ceph/src/boost/libs/spirit/test/karma/alternative1.cpp

   1 //  Copyright (c) 2001-2011 Hartmut Kaiser
   2 //
   3 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
   4 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #include <boost/spirit/include/karma_alternative.hpp>
   7
   8 #include <boost/spirit/include/karma_auxiliary.hpp>
   9 #include <boost/spirit/include/karma_char.hpp>
  10 #include <boost/spirit/include/karma_string.hpp>
  11 #include <boost/spirit/include/karma_numeric.hpp>
  12 #include <boost/spirit/include/karma_generate.hpp>
  13 #include <boost/spirit/include/karma_operator.hpp>
  14 #include <boost/spirit/include/karma_directive.hpp>
  15 #include <boost/spirit/include/karma_nonterminal.hpp>
  16
  17 #include "test.hpp"
  18
  19 using namespace spirit_test;
  20
  21 ///////////////////////////////////////////////////////////////////////////////
  22 int
  23 main()
  24 {
  25     using namespace boost;
  26     using namespace boost::spirit;
  27     using namespace boost::spirit::ascii;
  28
  29     {
  30         BOOST_TEST(test("x", char_('x') | char_('i')));
  31         BOOST_TEST(test("xi", char_('x') << char_('i') | char_('i')));
  32         BOOST_TEST(test("i", char_('i') | char_('x') << char_('i')));
  33
  34         BOOST_TEST(test("x", buffer[char_('x')] | char_('i')));
  35
  36         variant<int, char> v (10);
  37         BOOST_TEST(test("10", char_ | int_, v));
  38         BOOST_TEST(test("10", int_ | char_, v));
  39         BOOST_TEST(test("a", lit('a') | char_ | int_, v));
  40         BOOST_TEST(test("a", char_ | lit('a') | int_, v));
  41         BOOST_TEST(test("10", int_ | lit('a') | char_, v));
  42
  43         v = 'c';
  44         BOOST_TEST(test("c", char_ | int_, v));
  45         BOOST_TEST(test("a", lit('a') | char_ | int_, v));
  46         BOOST_TEST(test("c", char_ | lit('a') | int_, v));
  47         BOOST_TEST(test("a", int_ | lit('a') | char_, v));
  48         BOOST_TEST(test("c", int_ | char_ | lit('a'), v));
  49     }
  50
  51     // testing for alignment/truncation problems on little endian systems
  52     // (big endian systems will fail one of the other tests below)
  53     {
  54         // test optional attribute
  55         optional<variant<int, char> > v;
  56         BOOST_TEST(!test("", char_ | int_, v));
  57         BOOST_TEST(!test("", int_ | char_, v));
  58         BOOST_TEST(test("a", lit('a') | char_ | int_, v));
  59         BOOST_TEST(test("a", char_ | lit('a') | int_, v));
  60         BOOST_TEST(test("a", int_ | lit('a') | char_, v));
  61
  62         v = 10;
  63         BOOST_TEST(test("10", char_ | int_, v));
  64         BOOST_TEST(test("10", int_ | char_, v));
  65         BOOST_TEST(test("a", lit('a') | char_ | int_, v));
  66         BOOST_TEST(test("a", char_ | lit('a') | int_, v));
  67         BOOST_TEST(test("10", int_ | lit('a') | char_, v));
  68
  69         v = 'c';
  70         BOOST_TEST(test("c", char_ | int_, v));
  71         BOOST_TEST(test("a", lit('a') | char_ | int_, v));
  72         BOOST_TEST(test("c", char_ | lit('a') | int_, v));
  73         BOOST_TEST(test("a", int_ | lit('a') | char_, v));
  74         BOOST_TEST(test("c", int_ | char_ | lit('a'), v));
  75     }
  76
  77     {
  78         // more tests for optional attribute
  79         optional<int> o;
  80         BOOST_TEST(test("a", lit('a') | int_, o));
  81         BOOST_TEST(test("a", int_ | lit('a'), o));
  82
  83         o = 10;
  84         BOOST_TEST(test("a", lit('a') | int_, o));
  85         BOOST_TEST(test("10", int_ | lit('a'), o));
  86     }
  87
  88     {
  89         int i = 10;
  90         BOOST_TEST(test("a", lit('a') | int_, i));
  91         BOOST_TEST(test("10", int_ | lit('a'), i));
  92     }
  93
  94     {
  95         optional<std::string> o;
  96         BOOST_TEST(test("xyzzy", ("(" << string << ")") | lit("xyzzy"), o));
  97
  98         o = "plugh";
  99         BOOST_TEST(test("(plugh)", ("(" << string << ")") | lit("xyzzy"), o));
 100     }
 101
 102     {
 103         BOOST_TEST(test("abc", string | int_, std::string("abc")));
 104         BOOST_TEST(test("1234", string | int_, 1234));
 105         BOOST_TEST(test("abc", int_ | string, std::string("abc")));
 106         BOOST_TEST(test("1234", int_ | string, 1234));
 107     }
 108
 109     {
 110         // testing for alignment/truncation problems on little endian systems
 111         // (big endian systems will fail one of the other tests below)
 112         std::basic_string<wchar_t> generated;
 113         std::back_insert_iterator<std::basic_string<wchar_t> > outit(generated);
 114         boost::variant<int, char> v(10);
 115         bool result = karma::generate_delimited(outit
 116           , karma::int_ | karma::char_, karma::char_(' '), v);
 117         BOOST_TEST(result && generated == L"10 ");
 118     }
 119
 120     {
 121         boost::optional<int> v;
 122         BOOST_TEST(test("error", int_ | "error" << omit[-int_], v));
 123         BOOST_TEST(!test("error", int_ | "error" << omit[int_], v));
 124         BOOST_TEST(test("error", int_ | "error" << skip[int_], v));
 125         v = 1;
 126         BOOST_TEST(test("1", int_ | "error" << omit[-int_], v));
 127         BOOST_TEST(test("1", int_ | "error" << omit[int_], v));
 128         BOOST_TEST(test("1", int_ | "error" << skip[int_], v));
 129     }
 130
 131     {
 132         typedef spirit_test::output_iterator<char>::type outiter_type;
 133         namespace karma = boost::spirit::karma;
 134
 135         karma::rule<outiter_type, int()> r = int_;
 136         std::vector<int> v;
 137         BOOST_TEST(test("", '>' << r % ',' | karma::eps, v));
 138
 139         v.push_back(1);
 140         v.push_back(2);
 141         v.push_back(3);
 142         v.push_back(4);
 143         BOOST_TEST(test(">1,2,3,4", '>' << r % ',' | karma::eps, v));
 144     }
 145
 146     {
 147         typedef spirit_test::output_iterator<char>::type outiter_type;
 148         namespace karma = boost::spirit::karma;
 149
 150         karma::rule<outiter_type, boost::optional<int>()> r = int_;
 151         boost::optional<int> o;
 152         BOOST_TEST(test("error", r | "error", o));
 153
 154         o = 10;
 155         BOOST_TEST(test("10", r | "error", o));
 156     }
 157
 158     return boost::report_errors();
 159 }
 160