boost_1_45_0/libs/spirit/test/karma/sequence.cpp

//  Copyright (c) 2001-2010 Hartmut Kaiser
// 
//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// #define KARMA_TEST_COMPILE_FAIL

#include <boost/config/warning_disable.hpp>
#include <boost/detail/lightweight_test.hpp>

#include <boost/spirit/include/karma_char.hpp>
#include <boost/spirit/include/karma_string.hpp>
#include <boost/spirit/include/karma_numeric.hpp>
#include <boost/spirit/include/karma_generate.hpp>
#include <boost/spirit/include/karma_operator.hpp>
#include <boost/spirit/include/karma_directive.hpp>
#include <boost/spirit/include/karma_action.hpp>
#include <boost/spirit/include/karma_nonterminal.hpp>
#include <boost/spirit/include/karma_auxiliary.hpp>
#include <boost/spirit/include/karma_directive.hpp>
#include <boost/spirit/include/support_unused.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_statement.hpp>
#include <boost/spirit/include/phoenix_stl.hpp>
#include <boost/fusion/include/vector.hpp>

#include "test.hpp"

using namespace spirit_test;

///////////////////////////////////////////////////////////////////////////////
// lazy version of fusion::size
struct seqsize_impl
{
    template <typename Sequence>
    struct result 
      : boost::fusion::result_of::size<Sequence>
    {};

    template <typename Sequence>
    typename result<Sequence>::type
    operator()(Sequence const& seq) const
    {
        return boost::fusion::size(seq);
    }
};

boost::phoenix::function<seqsize_impl> const seqsize = seqsize_impl();

///////////////////////////////////////////////////////////////////////////////
int main()
{
    using namespace boost::spirit;
    using namespace boost::spirit::ascii;
    namespace fusion = boost::fusion;

    {
        {
            BOOST_TEST(test("xi", char_('x') << char_('i')));
            BOOST_TEST(!test("xi", char_('x') << char_('o')));
        }

        {
            BOOST_TEST(test_delimited("x i ", char_('x') << 'i', char(' ')));
            BOOST_TEST(!test_delimited("x i ", 
                char_('x') << char_('o'), char(' ')));
        }

        {
            BOOST_TEST(test_delimited("Hello , World ", 
                lit("Hello") << ',' << "World", char(' ')));
        }

        {
            // a single element
            char attr = 'a';
            BOOST_TEST((test("ab", char_ << 'b', attr)));
        }

        {
            // a single element fusion sequence
            fusion::vector<char> attr('a');
            BOOST_TEST((test("ab", char_ << 'b', attr)));
        }

        {
            fusion::vector<char, char, std::string> p ('a', 'b', "cdefg");
            BOOST_TEST(test("abcdefg", char_ << char_ << string, p));
            BOOST_TEST(test_delimited("a b cdefg ", 
                char_ << char_ << string, p, char(' ')));
        }

        {
            fusion::vector<char, int, char> p ('a', 12, 'c');
            BOOST_TEST(test("a12c", char_ << int_ << char_, p));
            BOOST_TEST(test_delimited("a 12 c ", 
                char_ << int_ << char_, p, char(' ')));
        }

        {
            // element sequence can be shorter and longer than the attribute 
            // sequence
            using boost::spirit::karma::strict;
            using boost::spirit::karma::relaxed;

            fusion::vector<char, int, char> p ('a', 12, 'c');
            BOOST_TEST(test("a12", char_ << int_, p));
            BOOST_TEST(test_delimited("a 12 ", char_ << int_, p, char(' ')));

            BOOST_TEST(test("a12", relaxed[char_ << int_], p));
            BOOST_TEST(test_delimited("a 12 ", relaxed[char_ << int_], p, char(' ')));

            BOOST_TEST(!test("", strict[char_ << int_], p));
            BOOST_TEST(!test_delimited("", strict[char_ << int_], p, char(' ')));

            fusion::vector<char, int> p1 ('a', 12);
            BOOST_TEST(test("a12c", char_ << int_ << char_('c'), p1));
            BOOST_TEST(test_delimited("a 12 c ", char_ << int_ << char_('c'), 
                p1, char(' ')));

            BOOST_TEST(test("a12c", relaxed[char_ << int_ << char_('c')], p1));
            BOOST_TEST(test_delimited("a 12 c ", 
                relaxed[char_ << int_ << char_('c')], p1, char(' ')));

            BOOST_TEST(!test("", strict[char_ << int_ << char_('c')], p1));
            BOOST_TEST(!test_delimited("", strict[char_ << int_ << char_('c')], 
                p1, char(' ')));

            BOOST_TEST(test("a12", strict[char_ << int_], p1));
            BOOST_TEST(test_delimited("a 12 ", strict[char_ << int_], p1, char(' ')));

            std::string value("foo ' bar");
            BOOST_TEST(test("\"foo ' bar\"", '"' << strict[*(~char_('*'))] << '"', value));
            BOOST_TEST(test("\"foo ' bar\"", strict['"' << *(~char_('*')) << '"'], value));
        }

        {
            // if all elements of a sequence have unused parameters, the whole 
            // sequence has an unused parameter as well
            fusion::vector<char, char> p ('a', 'e');
            BOOST_TEST(test("abcde", 
                char_ << (lit('b') << 'c' << 'd') << char_, p));
            BOOST_TEST(test_delimited("a b c d e ", 
                char_ << (lit('b') << 'c' << 'd') << char_, p, char(' ')));
        }

        {
            // literal generators do not need an attribute
            fusion::vector<char, char> p('a', 'c');
            BOOST_TEST(test("abc", char_ << 'b' << char_, p));
            BOOST_TEST(test_delimited("a b c ", 
                char_ << 'b' << char_, p, char(' ')));
        }

        {
            // literal generators do not need an attribute, not even at the end
            fusion::vector<char, char> p('a', 'c');
            BOOST_TEST(test("acb", char_ << char_ << 'b', p));
            BOOST_TEST(test_delimited("a c b ", 
                char_ << char_ << 'b', p, char(' ')));
        }

        {
            std::list<int> v;
            v.push_back(1);
            v.push_back(2);
            v.push_back(3);
            BOOST_TEST(test("123", int_ << int_ << int_, v));
//             BOOST_TEST(test_delimited("1 2 3 ", int_ << int_ << int_, v, ' '));
//             BOOST_TEST(test("1,2,3", int_ << ',' << int_ << ',' << int_, v));
//             BOOST_TEST(test_delimited("1 , 2 , 3 ", 
//                 int_ << ',' << int_ << ',' << int_, v, ' '));
        }

        {
            BOOST_TEST(test("aa", lower[char_('A') << 'a']));
            BOOST_TEST(test_delimited("BEGIN END ", 
                upper[lit("begin") << "end"], char(' ')));
            BOOST_TEST(!test_delimited("BEGIN END ", 
                upper[lit("begin") << "nend"], char(' ')));

            BOOST_TEST(test("Aa        ", left_align[char_('A') << 'a']));
            BOOST_TEST(test("    Aa    ", center[char_('A') << 'a']));
            BOOST_TEST(test("        Aa", right_align[char_('A') << 'a']));
        }

        {
            // make sure single element tuples get passed through if the rhs 
            // has a single element tuple as its attribute
            typedef spirit_test::output_iterator<char>::type iterator_type;
            fusion::vector<double, int> fv(2.0, 1);
            karma::rule<iterator_type, fusion::vector<double, int>()> r;
            r %= double_ << ',' << int_;
            BOOST_TEST(test("test:2.0,1", "test:" << r, fv));
        }

        // action tests
        {
            using namespace boost::phoenix;

            BOOST_TEST(test("abcdefg", 
                (char_ << char_ << string)[_1 = 'a', _2 = 'b', _3 = "cdefg"]));
            BOOST_TEST(test_delimited("a b cdefg ", 
                (char_ << char_ << string)[_1 = 'a', _2 = 'b', _3 = "cdefg"], 
                char(' ')));

            BOOST_TEST(test_delimited("a 12 c ", 
                (char_ << lit(12) << char_)[_1 = 'a', _2 = 'c'], char(' ')));

            char c = 'c';
            BOOST_TEST(test("abc", 
                (char_[_1 = 'a'] << 'b' << char_)[_1 = 'x', _2 = ref(c)]));
            BOOST_TEST(test_delimited("a b c ", 
                (char_[_1 = 'a'] << 'b' << char_)[_2 = ref(c)], char(' ')));

            BOOST_TEST(test("aa", lower[char_ << 'A'][_1 = 'A']));
            BOOST_TEST(test("AA", upper[char_ << 'a'][_1 = 'a']));

            BOOST_TEST(test("Aa        ", left_align[char_ << 'a'][_1 = 'A']));
            BOOST_TEST(test("    Aa    ", center[char_ << 'a'][_1 = 'A']));
            BOOST_TEST(test("        Aa", right_align[char_ << 'a'][_1 = 'A']));
        }
    }

    // test special case where sequence has a one element vector attribute 
    // sequence and this element is a rule (attribute has to be passed through 
    // without change)
    {
        typedef spirit_test::output_iterator<char>::type outiter_type;
        namespace karma = boost::spirit::karma;

        karma::rule<outiter_type, std::vector<int>()> r = -(int_ % ',');
        std::vector<int> v;
        BOOST_TEST(test(">", '>' << r, v));

        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);
        BOOST_TEST(test(">1,2,3,4", '>' << r, v));
    }

    {
        namespace karma = boost::spirit::karma;
        typedef spirit_test::output_iterator<char>::type outiter_type;

        karma::rule<outiter_type, std::string()> e = karma::string;
        karma::rule<outiter_type, std::vector<std::string>()> l = e << *(',' << e);

        std::vector<std::string> v;
        v.push_back("abc1");
        v.push_back("abc2");
        v.push_back("abc3");
        BOOST_TEST(test("abc1,abc2,abc3", l, v));
    }

    {
        namespace karma = boost::spirit::karma;
        namespace phoenix = boost::phoenix;

        typedef spirit_test::output_iterator<char>::type outiter_type;
        typedef fusion::vector<char, char, char> vector_type;
        
        vector_type p ('a', 'b', 'c');
        BOOST_TEST(test("ab", char_ << char_, p));

        karma::rule<outiter_type, vector_type()> r;
        r %= char_ << char_ << &karma::eps[seqsize(_val) == 3];
        BOOST_TEST(!test("", r, p));

        r %= char_ << char_ << char_ << &karma::eps[seqsize(_val) == 3];
        BOOST_TEST(test("abc", r, p));
    }

    {
        std::list<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);

        BOOST_TEST(test("1234", repeat(2)[int_] << *int_, v));
        BOOST_TEST(test_delimited("1 2 3 4 ", repeat(2)[int_] << *int_, v, char(' ')));
    }

    return boost::report_errors();
}