| // 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(); |
| } |
| |