diff options
Diffstat (limited to 'src/boost/libs/spirit/test/karma')
88 files changed, 10614 insertions, 0 deletions
diff --git a/src/boost/libs/spirit/test/karma/Jamfile b/src/boost/libs/spirit/test/karma/Jamfile new file mode 100644 index 00000000..953bdb02 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/Jamfile @@ -0,0 +1,137 @@ +#============================================================================== +# Copyright (c) 2001-2011 Joel de Guzman +# Copyright (c) 2001-2012 Hartmut Kaiser +# Copyright (c) 2011 Bryce Lelbach +# Copyright (c) 2016-2019 Nikita Kniazev +# +# Use, modification and distribution is subject to 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) +#============================================================================== + +import testing ; + +############################################################################### + +project spirit-karma + : requirements + <include>. + <c++-template-depth>512 + ; + +############################################################################### + +cpp-pch pch : pch.hpp : : : <include>. <toolset>msvc:<cxxflags>"/FIpch.hpp" ; + +explicit pch ; + +############################################################################### + +local subproject-name = karma ; + +rule run ( sources + : args * : input-files * + : requirements * : target-name ? : default-build * ) +{ + target-name ?= $(subproject-name)_$(sources[1]:D=:S=) ; + return [ testing.run $(sources) : $(args) : $(input-files) + : $(requirements) <pch>on-spirit:<source>pch : $(target-name) : $(default-build) ] ; +} + +rule compile ( sources + : requirements * : target-name ? ) +{ + target-name ?= $(subproject-name)_$(sources[1]:D=:S=) ; + return [ testing.compile $(sources) + : $(requirements) <pch>on-spirit:<source>pch : $(target-name) ] ; +} + +rule compile-fail ( sources + : requirements * : target-name ? ) +{ + target-name ?= $(subproject-name)_$(sources[1]:D=:S=) ; + return [ testing.compile-fail $(sources) + : $(requirements) <pch>on-spirit:<source>pch : $(target-name) ] ; +} + +############################################################################### + +compile-fail grammar_fail.cpp ; +compile-fail rule_fail.cpp ; +run actions.cpp ; +run alternative1.cpp ; +run alternative2.cpp ; +run and_predicate.cpp ; +run attribute.cpp ; +run auto1.cpp ; +run auto2.cpp ; +run auto3.cpp ; +run binary1.cpp ; +run binary2.cpp ; +run binary3.cpp ; +run bool.cpp ; +run buffer.cpp ; +run case_handling1.cpp ; +run case_handling2.cpp ; +run case_handling3.cpp ; +run center_alignment.cpp ; +run char1.cpp ; +run char2.cpp ; +run char3.cpp ; +run char_class.cpp ; +run columns.cpp ; +run debug.cpp : : : <pch>off ; +run delimiter.cpp ; +run duplicate.cpp ; +run encoding.cpp ; +run eol.cpp ; +run eps.cpp ; +run format_manip.cpp ; +run format_manip_attr.cpp ; +run format_pointer_container.cpp ; +run generate_attr.cpp ; +run grammar.cpp ; +run int1.cpp ; +run int2.cpp ; +run int3.cpp ; +run kleene.cpp ; +run lazy.cpp ; +run left_alignment.cpp ; +run list.cpp ; +run lit.cpp ; +run maxwidth.cpp ; +run not_predicate.cpp ; +run omit.cpp ; +run optional.cpp ; +run pattern1.cpp ; +run pattern2.cpp ; +run pattern3.cpp ; +run pattern4.cpp ; +run plus.cpp ; +run real1.cpp ; +run real2.cpp ; +run real3.cpp ; +run repeat1.cpp ; +run repeat2.cpp ; +run right_alignment.cpp ; +run sequence1.cpp ; +run sequence2.cpp ; +run stream.cpp ; +run symbols1.cpp ; +run symbols2.cpp ; +run symbols3.cpp ; +run tricky_alignment.cpp ; +run uint_radix.cpp ; +run utree1.cpp ; +run utree2.cpp ; +run utree3.cpp ; +run wstream.cpp ; + +compile regression_const_real_policies.cpp ; +run regression_adapt_adt.cpp ; +run regression_center_alignment.cpp ; +run regression_container_variant_sequence.cpp ; +run regression_iterator.cpp ; +run regression_optional_double.cpp ; +run regression_real_0.cpp ; +run regression_real_policy_sign.cpp ; +run regression_real_scientific.cpp ; +run regression_semantic_action_attribute.cpp ; +run regression_unicode_char.cpp : : : <pch>off ; diff --git a/src/boost/libs/spirit/test/karma/actions.cpp b/src/boost/libs/spirit/test/karma/actions.cpp new file mode 100644 index 00000000..2f3623e5 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/actions.cpp @@ -0,0 +1,137 @@ +/*============================================================================= + Copyright (c) 2001-2011 Hartmut Kaiser + Copyright (c) 2001-2011 Joel de Guzman + + 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) +=============================================================================*/ + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/bind.hpp> +#include <boost/lambda/lambda.hpp> + +#include <sstream> +#include "test.hpp" + +using namespace spirit_test; +using boost::spirit::unused_type; + +void read1(int& i) +{ + i = 42; +} + +void read2(int& i, unused_type) +{ + i = 42; +} + +void read3(int& i, unused_type, bool&) +{ + i = 42; +} + +void read3_fail(int& i, unused_type, bool& pass) +{ + i = 42; + pass = false; +} + +struct read_action +{ + void operator()(int& i, unused_type, unused_type) const + { + i = 42; + } +}; + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using boost::spirit::karma::int_; + { + BOOST_TEST(test("42", int_[&read1])); + BOOST_TEST(test_delimited("42 ", int_[&read1], ' ')); + BOOST_TEST(test("42", int_[&read2])); + BOOST_TEST(test_delimited("42 ", int_[&read2], ' ')); + BOOST_TEST(test("42", int_[&read3])); + BOOST_TEST(test_delimited("42 ", int_[&read3], ' ')); + BOOST_TEST(!test("42", int_[&read3_fail])); + BOOST_TEST(!test_delimited("42 ", int_[&read3_fail], ' ')); + } + + { + BOOST_TEST(test("42", int_[read_action()])); + BOOST_TEST(test_delimited("42 ", int_[read_action()], ' ')); + } + + { + BOOST_TEST(test("42", int_[boost::bind(&read1, _1)])); + BOOST_TEST(test_delimited("42 ", int_[boost::bind(&read1, _1)], ' ')); + BOOST_TEST(test("42", int_[boost::bind(&read2, _1, _2)])); + BOOST_TEST(test_delimited("42 ", int_[boost::bind(&read2, _1, _2)], ' ')); + BOOST_TEST(test("42", int_[boost::bind(&read3, _1, _2, _3)])); + BOOST_TEST(test_delimited("42 ", int_[boost::bind(&read3, _1, _2, _3)], ' ')); + } + + { + namespace lambda = boost::lambda; + { + std::stringstream strm("42"); + BOOST_TEST(test("42", int_[strm >> lambda::_1])); + } + { + std::stringstream strm("42"); + BOOST_TEST(test_delimited("42 ", int_[strm >> lambda::_1], ' ')); + } + } + + { + BOOST_TEST(test("{42}", '{' << int_[&read1] << '}')); + BOOST_TEST(test_delimited("{ 42 } ", '{' << int_[&read1] << '}', ' ')); + BOOST_TEST(test("{42}", '{' << int_[&read2] << '}')); + BOOST_TEST(test_delimited("{ 42 } ", '{' << int_[&read2] << '}', ' ')); + BOOST_TEST(test("{42}", '{' << int_[&read3] << '}')); + BOOST_TEST(test_delimited("{ 42 } ", '{' << int_[&read3] << '}', ' ')); + } + + { + BOOST_TEST(test("{42}", '{' << int_[read_action()] << '}')); + BOOST_TEST(test_delimited("{ 42 } ", '{' << int_[read_action()] << '}', ' ')); + } + + { + BOOST_TEST(test("{42}", '{' << int_[boost::bind(&read1, _1)] << '}')); + BOOST_TEST(test_delimited("{ 42 } ", + '{' << int_[boost::bind(&read1, _1)] << '}', ' ')); + BOOST_TEST(test("{42}", '{' << int_[boost::bind(&read2, _1, _2)] << '}')); + BOOST_TEST(test_delimited("{ 42 } ", + '{' << int_[boost::bind(&read2, _1, _2)] << '}', ' ')); + BOOST_TEST(test("{42}", '{' << int_[boost::bind(&read3, _1, _2, _3)] << '}')); + BOOST_TEST(test_delimited("{ 42 } ", + '{' << int_[boost::bind(&read3, _1, _2, _3)] << '}', ' ')); + } + + { + namespace lambda = boost::lambda; + { + std::stringstream strm("42"); + BOOST_TEST(test("{42}", '{' << int_[strm >> lambda::_1] << '}')); + } + { + std::stringstream strm("42"); + BOOST_TEST(test_delimited("{ 42 } ", + '{' << int_[strm >> lambda::_1] << '}', ' ')); + } + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/alternative1.cpp b/src/boost/libs/spirit/test/karma/alternative1.cpp new file mode 100644 index 00000000..461e4b06 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/alternative1.cpp @@ -0,0 +1,162 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_auxiliary.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_nonterminal.hpp> +#include <boost/spirit/include/karma_auxiliary.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + BOOST_TEST(test("x", char_('x') | char_('i'))); + BOOST_TEST(test("xi", char_('x') << char_('i') | char_('i'))); + BOOST_TEST(test("i", char_('i') | char_('x') << char_('i'))); + + BOOST_TEST(test("x", buffer[char_('x')] | char_('i'))); + + variant<int, char> v (10); + BOOST_TEST(test("10", char_ | int_, v)); + BOOST_TEST(test("10", int_ | char_, v)); + BOOST_TEST(test("a", lit('a') | char_ | int_, v)); + BOOST_TEST(test("a", char_ | lit('a') | int_, v)); + BOOST_TEST(test("10", int_ | lit('a') | char_, v)); + + v = 'c'; + BOOST_TEST(test("c", char_ | int_, v)); + BOOST_TEST(test("a", lit('a') | char_ | int_, v)); + BOOST_TEST(test("c", char_ | lit('a') | int_, v)); + BOOST_TEST(test("a", int_ | lit('a') | char_, v)); + BOOST_TEST(test("c", int_ | char_ | lit('a'), v)); + } + + // testing for alignment/truncation problems on little endian systems + // (big endian systems will fail one of the other tests below) + { + // test optional attribute + optional<variant<int, char> > v; + BOOST_TEST(!test("", char_ | int_, v)); + BOOST_TEST(!test("", int_ | char_, v)); + BOOST_TEST(test("a", lit('a') | char_ | int_, v)); + BOOST_TEST(test("a", char_ | lit('a') | int_, v)); + BOOST_TEST(test("a", int_ | lit('a') | char_, v)); + + v = 10; + BOOST_TEST(test("10", char_ | int_, v)); + BOOST_TEST(test("10", int_ | char_, v)); + BOOST_TEST(test("a", lit('a') | char_ | int_, v)); + BOOST_TEST(test("a", char_ | lit('a') | int_, v)); + BOOST_TEST(test("10", int_ | lit('a') | char_, v)); + + v = 'c'; + BOOST_TEST(test("c", char_ | int_, v)); + BOOST_TEST(test("a", lit('a') | char_ | int_, v)); + BOOST_TEST(test("c", char_ | lit('a') | int_, v)); + BOOST_TEST(test("a", int_ | lit('a') | char_, v)); + BOOST_TEST(test("c", int_ | char_ | lit('a'), v)); + } + + { + // more tests for optional attribute + optional<int> o; + BOOST_TEST(test("a", lit('a') | int_, o)); + BOOST_TEST(test("a", int_ | lit('a'), o)); + + o = 10; + BOOST_TEST(test("a", lit('a') | int_, o)); + BOOST_TEST(test("10", int_ | lit('a'), o)); + } + + { + int i = 10; + BOOST_TEST(test("a", lit('a') | int_, i)); + BOOST_TEST(test("10", int_ | lit('a'), i)); + } + + { + optional<std::string> o; + BOOST_TEST(test("xyzzy", ("(" << string << ")") | lit("xyzzy"), o)); + + o = "plugh"; + BOOST_TEST(test("(plugh)", ("(" << string << ")") | lit("xyzzy"), o)); + } + + { + BOOST_TEST(test("abc", string | int_, std::string("abc"))); + BOOST_TEST(test("1234", string | int_, 1234)); + BOOST_TEST(test("abc", int_ | string, std::string("abc"))); + BOOST_TEST(test("1234", int_ | string, 1234)); + } + + { + // testing for alignment/truncation problems on little endian systems + // (big endian systems will fail one of the other tests below) + std::basic_string<wchar_t> generated; + std::back_insert_iterator<std::basic_string<wchar_t> > outit(generated); + boost::variant<int, char> v(10); + bool result = karma::generate_delimited(outit + , karma::int_ | karma::char_, karma::char_(' '), v); + BOOST_TEST(result && generated == L"10 "); + } + + { + boost::optional<int> v; + BOOST_TEST(test("error", int_ | "error" << omit[-int_], v)); + BOOST_TEST(!test("error", int_ | "error" << omit[int_], v)); + BOOST_TEST(test("error", int_ | "error" << skip[int_], v)); + v = 1; + BOOST_TEST(test("1", int_ | "error" << omit[-int_], v)); + BOOST_TEST(test("1", int_ | "error" << omit[int_], v)); + BOOST_TEST(test("1", int_ | "error" << skip[int_], v)); + } + + { + typedef spirit_test::output_iterator<char>::type outiter_type; + namespace karma = boost::spirit::karma; + + karma::rule<outiter_type, int()> r = int_; + std::vector<int> v; + BOOST_TEST(test("", '>' << r % ',' | karma::eps, 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 % ',' | karma::eps, v)); + } + + { + typedef spirit_test::output_iterator<char>::type outiter_type; + namespace karma = boost::spirit::karma; + + karma::rule<outiter_type, boost::optional<int>()> r = int_; + boost::optional<int> o; + BOOST_TEST(test("error", r | "error", o)); + + o = 10; + BOOST_TEST(test("10", r | "error", o)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/alternative2.cpp b/src/boost/libs/spirit/test/karma/alternative2.cpp new file mode 100644 index 00000000..7e90b165 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/alternative2.cpp @@ -0,0 +1,141 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_auxiliary.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_nonterminal.hpp> +#include <boost/spirit/include/karma_auxiliary.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + // test if alternatives with all components having unused + // attribute generate first alternative + fusion::vector<char, char> v('a', 'b'); + BOOST_TEST(test("axb", char_ << (lit('x') | lit('i')) << char_, v)); + BOOST_TEST(test("axib", + char_ << (lit('x') << lit('i') | lit('i')) << char_, v)); + } + + { + BOOST_TEST(test_delimited("x ", char_('x') | char_('i'), char_(' '))); + BOOST_TEST(test_delimited("x i ", + char_('x') << char_('i') | char_('i'), char_(' '))); + BOOST_TEST(test_delimited("i ", + char_('i') | char_('x') << char_('i'), char_(' '))); + + variant<int, char> v (10); + BOOST_TEST(test_delimited("10 ", char_ | int_, v, char_(' '))); + BOOST_TEST(test_delimited("10 ", int_ | char_, v, char_(' '))); + BOOST_TEST(test_delimited("a ", lit('a') | char_ | int_, v, char_(' '))); + BOOST_TEST(test_delimited("a ", char_ | lit('a') | int_, v, char_(' '))); + BOOST_TEST(test_delimited("10 ", int_ | lit('a') | char_, v, char_(' '))); + + v = 'c'; + BOOST_TEST(test_delimited("c ", char_ | int_, v, char_(' '))); + BOOST_TEST(test_delimited("a ", lit('a') | char_ | int_, v, char_(' '))); + BOOST_TEST(test_delimited("c ", char_ | lit('a') | int_, v, char_(' '))); + BOOST_TEST(test_delimited("a ", int_ | lit('a') | char_, v, char_(' '))); + BOOST_TEST(test_delimited("c ", int_ | char_ | lit('a'), v, char_(' '))); + } + +// this leads to infinite loops +// { +// variant<int, std::string> v(10); +// BOOST_TEST(test("10", int_ | +char_, v)); +// +// v = "abc"; +// BOOST_TEST(test("abc", int_ | +char_, v)); +// } + + { + // if nothing matches, the first explicit alternative will be chosen + variant<double, char const*> v (10.0); + BOOST_TEST(test("11", char_ | lit(11), v)); + BOOST_TEST(test("11", lit(11) | char_ , v)); + BOOST_TEST(test("10.0", double_ | lit(11), v)); + BOOST_TEST(test("11", lit(11) | double_, v)); + BOOST_TEST(!test("", char_ | int_, v)); + + v = "c"; + BOOST_TEST(test("11", char_ | lit(11), v)); + BOOST_TEST(test("11", double_ | lit(11), v)); + BOOST_TEST(!test("", char_ | int_, v)); + } + + { + // in strict mode if nothing matches, the alternative will fail + variant<double, char const*> v (10.0); + BOOST_TEST(!test("11", strict[char_ | lit(11)], v)); + BOOST_TEST(test("11", strict[lit(11) | char_] , v)); + + v = "c"; + BOOST_TEST(!test("11", strict[char_ | lit(11)], v)); + } + + { + // if nothing matches, the first explicit alternative will be chosen + variant<double, char const*> v (10.0); + BOOST_TEST(test_delimited("11 ", char_ | lit(11), v, char_(' '))); + BOOST_TEST(test_delimited("11 ", lit(11) | char_ , v, char_(' '))); + BOOST_TEST(test_delimited("10.0 ", double_ | lit(11), v, char_(' '))); + BOOST_TEST(test_delimited("11 ", lit(11) | double_, v, char_(' '))); + BOOST_TEST(!test_delimited("", char_ | int_, v, char_(' '))); + + v = "c"; + BOOST_TEST(test_delimited("11 ", char_ | lit(11), v, char_(' '))); + BOOST_TEST(test_delimited("11 ", double_ | lit(11), v, char_(' '))); + BOOST_TEST(!test_delimited("", char_ | int_, v, char_(' '))); + } + + { + // if nothing matches, the first explicit alternative will be chosen, + // optionals need to be accepted + optional<variant<double, char const*> > v (10.0); + BOOST_TEST(test_delimited("11 ", char_ | lit(11), v, char_(' '))); + BOOST_TEST(test_delimited("11 ", lit(11) | char_ , v, char_(' '))); + BOOST_TEST(test_delimited("10.0 ", double_ | lit(11), v, char_(' '))); + BOOST_TEST(test_delimited("11 ", lit(11) | double_, v, char_(' '))); + BOOST_TEST(!test_delimited("", char_ | int_, v, char_(' '))); + + v = "c"; + BOOST_TEST(test_delimited("11 ", char_ | lit(11), v, char_(' '))); + BOOST_TEST(test_delimited("11 ", double_ | lit(11), v, char_(' '))); + BOOST_TEST(!test_delimited("", char_ | int_, v, char_(' '))); + } + + { + std::vector<int> v; + BOOST_TEST(test("[]", '[' << (int_ % ", ") << ']' | "[]", v)); + BOOST_TEST(test("[]", '[' << -(int_ % ", ") << ']', v)); + BOOST_TEST(test("[]", '[' << ((int_ % ", ") | eps) << ']', v)); + + v.push_back(5); + v.push_back(5); + v.push_back(5); + BOOST_TEST(test("[5, 5, 5]", '[' << (int_ % ", ") << ']' | "[]", v)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/and_predicate.cpp b/src/boost/libs/spirit/test/karma/and_predicate.cpp new file mode 100644 index 00000000..83965856 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/and_predicate.cpp @@ -0,0 +1,36 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.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_auxiliary.hpp> +#include <boost/spirit/include/karma_char.hpp> + +#include <iostream> +#include "test.hpp" + +int +main() +{ + using namespace spirit_test; + using namespace boost::spirit; + + { + BOOST_TEST(test("1", int_(1) << &(int_(2) << &int_(3) << int_(4)))); + } + + { + using boost::spirit::ascii::char_; + + BOOST_TEST(test("b", &char_('a') << 'b' | 'c', 'a')); + BOOST_TEST(test("c", &char_('a') << 'b' | 'c', 'x')); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/attribute.cpp b/src/boost/libs/spirit/test/karma/attribute.cpp new file mode 100644 index 00000000..6fdafdc9 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/attribute.cpp @@ -0,0 +1,214 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/phoenix_limits.hpp> + +#include <boost/fusion/include/struct.hpp> +#include <boost/fusion/include/nview.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_operator.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_auxiliary.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +struct test_data +{ + std::string s1; + std::string s2; + int i1; + double d1; + std::string s3; +}; + +BOOST_FUSION_ADAPT_STRUCT( + test_data, + (int, i1) + (std::string, s1) + (std::string, s2) + (std::string, s3) + (double, d1) +) + +/////////////////////////////////////////////////////////////////////////////// +// this is just a test structure we need to use in place of an int +struct test_int_data1 +{ + int i; +}; + +// so we provide a custom attribute transformation +namespace boost { namespace spirit { namespace traits +{ + template <> + struct transform_attribute<test_int_data1 const, int, karma::domain> + { + typedef int type; + static int pre(test_int_data1 const& d) { return d.i; } + }; +}}} + +/////////////////////////////////////////////////////////////////////////////// +// this is another test structure we need to use in place of an int, but this +// time we use a reference to the embedded element +struct test_int_data2 +{ + int i; +}; + +// so we provide a custom attribute transformation +namespace boost { namespace spirit { namespace traits +{ + template <> + struct transform_attribute<test_int_data2 const, int, karma::domain> + { + typedef int const& type; + static int const& pre(test_int_data2 const& d) { return d.i; } + }; +}}} + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + namespace fusion = boost::fusion; + namespace karma = boost::spirit::karma; + + test_data d1 = { "s11", "s12", 1, 2.5, "s13" }; + { + + BOOST_TEST(test("s121", + karma::string << karma::int_, + fusion::as_nview<2, 0>(d1))); + + BOOST_TEST(test_delimited("s12 1 ", + karma::string << karma::int_, + fusion::as_nview<2, 0>(d1), ' ')); + } + + { + test_data d2 = { "s21", "s22", 2, 3.4, "s23" }; + typedef fusion::result_of::as_nview<test_data const, 1, 2, 4>::type + test_view; + std::vector<test_data> v; + v.push_back(d1); + v.push_back(d2); + + karma::rule<output_iterator<char>::type, test_view()> r = + karma::string << karma::string << karma::double_; + + BOOST_TEST(test("s11s122.5\ns21s223.4", r % karma::eol, v)); + BOOST_TEST(test_delimited("s11s122.5 \n s21s223.4 ", + r % karma::eol, v, ' ')); + } + + { + test_int_data1 d = { 1 }; + BOOST_TEST(test("1", karma::attr_cast(karma::int_), d)); + BOOST_TEST(test("1", karma::attr_cast<test_int_data1>(karma::int_), d)); + BOOST_TEST(test("1", karma::attr_cast<test_int_data1, int>(karma::int_), d)); + } + + { + test_int_data1 d[] = {{ 1 }, { 2 }}; + std::vector<test_int_data1> v; + v.push_back(d[0]); + v.push_back(d[1]); + + BOOST_TEST(test("1,2", karma::attr_cast(karma::int_) % ',', v)); + BOOST_TEST(test("1,2" + , karma::attr_cast<test_int_data1>(karma::int_) % ',', v)); + BOOST_TEST(test("1,2" + , karma::attr_cast<test_int_data1, int>(karma::int_) % ',', v)); + } + + { + test_int_data1 d[] = {{ 1 }, { 2 }}; + std::vector<test_int_data1> v; + v.push_back(d[0]); + v.push_back(d[1]); + + karma::rule<output_iterator<char>::type, int()> r = karma::int_; + BOOST_TEST(test("1,2", r % ',', v)); + } + + { + test_int_data1 d[] = {{ 1 }, { 2 }}; + std::vector<test_int_data1> v; + v.push_back(d[0]); + v.push_back(d[1] ); + +// this won't compile as there is no defined transformation for +// test_int_data1 and double +// BOOST_TEST(test("1.0,2.0", karma::attr_cast(karma::double_) % ',', v)); +// BOOST_TEST(test("1.0,2.0" +// , karma::attr_cast<test_int_data1>(karma::double_) % ',', v)); + + BOOST_TEST(test("1.0,2.0" + , karma::attr_cast<test_int_data1, int>(karma::double_) % ',', v)); + + karma::rule<output_iterator<char>::type, int()> r = karma::double_; + BOOST_TEST(test("1.0,2.0", r % ',', v)); + } + + { + test_int_data2 d = { 1 }; + BOOST_TEST(test("1", karma::attr_cast(karma::int_), d)); + BOOST_TEST(test("1", karma::attr_cast<test_int_data2>(karma::int_), d)); + BOOST_TEST(test("1", karma::attr_cast<test_int_data2, int>(karma::int_), d)); + } + + { + test_int_data2 d[] = {{ 1 }, { 2 }}; + std::vector<test_int_data2> v; + v.push_back(d[0]); + v.push_back(d[1]); + + BOOST_TEST(test("1,2", karma::attr_cast(karma::int_) % ',', v)); + BOOST_TEST(test("1,2" + , karma::attr_cast<test_int_data2>(karma::int_) % ',', v)); + BOOST_TEST(test("1,2" + , karma::attr_cast<test_int_data2, int>(karma::int_) % ',', v)); + } + + { + test_int_data2 d[] = {{ 1 }, { 2 }}; + std::vector<test_int_data2> v; + v.push_back(d[0]); + v.push_back(d[1]); + + karma::rule<output_iterator<char>::type, int()> r = karma::int_; + BOOST_TEST(test("1,2", r % ',', v)); + } + + { + test_int_data2 d[] = {{ 1 }, { 2 }}; + std::vector<test_int_data2> v; + v.push_back(d[0]); + v.push_back(d[1] ); + +// this won't compile as there is no defined transformation for +// test_int_data2 and double +// BOOST_TEST(test("1.0,2.0", karma::attr_cast(karma::double_) % ',', v)); +// BOOST_TEST(test("1.0,2.0" +// , karma::attr_cast<test_int_data2>(karma::double_) % ',', v)); + + BOOST_TEST(test("1.0,2.0" + , karma::attr_cast<test_int_data2, int>(karma::double_) % ',', v)); + + karma::rule<output_iterator<char>::type, int()> r = karma::double_; + BOOST_TEST(test("1.0,2.0", r % ',', v)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/auto.hpp b/src/boost/libs/spirit/test/karma/auto.hpp new file mode 100644 index 00000000..a2d1ae79 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/auto.hpp @@ -0,0 +1,79 @@ +// 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) + +#if !defined(BOOST_SPIRIT_TEST_AUTO_HPP) +#define BOOST_SPIRIT_TEST_AUTO_HPP + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/fusion/include/std_pair.hpp> +#include <boost/spirit/include/karma_bool.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_auto.hpp> + +#include "test.hpp" + +namespace karma = boost::spirit::karma; +namespace traits = boost::spirit::traits; + +/////////////////////////////////////////////////////////////////////////////// +template <typename Char, typename T> +bool test_create_generator(Char const *expected, T const& t) +{ + std::basic_string<Char> generated; + std::back_insert_iterator<std::basic_string<Char> > sink(generated); + + BOOST_TEST((traits::meta_create_exists<karma::domain, T>::value)); + bool result = karma::generate(sink, karma::create_generator<T>(), t); + + spirit_test::print_if_failed("test_create_generator", result, generated, expected); + return result && generated == expected; +} + +template <typename Char, typename T> +bool test_create_generator_auto(Char const *expected, T const& t) +{ + std::basic_string<Char> generated; + std::back_insert_iterator<std::basic_string<Char> > sink(generated); + + BOOST_TEST((traits::meta_create_exists<karma::domain, T>::value)); + bool result = karma::generate(sink, t); + + spirit_test::print_if_failed("test_create_generator (auto)", result, generated, expected); + return result && generated == expected; +} + +template <typename Char, typename Attribute> +bool test_rule(Char const *expected, Attribute const& attr) +{ + BOOST_TEST((traits::meta_create_exists<karma::domain, Attribute>::value)); + + typedef typename spirit_test::output_iterator<Char>::type sink_type; + karma::rule<sink_type, Attribute()> r = + karma::create_generator<Attribute>(); + return spirit_test::test(expected, r, attr); +} + +template <typename Char, typename Attribute, typename Delimiter> +bool test_rule_delimited(Char const *expected, Attribute const& attr + , Delimiter const& d) +{ + BOOST_TEST((traits::meta_create_exists<karma::domain, Attribute>::value)); + + typedef typename spirit_test::output_iterator<Char>::type sink_type; + karma::rule<sink_type, Attribute(), Delimiter> r = + karma::create_generator<Attribute>(); + return spirit_test::test_delimited(expected, r, attr, d); +} + +struct my_type {}; + +#endif diff --git a/src/boost/libs/spirit/test/karma/auto1.cpp b/src/boost/libs/spirit/test/karma/auto1.cpp new file mode 100644 index 00000000..a3b4850f --- /dev/null +++ b/src/boost/libs/spirit/test/karma/auto1.cpp @@ -0,0 +1,104 @@ +// Copyright (c) 2001-2011 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) + +#include "auto.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + { + BOOST_TEST((!traits::meta_create_exists<karma::domain, my_type>::value)); + } + + { + // test primitive types + BOOST_TEST(test_create_generator("true", true)); + BOOST_TEST(test_create_generator("1", 1)); + BOOST_TEST(test_create_generator("1.1", 1.1)); + BOOST_TEST(test_create_generator("test", std::string("test"))); + BOOST_TEST(test_create_generator("a", 'a')); + BOOST_TEST(test_create_generator(L"a", L'a')); + + // test containers + std::vector<int> v; + v.push_back(0); + v.push_back(1); + v.push_back(2); + BOOST_TEST(test_create_generator("012", v)); + + std::list<int> l; + l.push_back(0); + l.push_back(1); + l.push_back(2); + BOOST_TEST(test_create_generator("012", l)); + + // test optional + boost::optional<int> o; + BOOST_TEST(test_create_generator("", o)); + o = 1; + BOOST_TEST(test_create_generator("1", o)); + + // test alternative + boost::variant<int, double, float, std::string> vv; + vv = 1; + BOOST_TEST(test_create_generator("1", vv)); + vv = 1.0; + BOOST_TEST(test_create_generator("1.0", vv)); + vv = 1.0f; + BOOST_TEST(test_create_generator("1.0", vv)); + vv = "some string"; + BOOST_TEST(test_create_generator("some string", vv)); + + // test fusion sequence + std::pair<int, double> p (1, 2.0); + BOOST_TEST(test_create_generator("12.0", p)); + } + + { + // test primitive types +// BOOST_TEST(test_create_generator_auto("true", true)); +// BOOST_TEST(test_create_generator_auto("1", 1)); +// BOOST_TEST(test_create_generator_auto("1.1", 1.1)); +// BOOST_TEST(test_create_generator_auto("test", std::string("test"))); +// BOOST_TEST(test_create_generator_auto("a", 'a')); +// BOOST_TEST(test_create_generator_auto(L"a", L'a')); + + // test containers + std::vector<int> v; + v.push_back(0); + v.push_back(1); + v.push_back(2); + BOOST_TEST(test_create_generator_auto("012", v)); + + std::list<int> l; + l.push_back(0); + l.push_back(1); + l.push_back(2); + BOOST_TEST(test_create_generator_auto("012", l)); + + // test optional + boost::optional<int> o; + BOOST_TEST(test_create_generator_auto("", o)); + o = 1; + BOOST_TEST(test_create_generator_auto("1", o)); + + // test alternative + boost::variant<int, double, float, std::string> vv; + vv = 1; + BOOST_TEST(test_create_generator_auto("1", vv)); + vv = 1.0; + BOOST_TEST(test_create_generator_auto("1.0", vv)); + vv = 1.0f; + BOOST_TEST(test_create_generator_auto("1.0", vv)); + vv = "some string"; + BOOST_TEST(test_create_generator_auto("some string", vv)); + + // test fusion sequence + std::pair<int, double> p (1, 2.0); + BOOST_TEST(test_create_generator_auto("12.0", p)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/auto2.cpp b/src/boost/libs/spirit/test/karma/auto2.cpp new file mode 100644 index 00000000..4527b869 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/auto2.cpp @@ -0,0 +1,126 @@ +// 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) + +#include "auto.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + { + using karma::auto_; + using karma::upper; + using spirit_test::test; + using spirit_test::test_delimited; + + // test primitive types + BOOST_TEST(test("true", auto_, true)); + BOOST_TEST(test("1", auto_, 1)); + BOOST_TEST(test("1.1", auto_, 1.1)); + BOOST_TEST(test("test", auto_, "test")); + BOOST_TEST(test(L"test", auto_, L"test")); + BOOST_TEST(test("a", auto_, 'a')); + BOOST_TEST(test(L"a", auto_, L'a')); + + BOOST_TEST(test("TRUE", upper[auto_], true)); + BOOST_TEST(test("TEST", upper[auto_], "test")); + + // test containers + std::vector<int> v; + v.push_back(0); + v.push_back(1); + v.push_back(2); + BOOST_TEST(test("012", auto_, v)); + BOOST_TEST(test("0,1,2", auto_ % ',', v)); + BOOST_TEST(test_delimited("0,1,2,", auto_, v, ',')); + + std::list<int> l; + l.push_back(0); + l.push_back(1); + l.push_back(2); + BOOST_TEST(test("012", auto_, l)); + BOOST_TEST(test("0,1,2", auto_ % ',', l)); + BOOST_TEST(test_delimited("0,1,2,", auto_, l, ',')); + + // test optional + boost::optional<int> o; + BOOST_TEST(test("", auto_, o)); + o = 1; + BOOST_TEST(test("1", auto_, o)); + + // test alternative + boost::variant<int, double, float, std::string> vv; + vv = 1; + BOOST_TEST(test("1", auto_, vv)); + vv = 1.0; + BOOST_TEST(test("1.0", auto_, vv)); + vv = 1.0f; + BOOST_TEST(test("1.0", auto_, vv)); + vv = "some string"; + BOOST_TEST(test("some string", auto_, vv)); + + // test fusion sequence + std::pair<int, double> p (1, 2.0); + BOOST_TEST(test("12.0", auto_, p)); + BOOST_TEST(test_delimited("1,2.0,", auto_, p, ',')); + } + + { + using karma::auto_; + using karma::upper; + using spirit_test::test; + using spirit_test::test_delimited; + + // test primitive types + BOOST_TEST(test("true", auto_(true))); + BOOST_TEST(test("1", auto_(1))); + BOOST_TEST(test("1.1", auto_(1.1))); + BOOST_TEST(test("test", auto_("test"))); + BOOST_TEST(test(L"test", auto_(L"test"))); + BOOST_TEST(test("a", auto_('a'))); + BOOST_TEST(test(L"a", auto_(L'a'))); + + BOOST_TEST(test("TRUE", upper[auto_(true)])); + BOOST_TEST(test("TEST", upper[auto_("test")])); + + // test containers + std::vector<int> v; + v.push_back(0); + v.push_back(1); + v.push_back(2); + BOOST_TEST(test("012", auto_(v))); + BOOST_TEST(test_delimited("0,1,2,", auto_(v), ',')); + + std::list<int> l; + l.push_back(0); + l.push_back(1); + l.push_back(2); + BOOST_TEST(test("012", auto_(l))); + BOOST_TEST(test_delimited("0,1,2,", auto_(l), ',')); + + // test optional + boost::optional<int> o; + BOOST_TEST(test("", auto_(o))); + o = 1; + BOOST_TEST(test("1", auto_(o))); + + // test alternative + boost::variant<int, double, float, std::string> vv; + vv = 1; + BOOST_TEST(test("1", auto_(vv))); + vv = 1.0; + BOOST_TEST(test("1.0", auto_(vv))); + vv = 1.0f; + BOOST_TEST(test("1.0", auto_(vv))); + vv = "some string"; + BOOST_TEST(test("some string", auto_(vv))); + + // test fusion sequence + std::pair<int, double> p (1, 2.0); + BOOST_TEST(test("12.0", auto_, p)); + BOOST_TEST(test_delimited("1,2.0,", auto_(p), ',')); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/auto3.cpp b/src/boost/libs/spirit/test/karma/auto3.cpp new file mode 100644 index 00000000..ffbcdc9a --- /dev/null +++ b/src/boost/libs/spirit/test/karma/auto3.cpp @@ -0,0 +1,60 @@ +// 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) + +#include "auto.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + { + using spirit_test::test; + using spirit_test::test_delimited; + + // test primitive types + BOOST_TEST(test_rule("true", true)); + BOOST_TEST(test_rule("1", 1)); + BOOST_TEST(test_rule("1.1", 1.1)); + BOOST_TEST(test_rule("test", std::string("test"))); + + // test containers + std::vector<int> v; + v.push_back(0); + v.push_back(1); + v.push_back(2); + BOOST_TEST(test_rule("012", v)); + BOOST_TEST(test_rule_delimited("0,1,2,", v, ',')); + + std::list<int> l; + l.push_back(0); + l.push_back(1); + l.push_back(2); + BOOST_TEST(test_rule("012", l)); + BOOST_TEST(test_rule_delimited("0,1,2,", l, ',')); + + // test optional + boost::optional<int> o; + BOOST_TEST(test_rule("", o)); + o = 1; + BOOST_TEST(test_rule("1", o)); + + // test alternative + boost::variant<int, double, float, std::string> vv; + vv = 1; + BOOST_TEST(test_rule("1", vv)); + vv = 1.0; + BOOST_TEST(test_rule("1.0", vv)); + vv = 1.0f; + BOOST_TEST(test_rule("1.0", vv)); + vv = "some string"; + BOOST_TEST(test_rule("some string", vv)); + + // test fusion sequence + std::pair<int, double> p (1, 2.0); + BOOST_TEST(test_rule("12.0", p)); + BOOST_TEST(test_rule_delimited("1,2.0,", p, ',')); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/binary1.cpp b/src/boost/libs/spirit/test/karma/binary1.cpp new file mode 100644 index 00000000..336d2b42 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/binary1.cpp @@ -0,0 +1,113 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_binary.hpp> +#include <boost/spirit/include/karma_generate.hpp> + +#include <boost/predef/other/endian.h> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { // test native endian binaries +#if BOOST_ENDIAN_LITTLE_BYTE + BOOST_TEST(binary_test("\x01", 1, byte_, 0x01)); + BOOST_TEST(binary_test("\x80", 1, byte_, 0x80)); + BOOST_TEST(binary_test("\x01\x82", 2, word, 0x8201)); + BOOST_TEST(binary_test("\x81\x02", 2, word, 0x0281)); + BOOST_TEST(binary_test("\x01\x02\x03\x84", 4, dword, 0x84030201)); + BOOST_TEST(binary_test("\x81\x02\x03\x04", 4, dword, 0x04030281)); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x88", 8, qword, + 0x8807060504030201LL)); + BOOST_TEST(binary_test("\x81\x02\x03\x04\x05\x06\x07\x08", 8, qword, + 0x0807060504030281LL)); +#endif + BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float, 1.0f)); + BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8, + bin_double, 1.0)); + + BOOST_TEST(binary_test_delimited("\x01\x00\x00\x00", 4, byte_, 0x01, pad(4))); + BOOST_TEST(binary_test_delimited("\x01\x02\x00\x00", 4, word, 0x0201, pad(4))); + BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04", 4, dword, 0x04030201, pad(4))); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00", 10, + qword, 0x0807060504030201LL, pad(10))); +#endif + BOOST_TEST(binary_test_delimited("\x00\x00\x80\x3f", 4, bin_float, + 1.0f, pad(4))); + BOOST_TEST(binary_test_delimited("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8, + bin_double, 1.0, pad(8))); + +#else // BOOST_ENDIAN_LITTLE_BYTE + + BOOST_TEST(binary_test("\x01", 1, byte_, 0x01)); + BOOST_TEST(binary_test("\x80", 1, byte_, 0x80)); + BOOST_TEST(binary_test("\x01\x82", 2, word, 0x0182)); + BOOST_TEST(binary_test("\x81\x02", 2, word, 0x8102)); + BOOST_TEST(binary_test("\x01\x02\x03\x84", 4, dword, 0x01020384)); + BOOST_TEST(binary_test("\x81\x02\x03\x04", 4, dword, 0x81020304)); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x88", 8, qword, + 0x0102030405060788LL)); + BOOST_TEST(binary_test("\x81\x02\x03\x04\x05\x06\x07\x08", 8, qword, + 0x8102030405060708LL)); +#endif + BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float, 1.0f)); + BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8, + bin_double, 1.0)); + + BOOST_TEST(binary_test_delimited("\x01\x00\x00\x00", 4, byte_, 0x01, pad(4))); + BOOST_TEST(binary_test_delimited("\x01\x02\x00\x00", 4, word, 0x0102, pad(4))); + BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04", 4, dword, 0x01020304, pad(4))); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00", 10, + qword, 0x0102030405060708LL, pad(10))); +#endif + BOOST_TEST(binary_test_delimited("\x3f\x80\x00\x00", 4, bin_float, + 1.0f, pad(4))); + BOOST_TEST(binary_test_delimited("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8, + bin_double, 1.0, pad(8))); +#endif + } + + { // test native endian binaries +#if BOOST_ENDIAN_LITTLE_BYTE + BOOST_TEST(binary_test("\x01", 1, byte_(0x01))); + BOOST_TEST(binary_test("\x01\x02", 2, word(0x0201))); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, dword(0x04030201))); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, + qword(0x0807060504030201LL))); +#endif + BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float(1.0f))); + BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8, + bin_double(1.0))); +#else + BOOST_TEST(binary_test("\x01", 1, byte_(0x01))); + BOOST_TEST(binary_test("\x01\x02", 2, word(0x0102))); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, dword(0x01020304))); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, + qword(0x0102030405060708LL))); +#endif + BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float(1.0f))); + BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8, + bin_double(1.0))); +#endif + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/binary2.cpp b/src/boost/libs/spirit/test/karma/binary2.cpp new file mode 100644 index 00000000..00f82032 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/binary2.cpp @@ -0,0 +1,131 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_binary.hpp> +#include <boost/spirit/include/karma_generate.hpp> + +#include <boost/predef/other/endian.h> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { // test big endian binaries + BOOST_TEST(binary_test("\x01\x82", 2, big_word, 0x0182)); + BOOST_TEST(binary_test("\x81\x02", 2, big_word, 0x8102)); + BOOST_TEST(binary_test("\x01\x02\x03\x84", 4, big_dword, 0x01020384)); + BOOST_TEST(binary_test("\x81\x02\x03\x04", 4, big_dword, 0x81020304)); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x88", 8, big_qword, + 0x0102030405060788LL)); + BOOST_TEST(binary_test("\x81\x02\x03\x04\x05\x06\x07\x08", 8, big_qword, + 0x8102030405060708LL)); + BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00", + 10, big_qword, 0x0102030405060708LL, pad(10))); +#endif + BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, big_bin_float, 1.0f)); + BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8, + big_bin_double, 1.0)); + BOOST_TEST(binary_test_delimited("\x3f\xf0\x00\x00\x00\x00\x00\x00\x00\x00", + 10, big_bin_double, 1.0, pad(10))); + } + + { + BOOST_TEST(binary_test("\x01\x02", 2, big_word(0x0102))); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, big_dword(0x01020304))); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, + big_qword(0x0102030405060708LL))); + BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00", + 10, big_qword(0x0102030405060708LL), pad(10))); +#endif + BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, big_bin_float(1.0f))); + BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8, + big_bin_double(1.0))); + BOOST_TEST(binary_test_delimited("\x3f\xf0\x00\x00\x00\x00\x00\x00\x00\x00", + 10, big_bin_double(1.0), pad(10))); + } + + { // test little endian binaries + BOOST_TEST(binary_test("\x01\x82", 2, little_word, 0x8201)); + BOOST_TEST(binary_test("\x81\x02", 2, little_word, 0x0281)); + BOOST_TEST(binary_test("\x01\x02\x03\x84", 4, little_dword, 0x84030201)); + BOOST_TEST(binary_test("\x81\x02\x03\x04", 4, little_dword, 0x04030281)); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x88", 8, little_qword, + 0x8807060504030201LL)); + BOOST_TEST(binary_test("\x81\x02\x03\x04\x05\x06\x07\x08", 8, little_qword, + 0x0807060504030281LL)); + BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00", + 10, little_qword, 0x0807060504030201LL, pad(10))); +#endif + BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, little_bin_float, 1.0f)); + BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8, + little_bin_double, 1.0)); + BOOST_TEST(binary_test_delimited("\x00\x00\x00\x00\x00\x00\xf0\x3f\x00\x00", + 10, little_bin_double, 1.0, pad(10))); + } + + { + BOOST_TEST(binary_test("\x01\x02", 2, little_word(0x0201))); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, little_dword(0x04030201))); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, + little_qword(0x0807060504030201LL))); + BOOST_TEST(binary_test_delimited("\x01\x02\x03\x04\x05\x06\x07\x08\x00\x00", + 10, little_qword(0x0807060504030201LL), pad(10))); +#endif + BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, little_bin_float(1.0f))); + BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8, + little_bin_double(1.0))); + BOOST_TEST(binary_test_delimited("\x00\x00\x00\x00\x00\x00\xf0\x3f\x00\x00", + 10, little_bin_double(1.0), pad(10))); + } + + { // test native endian binaries + boost::optional<boost::uint8_t> v8; + boost::optional<boost::uint16_t> v16; + boost::optional<boost::uint32_t> v32; + boost::optional<float> vf; + boost::optional<double> vd; + +#if BOOST_ENDIAN_LITTLE_BYTE + + BOOST_TEST(!binary_test("", 0, byte_, v8)); + BOOST_TEST(!binary_test("", 0, word, v16)); + BOOST_TEST(!binary_test("", 0, dword, v32)); +#ifdef BOOST_HAS_LONG_LONG + boost::optional<boost::uint64_t> v64; + BOOST_TEST(!binary_test("", 0, qword, v64)); +#endif + BOOST_TEST(!binary_test("", 0, bin_float, vf)); + BOOST_TEST(!binary_test("", 0, bin_double, vd)); + +#else // BOOST_ENDIAN_LITTLE_BYTE + + BOOST_TEST(!binary_test("", 0, byte_, v8)); + BOOST_TEST(!binary_test("", 0, word, v16)); + BOOST_TEST(!binary_test("", 0, dword, v32)); +#ifdef BOOST_HAS_LONG_LONG + boost::optional<boost::uint64_t> v64; + BOOST_TEST(!binary_test("", 0, qword, v64)); +#endif + BOOST_TEST(!binary_test("", 0, bin_float, vf)); + BOOST_TEST(!binary_test("", 0, bin_double, vd)); + +#endif + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/binary3.cpp b/src/boost/libs/spirit/test/karma/binary3.cpp new file mode 100644 index 00000000..d666307e --- /dev/null +++ b/src/boost/libs/spirit/test/karma/binary3.cpp @@ -0,0 +1,168 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_binary.hpp> +#include <boost/spirit/include/karma_generate.hpp> + +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include <boost/predef/other/endian.h> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + using namespace boost::phoenix; + + { // test optional attributes + +#if BOOST_ENDIAN_LITTLE_BYTE + boost::optional<boost::uint8_t> v8 (0x01); + BOOST_TEST(binary_test("\x01", 1, byte_, v8)); + boost::optional<boost::uint16_t> v16 (0x0201); + BOOST_TEST(binary_test("\x01\x02", 2, word, v16)); + boost::optional<boost::uint32_t> v32 (0x04030201); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, dword, v32)); +#ifdef BOOST_HAS_LONG_LONG + boost::optional<boost::uint64_t> v64 (0x0807060504030201LL); + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword, v64)); +#endif + boost::optional<float> vf(1.0f); + BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float, vf)); + boost::optional<double> vd(1.0); + BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8, + bin_double, vd)); + +#else // BOOST_ENDIAN_LITTLE_BYTE + + boost::optional<boost::uint8_t> v8 (0x01); + BOOST_TEST(binary_test("\x01", 1, byte_, v8)); + boost::optional<boost::uint16_t> v16 (0x0102); + BOOST_TEST(binary_test("\x01\x02", 2, word, v16)); + boost::optional<boost::uint32_t> v32 (0x01020304); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, dword, v32)); +#ifdef BOOST_HAS_LONG_LONG + boost::optional<boost::uint64_t> v64 (0x0102030405060708LL); + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword, v64)); +#endif + boost::optional<float> vf(1.0f); + BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float, vf)); + boost::optional<double> vd(1.0); + BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8, + bin_double, vd)); + +#endif + } + +// we support Phoenix attributes only starting with V2.2 +#if SPIRIT_VERSION >= 0x2020 + { // test Phoenix expression attributes, only supported if + // karma_phoenix_attributes.hpp is included + namespace phoenix = boost::phoenix; + +#if BOOST_ENDIAN_LITTLE_BYTE + BOOST_TEST(binary_test("\x01", 1, byte_, phoenix::val(0x01))); + BOOST_TEST(binary_test("\x01\x02", 2, word, phoenix::val(0x0201))); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, dword, + phoenix::val(0x04030201))); + + boost::uint8_t v8 (0x01); + BOOST_TEST(binary_test("\x01", 1, byte_, phoenix::ref(v8))); + BOOST_TEST(binary_test("\x02", 1, byte_, ++phoenix::ref(v8))); + + boost::uint16_t v16 (0x0201); + BOOST_TEST(binary_test("\x01\x02", 2, word, phoenix::ref(v16))); + BOOST_TEST(binary_test("\x02\x02", 2, word, ++phoenix::ref(v16))); + + boost::uint32_t v32 (0x04030201); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, dword, phoenix::ref(v32))); + BOOST_TEST(binary_test("\x02\x02\x03\x04", 4, dword, ++phoenix::ref(v32))); + +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword, + phoenix::val(0x0807060504030201LL))); + + boost::uint64_t v64 (0x0807060504030201LL); + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword, + phoenix::ref(v64))); + BOOST_TEST(binary_test("\x02\x02\x03\x04\x05\x06\x07\x08", 8, qword, + ++phoenix::ref(v64))); +#endif + BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float, + phoenix::val(1.0f))); + float vf(1.0f); + BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float, + phoenix::ref(vf))); + BOOST_TEST(binary_test("\x00\x00\x00\x40", 4, bin_float, + ++phoenix::ref(vf))); + + BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8, + bin_double, phoenix::val(1.0))); + double vd(1.0); + BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8, + bin_double, phoenix::ref(vd))); + BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\x00\x40", 8, + bin_double, ++phoenix::ref(vd))); + +#else // BOOST_ENDIAN_LITTLE_BYTE + + BOOST_TEST(binary_test("\x01", 1, byte_, phoenix::val(0x01))); + BOOST_TEST(binary_test("\x01\x02", 2, word, phoenix::val(0x0102))); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, dword, + phoenix::val(0x01020304))); + + boost::uint8_t v8 (0x01); + BOOST_TEST(binary_test("\x01", 1, byte_, phoenix::ref(v8))); + BOOST_TEST(binary_test("\x02", 1, byte_, ++phoenix::ref(v8))); + + boost::uint16_t v16 (0x0102); + BOOST_TEST(binary_test("\x01\x02", 2, word, phoenix::ref(v16))); + BOOST_TEST(binary_test("\x01\x03", 2, word, ++phoenix::ref(v16))); + + boost::uint32_t v32 (0x01020304); + BOOST_TEST(binary_test("\x01\x02\x03\x04", 4, dword, phoenix::ref(v32))); + BOOST_TEST(binary_test("\x01\x02\x03\x05", 4, dword, ++phoenix::ref(v32))); + +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword, + phoenix::val(0x0102030405060708LL))); + + boost::uint64_t v64 (0x0102030405060708LL); + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x08", 8, qword, + phoenix::ref(v64))); + BOOST_TEST(binary_test("\x01\x02\x03\x04\x05\x06\x07\x09", 8, qword, + ++phoenix::ref(v64))); +#endif + BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float, + phoenix::val(1.0f))); + float vf(1.0f); + BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float, + phoenix::ref(vf))); + BOOST_TEST(binary_test("\x40\x00\x00\x00", 4, bin_float, + ++phoenix::ref(vf))); + + BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8, + bin_double, phoenix::val(1.0))); + double vd(1.0); + BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8, + bin_double, phoenix::ref(vd))); + BOOST_TEST(binary_test("\x40\x00\x00\x00\x00\x00\x00\x00", 8, + bin_double, ++phoenix::ref(vd))); + +#endif + } +#endif + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/bool.cpp b/src/boost/libs/spirit/test/karma/bool.cpp new file mode 100644 index 00000000..4627bd08 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/bool.cpp @@ -0,0 +1,184 @@ +/*============================================================================= + Copyright (c) 2001-2011 Hartmut Kaiser + Copyright (c) 2001-2011 Joel de Guzman + + 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) +=============================================================================*/ + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_phoenix_attributes.hpp> + +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +// special bool output policy allowing to spell false as true backwards (eurt) +struct special_bool_policy : boost::spirit::karma::bool_policies<> +{ + template <typename CharEncoding, typename Tag + , typename OutputIterator> + static bool generate_false(OutputIterator& sink, bool) + { + // we want to spell the names of true and false backwards + return boost::spirit::karma::string_inserter<CharEncoding, Tag>:: + call(sink, "eurt"); + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// special policy allowing to use any type as a boolean +struct test_bool_data +{ + explicit test_bool_data(bool b) : b(b) {} + + bool b; + + // we need to provide (safe) convertibility to bool +private: + struct dummy { void true_() {} }; + typedef void (dummy::*safe_bool)(); + +public: + operator safe_bool () const { return b ? &dummy::true_ : 0; } +}; + +struct test_bool_policy : boost::spirit::karma::bool_policies<> +{ + template <typename Inserter, typename OutputIterator, typename Policies> + static bool + call (OutputIterator& sink, test_bool_data b, Policies const& p) + { + // call the predefined inserter to do the job + return Inserter::call_n(sink, bool(b), p); + } +}; + + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using boost::spirit::karma::bool_; + using boost::spirit::karma::false_; + using boost::spirit::karma::true_; + using boost::spirit::karma::lit; + using boost::spirit::karma::lower; + using boost::spirit::karma::upper; + + // testing plain bool + { + BOOST_TEST(test("false", bool_, false)); + BOOST_TEST(test("true", bool_, true)); + BOOST_TEST(test("false", false_, false)); + BOOST_TEST(test("true", true_, true)); + BOOST_TEST(test("false", bool_(false))); + BOOST_TEST(test("true", bool_(true))); + BOOST_TEST(test("false", bool_(false), false)); + BOOST_TEST(test("true", bool_(true), true)); + BOOST_TEST(!test("", bool_(false), true)); + BOOST_TEST(!test("", bool_(true), false)); + BOOST_TEST(test("false", lit(false))); + BOOST_TEST(test("true", lit(true))); + } + + // test optional attributes + { + boost::optional<bool> optbool; + + BOOST_TEST(!test("", bool_, optbool)); + BOOST_TEST(test("", -bool_, optbool)); + optbool = false; + BOOST_TEST(test("false", bool_, optbool)); + BOOST_TEST(test("false", -bool_, optbool)); + optbool = true; + BOOST_TEST(test("true", bool_, optbool)); + BOOST_TEST(test("true", -bool_, optbool)); + } + +// we support Phoenix attributes only starting with V2.2 +#if SPIRIT_VERSION >= 0x2020 + // test Phoenix expression attributes (requires to include + // karma_phoenix_attributes.hpp) + { + namespace phoenix = boost::phoenix; + + BOOST_TEST(test("true", bool_, phoenix::val(true))); + + bool b = false; + BOOST_TEST(test("false", bool_, phoenix::ref(b))); + BOOST_TEST(test("true", bool_, !phoenix::ref(b))); + } +#endif + + { + BOOST_TEST(test("false", lower[bool_], false)); + BOOST_TEST(test("true", lower[bool_], true)); + BOOST_TEST(test("false", lower[bool_(false)])); + BOOST_TEST(test("true", lower[bool_(true)])); + BOOST_TEST(test("false", lower[bool_(false)], false)); + BOOST_TEST(test("true", lower[bool_(true)], true)); + BOOST_TEST(!test("", lower[bool_(false)], true)); + BOOST_TEST(!test("", lower[bool_(true)], false)); + BOOST_TEST(test("false", lower[lit(false)])); + BOOST_TEST(test("true", lower[lit(true)])); + } + + { + BOOST_TEST(test("FALSE", upper[bool_], false)); + BOOST_TEST(test("TRUE", upper[bool_], true)); + BOOST_TEST(test("FALSE", upper[bool_(false)])); + BOOST_TEST(test("TRUE", upper[bool_(true)])); + BOOST_TEST(test("FALSE", upper[bool_(false)], false)); + BOOST_TEST(test("TRUE", upper[bool_(true)], true)); + BOOST_TEST(!test("", upper[bool_(false)], true)); + BOOST_TEST(!test("", upper[bool_(true)], false)); + BOOST_TEST(test("FALSE", upper[lit(false)])); + BOOST_TEST(test("TRUE", upper[lit(true)])); + } + + { + typedef boost::spirit::karma::bool_generator<bool, special_bool_policy> + backwards_bool_type; + backwards_bool_type const backwards_bool = backwards_bool_type(); + + BOOST_TEST(test("eurt", backwards_bool, false)); + BOOST_TEST(test("true", backwards_bool, true)); + BOOST_TEST(test("eurt", backwards_bool(false))); + BOOST_TEST(test("true", backwards_bool(true))); + BOOST_TEST(test("eurt", backwards_bool(false), false)); + BOOST_TEST(test("true", backwards_bool(true), true)); + BOOST_TEST(!test("", backwards_bool(false), true)); + BOOST_TEST(!test("", backwards_bool(true), false)); + } + + { + typedef boost::spirit::karma::bool_generator< + test_bool_data, test_bool_policy> test_bool_type; + test_bool_type const test_bool = test_bool_type(); + + test_bool_data const test_false = test_bool_data(false); + test_bool_data const test_true = test_bool_data(true); + + BOOST_TEST(test("false", test_bool, test_false)); + BOOST_TEST(test("true", test_bool, test_true)); + BOOST_TEST(test("false", test_bool(test_false))); + BOOST_TEST(test("true", test_bool(test_true))); + BOOST_TEST(test("false", test_bool(test_false), test_false)); + BOOST_TEST(test("true", test_bool(test_true), test_true)); + BOOST_TEST(!test("", test_bool(test_false), test_true)); + BOOST_TEST(!test("", test_bool(test_true), test_false)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/buffer.cpp b/src/boost/libs/spirit/test/karma/buffer.cpp new file mode 100644 index 00000000..ef8d12a3 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/buffer.cpp @@ -0,0 +1,53 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.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_char.hpp> + +#include <iostream> +#include "test.hpp" + +int +main() +{ + using namespace spirit_test; + using namespace boost::spirit; + + { + using boost::spirit::karma::double_; + using boost::spirit::karma::buffer; + + std::vector<double> v; + BOOST_TEST(test("", -buffer['[' << +double_ << ']'], v)); + + v.push_back(1.0); + v.push_back(2.0); + BOOST_TEST(test("[1.02.0]", buffer['[' << +double_ << ']'], v)); + BOOST_TEST(test("[1.02.0]", buffer[buffer['[' << +double_ << ']']], v)); + } + + { + using boost::spirit::karma::double_; + using boost::spirit::karma::buffer; + using boost::spirit::ascii::space; + + std::vector<double> v; + BOOST_TEST(test_delimited("", + -buffer['[' << +double_ << ']'], v, space)); + + v.push_back(1.0); + v.push_back(2.0); + BOOST_TEST(test_delimited("[ 1.0 2.0 ] ", + buffer['[' << +double_ << ']'], v, space)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/case_handling1.cpp b/src/boost/libs/spirit/test/karma/case_handling1.cpp new file mode 100644 index 00000000..2af1dafe --- /dev/null +++ b/src/boost/libs/spirit/test/karma/case_handling1.cpp @@ -0,0 +1,96 @@ +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/detail/workaround.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_directive.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test("x", lower['X'])); + BOOST_TEST(test("x", lower['x'])); + + BOOST_TEST(test("x", lower[char_], 'X')); + BOOST_TEST(test("x", lower[char_], 'x')); + BOOST_TEST(test("x", lower[char_('X')])); + BOOST_TEST(test("x", lower[char_('x')])); + + BOOST_TEST(test(" ", lower[space])); + BOOST_TEST(test("\t", lower[space], '\t')); + + BOOST_TEST(test("x", lower[lower['X']])); + BOOST_TEST(test("x", lower[lower['x']])); + + BOOST_TEST(test("x", lower[lower[char_]], 'X')); + BOOST_TEST(test("x", lower[lower[char_]], 'x')); + BOOST_TEST(test("x", lower[lower[char_('X')]])); + BOOST_TEST(test("x", lower[lower[char_('x')]])); + + BOOST_TEST(test(" ", lower[lower[space]])); + BOOST_TEST(test("\t", lower[lower[space]], '\t')); + + BOOST_TEST(test("X", upper[lower['X']])); + BOOST_TEST(test("X", upper[lower['x']])); + + BOOST_TEST(test("X", upper[lower[char_]], 'X')); + BOOST_TEST(test("X", upper[lower[char_]], 'x')); + BOOST_TEST(test("X", upper[lower[char_('X')]])); + BOOST_TEST(test("X", upper[lower[char_('x')]])); + + BOOST_TEST(test(" ", upper[lower[space]])); + BOOST_TEST(test("\t", upper[lower[space]], '\t')); + + BOOST_TEST(test("X", upper['X'])); + BOOST_TEST(test("X", upper['x'])); + + BOOST_TEST(test("X", upper[char_], 'X')); + BOOST_TEST(test("X", upper[char_], 'x')); + BOOST_TEST(test("X", upper[char_('X')])); + BOOST_TEST(test("X", upper[char_('x')])); + + BOOST_TEST(test(" ", upper[space])); + BOOST_TEST(test("\t", upper[space], '\t')); + + BOOST_TEST(test("x", lower[upper['X']])); + BOOST_TEST(test("x", lower[upper['x']])); + + BOOST_TEST(test("x", lower[upper[char_]], 'X')); + BOOST_TEST(test("x", lower[upper[char_]], 'x')); + BOOST_TEST(test("x", lower[upper[char_('X')]])); + BOOST_TEST(test("x", lower[upper[char_('x')]])); + + BOOST_TEST(test(" ", lower[upper[space]])); + BOOST_TEST(test("\t", lower[upper[space]], '\t')); + + BOOST_TEST(test("X", upper[upper['X']])); + BOOST_TEST(test("X", upper[upper['x']])); + + BOOST_TEST(test("X", upper[upper[char_]], 'X')); + BOOST_TEST(test("X", upper[upper[char_]], 'x')); + BOOST_TEST(test("X", upper[upper[char_('X')]])); + BOOST_TEST(test("X", upper[upper[char_('x')]])); + + BOOST_TEST(test(" ", upper[upper[space]])); + BOOST_TEST(test("\t", upper[upper[space]], '\t')); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/case_handling2.cpp b/src/boost/libs/spirit/test/karma/case_handling2.cpp new file mode 100644 index 00000000..16687106 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/case_handling2.cpp @@ -0,0 +1,114 @@ +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/detail/workaround.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_directive.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { + using namespace boost::spirit::standard_wide; + + BOOST_TEST(test(L"x", lower[L'X'])); + BOOST_TEST(test(L"x", lower[L'x'])); + + BOOST_TEST(test(L"x", lower[char_], L'X')); + BOOST_TEST(test(L"x", lower[char_], L'x')); + BOOST_TEST(test(L"x", lower[char_(L'X')])); + BOOST_TEST(test(L"x", lower[char_(L'x')])); + + BOOST_TEST(test(L" ", lower[space])); + BOOST_TEST(test(L"\t", lower[space], L'\t')); + + BOOST_TEST(test(L"x", lower[lower[L'X']])); + BOOST_TEST(test(L"x", lower[lower[L'x']])); + + BOOST_TEST(test(L"x", lower[lower[char_]], L'X')); + BOOST_TEST(test(L"x", lower[lower[char_]], L'x')); + BOOST_TEST(test(L"x", lower[lower[char_(L'X')]])); + BOOST_TEST(test(L"x", lower[lower[char_(L'x')]])); + + BOOST_TEST(test(L" ", lower[lower[space]])); + BOOST_TEST(test(L"\t", lower[lower[space]], L'\t')); + + BOOST_TEST(test(L"X", upper[lower[L'X']])); + BOOST_TEST(test(L"X", upper[lower[L'x']])); + + BOOST_TEST(test(L"X", upper[lower[char_]], L'X')); + BOOST_TEST(test(L"X", upper[lower[char_]], L'x')); + BOOST_TEST(test(L"X", upper[lower[char_(L'X')]])); + BOOST_TEST(test(L"X", upper[lower[char_(L'x')]])); + + BOOST_TEST(test(L" ", upper[lower[space]])); + BOOST_TEST(test(L"\t", upper[lower[space]], L'\t')); + + BOOST_TEST(test(L"X", upper[L'X'])); + BOOST_TEST(test(L"X", upper[L'x'])); + + BOOST_TEST(test(L"X", upper[char_], L'X')); + BOOST_TEST(test(L"X", upper[char_], L'x')); + BOOST_TEST(test(L"X", upper[char_(L'X')])); + BOOST_TEST(test(L"X", upper[char_(L'x')])); + + BOOST_TEST(test(L" ", upper[space])); + BOOST_TEST(test(L"\t", upper[space], L'\t')); + + BOOST_TEST(test(L"x", lower[upper[L'X']])); + BOOST_TEST(test(L"x", lower[upper[L'x']])); + + BOOST_TEST(test(L"x", lower[upper[char_]], L'X')); + BOOST_TEST(test(L"x", lower[upper[char_]], L'x')); + BOOST_TEST(test(L"x", lower[upper[char_(L'X')]])); + BOOST_TEST(test(L"x", lower[upper[char_(L'x')]])); + + BOOST_TEST(test(L" ", lower[upper[space]])); + BOOST_TEST(test(L"\t", lower[upper[space]], L'\t')); + + BOOST_TEST(test(L"X", upper[upper[L'X']])); + BOOST_TEST(test(L"X", upper[upper[L'x']])); + + BOOST_TEST(test(L"X", upper[upper[char_]], L'X')); + BOOST_TEST(test(L"X", upper[upper[char_]], L'x')); + BOOST_TEST(test(L"X", upper[upper[char_(L'X')]])); + BOOST_TEST(test(L"X", upper[upper[char_(L'x')]])); + + BOOST_TEST(test(L" ", upper[upper[space]])); + BOOST_TEST(test(L"\t", upper[upper[space]], L'\t')); + } + + { // test extended ASCII characters + using namespace boost::spirit::iso8859_1; + + BOOST_TEST(test("\xE4\xE4", lower["\xC4\xE4"])); + BOOST_TEST(test("\xE4\xE4", lower["\xC4\xE4"])); + + BOOST_TEST(test("\xC4\xC4", upper["\xC4\xE4"])); + BOOST_TEST(test("\xC4\xC4", upper["\xC4\xE4"])); + } + + { + using namespace boost::spirit::ascii; + using boost::phoenix::val; + + BOOST_TEST(test("x", lower[val('X')])); + BOOST_TEST(test("x", lower[val('x')])); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/case_handling3.cpp b/src/boost/libs/spirit/test/karma/case_handling3.cpp new file mode 100644 index 00000000..018a6184 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/case_handling3.cpp @@ -0,0 +1,110 @@ +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/detail/workaround.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_directive.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { // test extended ASCII characters + using namespace boost::spirit::iso8859_1; + + BOOST_TEST(test("\xE4", lower['\xC4'])); + BOOST_TEST(test("\xE4", lower['\xE4'])); + + BOOST_TEST(test("\xC4", upper['\xC4'])); + BOOST_TEST(test("\xC4", upper['\xE4'])); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test("a1- ", lower["a1- "])); + BOOST_TEST(test("a1- ", lower["a1- "])); + BOOST_TEST(test("a1- ", lower["a1- "])); + BOOST_TEST(test("a1- ", lower["A1- "])); + + BOOST_TEST(test("a1- ", lower[string], "a1- ")); + BOOST_TEST(test("a1- ", lower[string], "A1- ")); + BOOST_TEST(test("a1- ", lower[lit("a1- ")])); + BOOST_TEST(test("a1- ", lower[lit("A1- ")])); + BOOST_TEST(test("a1- ", lower[string("a1- ")])); + BOOST_TEST(test("a1- ", lower[string("A1- ")])); + + BOOST_TEST(test("a1- ", lower[lower["a1- "]])); + BOOST_TEST(test("a1- ", lower[lower["a1- "]])); + BOOST_TEST(test("a1- ", lower[lower["a1- "]])); + BOOST_TEST(test("a1- ", lower[lower["A1- "]])); + + BOOST_TEST(test("a1- ", lower[lower[string]], "a1- ")); + BOOST_TEST(test("a1- ", lower[lower[string]], "A1- ")); + BOOST_TEST(test("a1- ", lower[lower[lit("a1- ")]])); + BOOST_TEST(test("a1- ", lower[lower[lit("A1- ")]])); + BOOST_TEST(test("a1- ", lower[lower[string("a1- ")]])); + BOOST_TEST(test("a1- ", lower[lower[string("A1- ")]])); + + BOOST_TEST(test("A1- ", upper[lower["a1- "]])); + BOOST_TEST(test("A1- ", upper[lower["a1- "]])); + BOOST_TEST(test("A1- ", upper[lower["a1- "]])); + BOOST_TEST(test("A1- ", upper[lower["A1- "]])); + + BOOST_TEST(test("A1- ", upper[lower[string]], "a1- ")); + BOOST_TEST(test("A1- ", upper[lower[string]], "A1- ")); + BOOST_TEST(test("A1- ", upper[lower[lit("a1- ")]])); + BOOST_TEST(test("A1- ", upper[lower[lit("A1- ")]])); + BOOST_TEST(test("A1- ", upper[lower[string("a1- ")]])); + BOOST_TEST(test("A1- ", upper[lower[string("A1- ")]])); + + BOOST_TEST(test("A1- ", upper["a1- "])); + BOOST_TEST(test("A1- ", upper["a1- "])); + BOOST_TEST(test("A1- ", upper["a1- "])); + BOOST_TEST(test("A1- ", upper["A1- "])); + + BOOST_TEST(test("A1- ", upper[string], "a1- ")); + BOOST_TEST(test("A1- ", upper[string], "A1- ")); + BOOST_TEST(test("A1- ", upper[lit("a1- ")])); + BOOST_TEST(test("A1- ", upper[lit("A1- ")])); + + BOOST_TEST(test("a1- ", lower[upper["a1- "]])); + BOOST_TEST(test("a1- ", lower[upper["a1- "]])); + BOOST_TEST(test("a1- ", lower[upper["a1- "]])); + BOOST_TEST(test("a1- ", lower[upper["A1- "]])); + + BOOST_TEST(test("a1- ", lower[upper[string]], "a1- ")); + BOOST_TEST(test("a1- ", lower[upper[string]], "A1- ")); + BOOST_TEST(test("a1- ", lower[upper[lit("a1- ")]])); + BOOST_TEST(test("a1- ", lower[upper[lit("A1- ")]])); + BOOST_TEST(test("a1- ", lower[upper[string("a1- ")]])); + BOOST_TEST(test("a1- ", lower[upper[string("A1- ")]])); + + BOOST_TEST(test("A1- ", upper[upper["a1- "]])); + BOOST_TEST(test("A1- ", upper[upper["a1- "]])); + BOOST_TEST(test("A1- ", upper[upper["a1- "]])); + BOOST_TEST(test("A1- ", upper[upper["A1- "]])); + + BOOST_TEST(test("A1- ", upper[upper[string]], "a1- ")); + BOOST_TEST(test("A1- ", upper[upper[string]], "A1- ")); + BOOST_TEST(test("A1- ", upper[upper[lit("a1- ")]])); + BOOST_TEST(test("A1- ", upper[upper[lit("A1- ")]])); + BOOST_TEST(test("A1- ", upper[upper[string("a1- ")]])); + BOOST_TEST(test("A1- ", upper[upper[string("A1- ")]])); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/center_alignment.cpp b/src/boost/libs/spirit/test/karma/center_alignment.cpp new file mode 100644 index 00000000..a5e01efe --- /dev/null +++ b/src/boost/libs/spirit/test/karma/center_alignment.cpp @@ -0,0 +1,87 @@ +// Copyright (c) 2001-2011 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) + +#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_directive.hpp> +#include <boost/spirit/include/karma_upper_lower_case.hpp> + +#include <string> +#include <iterator> + +#include "test.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace spirit_test; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + BOOST_TEST(test(" x ", center[char_('x')])); + BOOST_TEST(test(" x ", center[char_], 'x')); + BOOST_TEST(test(" x ", center['x'])); + + BOOST_TEST(test(" x ", center(10)[char_('x')])); + BOOST_TEST(test(" x ", center(10)[char_], 'x')); + BOOST_TEST(test(" x ", center(10)['x'])); + + BOOST_TEST(test("*****x****", center(10, char_('*'))[char_('x')])); + BOOST_TEST(test("*****x****", center(10, '*')[char_], 'x')); + BOOST_TEST(test("*****x****", center(10, '*')['x'])); + BOOST_TEST(test("aaaaaxaaaa", lower[center(10, 'A')['X']])); + BOOST_TEST(test("AAAAAXAAAA", upper[center(10, 'a')['x']])); + + + BOOST_TEST(test("*****x****", center(char_('*'))[char_('x')])); + BOOST_TEST(test("*****x****", center(char_('*'))[char_], 'x')); + BOOST_TEST(test("*****x****", center(char_('*'))['x'])); + + BOOST_TEST(test(" x ", center(11)[char_('x')])); + + BOOST_TEST(test(" abc ", center[lit("abc")])); + BOOST_TEST(test(" abc ", center[string], "abc")); + + BOOST_TEST(test(" abc ", center(10)[lit("abc")])); + BOOST_TEST(test(" abc ", center(10)[string], "abc")); + BOOST_TEST(test(" abc ", center(10)["abc"])); + + BOOST_TEST(test(" abc ", center(11)[lit("abc")])); + BOOST_TEST(test(" ab ", center(11)[lit("ab")])); + + BOOST_TEST(test("****abc***", center(10, char_('*'))[lit("abc")])); + BOOST_TEST(test("****abc***", center(10, '*')[string], "abc")); + BOOST_TEST(test("****abc***", center(10, '*')["abc"])); + + BOOST_TEST(test("****abc***", center(char_('*'))[lit("abc")])); + BOOST_TEST(test("****abc***", center(char_('*'))[string], "abc")); + BOOST_TEST(test("****abc***", center(char_('*'))["abc"])); + + BOOST_TEST(test(" abc ", center(11)[lit("abc")])); + + BOOST_TEST(test(" 100 ", center[int_(100)])); + BOOST_TEST(test(" 100 ", center[int_], 100)); + + BOOST_TEST(test(" 100 ", center(10)[int_(100)])); + BOOST_TEST(test(" 100 ", center(10)[int_], 100)); + + BOOST_TEST(test("****100***", center(10, char_('*'))[int_(100)])); + BOOST_TEST(test("****100***", center(10, '*')[int_], 100)); + + BOOST_TEST(test(" 100 ", center(11)[int_(100)])); + + BOOST_TEST(test("****100***", center(char_('*'))[int_(100)])); + BOOST_TEST(test("****100***", center(char_('*'))[int_], 100)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/char1.cpp b/src/boost/libs/spirit/test/karma/char1.cpp new file mode 100644 index 00000000..e1c4dc40 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/char1.cpp @@ -0,0 +1,176 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/karma_phoenix_attributes.hpp> + +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/spirit/include/phoenix_statement.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + using namespace boost::phoenix; + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test("x", 'x')); + BOOST_TEST(test(L"x", L'x')); + BOOST_TEST(!test("x", 'y')); + BOOST_TEST(!test(L"x", L'y')); + + BOOST_TEST(test("x", "x")); + BOOST_TEST(test(L"x", L"x")); + BOOST_TEST(!test("x", "y")); + BOOST_TEST(!test(L"x", L"y")); + + BOOST_TEST(test("x", char_, 'x')); + BOOST_TEST(test(L"x", char_, L'x')); + BOOST_TEST(!test("x", char_, 'y')); + BOOST_TEST(!test(L"x", char_, L'y')); + + BOOST_TEST(test("x", char_('x'))); + BOOST_TEST(!test("x", char_('y'))); + + BOOST_TEST(test("x", char_('x'), 'x')); + BOOST_TEST(!test("", char_('y'), 'x')); + + BOOST_TEST(test("x", char_("x"))); + + BOOST_TEST(test("a", char_('a', 'z'), 'a')); + BOOST_TEST(test("b", char_('a', 'z'), 'b')); + BOOST_TEST(!test("", char_('a', 'z'), 'A')); + + BOOST_TEST(test("a", char_("a-z"), 'a')); + BOOST_TEST(test("b", char_("a-z"), 'b')); + BOOST_TEST(!test("", char_("a-z"), 'A')); + +#if defined(KARMA_FAIL_COMPILATION) + BOOST_TEST(test("x", char_)); // anychar without a parameter doesn't make any sense + BOOST_TEST(test("", char_('a', 'z'))); // char sets without attribute neither +#endif + + BOOST_TEST(!test("", ~char_('x'))); + + BOOST_TEST(!test("", ~char_('x'), 'x')); + BOOST_TEST(test("x", ~char_('y'), 'x')); + + BOOST_TEST(!test("", ~char_("x"))); + + BOOST_TEST(!test("", ~char_('a', 'z'), 'a')); + BOOST_TEST(!test("", ~char_('a', 'z'), 'b')); + BOOST_TEST(test("A", ~char_('a', 'z'), 'A')); + + BOOST_TEST(!test("", ~char_("a-z"), 'a')); + BOOST_TEST(!test("", ~char_("a-z"), 'b')); + BOOST_TEST(test("A", ~char_("a-z"), 'A')); + + BOOST_TEST(test("x", ~~char_('x'))); + BOOST_TEST(!test("x", ~~char_('y'))); + + BOOST_TEST(test("x", ~~char_('x'), 'x')); + BOOST_TEST(!test("", ~~char_('y'), 'x')); + + BOOST_TEST(test("x", ~~char_("x"))); + + BOOST_TEST(test("a", ~~char_('a', 'z'), 'a')); + BOOST_TEST(test("b", ~~char_('a', 'z'), 'b')); + BOOST_TEST(!test("", ~~char_('a', 'z'), 'A')); + + BOOST_TEST(test("a", ~~char_("a-z"), 'a')); + BOOST_TEST(test("b", ~~char_("a-z"), 'b')); + BOOST_TEST(!test("", ~~char_("a-z"), 'A')); + } + + { + using namespace boost::spirit::standard_wide; + + BOOST_TEST(test(L"x", 'x')); + BOOST_TEST(test(L"x", L'x')); + BOOST_TEST(!test(L"x", 'y')); + BOOST_TEST(!test(L"x", L'y')); + + BOOST_TEST(test(L"x", "x")); + BOOST_TEST(test(L"x", L"x")); + BOOST_TEST(!test(L"x", "y")); + BOOST_TEST(!test(L"x", L"y")); + + BOOST_TEST(test(L"x", char_, 'x')); + BOOST_TEST(test(L"x", char_, L'x')); + BOOST_TEST(!test(L"x", char_, 'y')); + BOOST_TEST(!test(L"x", char_, L'y')); + + BOOST_TEST(test(L"x", char_('x'))); + BOOST_TEST(test(L"x", char_(L'x'))); + BOOST_TEST(!test(L"x", char_('y'))); + BOOST_TEST(!test(L"x", char_(L'y'))); + + BOOST_TEST(test(L"x", char_(L'x'), L'x')); + BOOST_TEST(!test(L"", char_('y'), L'x')); + + BOOST_TEST(test(L"x", char_(L"x"))); + + BOOST_TEST(test("a", char_("a", "z"), 'a')); + BOOST_TEST(test(L"a", char_(L"a", L"z"), L'a')); + +#if defined(KARMA_FAIL_COMPILATION) + BOOST_TEST(test("x", char_)); // anychar without a parameter doesn't make any sense +#endif + + BOOST_TEST(!test(L"", ~char_('x'))); + BOOST_TEST(!test(L"", ~char_(L'x'))); + + BOOST_TEST(!test(L"", ~char_(L'x'), L'x')); + BOOST_TEST(test(L"x", ~char_('y'), L'x')); + + BOOST_TEST(!test(L"", ~char_(L"x"))); + } + + { // lazy chars + namespace ascii = boost::spirit::ascii; + namespace wide = boost::spirit::standard_wide; + + using namespace boost::phoenix; + + BOOST_TEST((test("x", ascii::char_(val('x'))))); + BOOST_TEST((test(L"x", wide::char_(val(L'x'))))); + + BOOST_TEST((test("x", ascii::char_(val('x')), 'x'))); + BOOST_TEST((test(L"x", wide::char_(val(L'x')), L'x'))); + + BOOST_TEST((!test("", ascii::char_(val('y')), 'x'))); + BOOST_TEST((!test(L"", wide::char_(val(L'y')), L'x'))); + } + + // we can pass optionals as attributes to any generator + { + namespace ascii = boost::spirit::ascii; + namespace wide = boost::spirit::standard_wide; + + boost::optional<char> v; + boost::optional<wchar_t> w; + + BOOST_TEST(!test("", ascii::char_, v)); + BOOST_TEST(!test(L"", wide::char_, w)); + + BOOST_TEST(!test("", ascii::char_('x'), v)); + BOOST_TEST(!test(L"", wide::char_(L'x'), w)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/char2.cpp b/src/boost/libs/spirit/test/karma/char2.cpp new file mode 100644 index 00000000..aae587bf --- /dev/null +++ b/src/boost/libs/spirit/test/karma/char2.cpp @@ -0,0 +1,158 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/karma_phoenix_attributes.hpp> + +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/spirit/include/phoenix_statement.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + using namespace boost::phoenix; + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test(" ", space)); + BOOST_TEST(test(L" ", space)); + BOOST_TEST(!test("\t", space)); + BOOST_TEST(!test(L"\t", space)); + + BOOST_TEST(test(" ", space, ' ')); + BOOST_TEST(test(L" ", space, L' ')); + BOOST_TEST(test("\t", space, '\t')); + BOOST_TEST(test(L"\t", space, L'\t')); + + BOOST_TEST(!test("", space, 'x')); + BOOST_TEST(!test(L"", space, L'x')); + + BOOST_TEST(!test(" ", ~space, ' ')); + BOOST_TEST(!test(L" ", ~space, L' ')); + + BOOST_TEST(test("x", ~space, 'x')); + BOOST_TEST(test(L"x", ~space, L'x')); + } + + { + using namespace boost::spirit::standard_wide; + + BOOST_TEST(test(" ", space)); + BOOST_TEST(test(L" ", space)); + BOOST_TEST(!test("\t", space)); + BOOST_TEST(!test(L"\t", space)); + + BOOST_TEST(test(" ", space, ' ')); + BOOST_TEST(test(L" ", space, L' ')); + BOOST_TEST(test("\t", space, '\t')); + BOOST_TEST(test(L"\t", space, L'\t')); + + BOOST_TEST(!test("", space, 'x')); + BOOST_TEST(!test(L"", space, L'x')); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test_delimited("x ", 'x', ' ')); + BOOST_TEST(test_delimited(L"x ", L'x', L' ')); + BOOST_TEST(!test_delimited("x ", 'y', ' ')); + BOOST_TEST(!test_delimited(L"x ", L'y', L' ')); + + BOOST_TEST(test_delimited("x ", 'x', ' ')); + BOOST_TEST(test_delimited(L"x ", L'x', L' ')); + BOOST_TEST(!test_delimited("x ", 'y', ' ')); + BOOST_TEST(!test_delimited(L"x ", L'y', L' ')); + + BOOST_TEST(test_delimited("x ", char_, 'x', ' ')); + BOOST_TEST(test_delimited(L"x ", char_, L'x', L' ')); + BOOST_TEST(!test_delimited("x ", char_, 'y', ' ')); + BOOST_TEST(!test_delimited(L"x ", char_, L'y', L' ')); + + BOOST_TEST(test_delimited("x ", char_('x'), ' ')); + BOOST_TEST(!test_delimited("x ", char_('y'), ' ')); + + BOOST_TEST(test_delimited("x ", char_('x'), 'x', ' ')); + BOOST_TEST(!test_delimited("", char_('y'), 'x', ' ')); + + BOOST_TEST(test_delimited("x ", char_("x"), ' ')); + +#if defined(KARMA_FAIL_COMPILATION) + BOOST_TEST(test_delimited("x ", char_, ' ')); // anychar without a parameter doesn't make any sense +#endif + } + + { // pre-delimiting + { + std::string generated; + std::back_insert_iterator<std::string> it(generated); + BOOST_TEST(karma::generate_delimited(it, '_', '^' + , karma::delimit_flag::predelimit)); + BOOST_TEST(generated == "^_^"); + } + { + using namespace boost::spirit::standard_wide; + std::basic_string<wchar_t> generated; + std::back_insert_iterator<std::basic_string<wchar_t> > it(generated); + BOOST_TEST(karma::generate_delimited(it, char_, L'.' + , karma::delimit_flag::predelimit, L'x')); + BOOST_TEST(generated == L".x."); + } + } + + // action tests + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test("x", char_[_1 = val('x')])); + BOOST_TEST(!test("x", char_[_1 = val('y')])); + } + +// we support Phoenix attributes only starting with V2.2 +#if SPIRIT_VERSION >= 0x2020 + // yes, we can use phoenix expressions as attributes as well + // but only if we include karma_phoenix_attributes.hpp + { + namespace ascii = boost::spirit::ascii; + namespace phoenix = boost::phoenix; + + BOOST_TEST(test("x", ascii::char_, phoenix::val('x'))); + + char c = 'x'; + BOOST_TEST(test("x", ascii::char_, phoenix::ref(c))); + BOOST_TEST(test("y", ascii::char_, ++phoenix::ref(c))); + } +#endif + + { + namespace ascii = boost::spirit::ascii; + namespace wide = boost::spirit::standard_wide; + + boost::optional<char> v ('x'); + boost::optional<wchar_t> w (L'x'); + + BOOST_TEST(test("x", ascii::char_, v)); + BOOST_TEST(test(L"x", wide::char_, w)); + BOOST_TEST(test("x", ascii::char_('x'), v)); + BOOST_TEST(test(L"x", wide::char_(L'x'), w)); + BOOST_TEST(!test("", ascii::char_('y'), v)); + BOOST_TEST(!test(L"", wide::char_(L'y'), w)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/char3.cpp b/src/boost/libs/spirit/test/karma/char3.cpp new file mode 100644 index 00000000..55e5978b --- /dev/null +++ b/src/boost/libs/spirit/test/karma/char3.cpp @@ -0,0 +1,103 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/karma_phoenix_attributes.hpp> + +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/spirit/include/phoenix_statement.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + using namespace boost::phoenix; + using boost::spirit::karma::lit; + + { + BOOST_TEST(test("x", lit('x'))); + BOOST_TEST(!test("x", lit('y'))); + + BOOST_TEST(test("x", lit('x'), 'x')); + BOOST_TEST(!test("", lit('y'), 'x')); + +// BOOST_TEST(test("a", lit('a', 'z'), 'a')); +// BOOST_TEST(test("b", lit('a', 'z'), 'b')); +// BOOST_TEST(!test("", lit('a', 'z'), 'A')); + + BOOST_TEST(!test("", ~lit('x'))); + + BOOST_TEST(!test("", ~lit('x'), 'x')); + BOOST_TEST(test("x", ~lit('y'), 'x')); + +// BOOST_TEST(!test("", ~lit('a', 'z'), 'a')); +// BOOST_TEST(!test("", ~lit('a', 'z'), 'b')); +// BOOST_TEST(test("A", ~lit('a', 'z'), 'A')); + + BOOST_TEST(test("x", ~~lit('x'))); + BOOST_TEST(!test("x", ~~lit('y'))); + + BOOST_TEST(test("x", ~~lit('x'), 'x')); + BOOST_TEST(!test("", ~~lit('y'), 'x')); + +// BOOST_TEST(test("a", ~~lit('a', 'z'), 'a')); +// BOOST_TEST(test("b", ~~lit('a', 'z'), 'b')); +// BOOST_TEST(!test("", ~~lit('a', 'z'), 'A')); + } + + { + BOOST_TEST(test(L"x", lit('x'))); + BOOST_TEST(test(L"x", lit(L'x'))); + BOOST_TEST(!test(L"x", lit('y'))); + BOOST_TEST(!test(L"x", lit(L'y'))); + + BOOST_TEST(test(L"x", lit(L'x'), L'x')); + BOOST_TEST(!test(L"", lit('y'), L'x')); + +// BOOST_TEST(test("a", lit("a", "z"), 'a')); +// BOOST_TEST(test(L"a", lit(L"a", L"z"), L'a')); + + BOOST_TEST(!test(L"", ~lit('x'))); + BOOST_TEST(!test(L"", ~lit(L'x'))); + + BOOST_TEST(!test(L"", ~lit(L'x'), L'x')); + BOOST_TEST(test(L"x", ~lit('y'), L'x')); + } + + { // lazy chars + using namespace boost::phoenix; + + BOOST_TEST((test("x", lit(val('x'))))); + BOOST_TEST((test(L"x", lit(val(L'x'))))); + + BOOST_TEST((test("x", lit(val('x')), 'x'))); + BOOST_TEST((test(L"x", lit(val(L'x')), L'x'))); + + BOOST_TEST((!test("", lit(val('y')), 'x'))); + BOOST_TEST((!test(L"", lit(val(L'y')), L'x'))); + } + + // we can pass optionals as attributes to any generator + { + boost::optional<char> v; + boost::optional<wchar_t> w; + + BOOST_TEST(!test("", lit('x'), v)); + BOOST_TEST(!test(L"", lit(L'x'), w)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/char_class.cpp b/src/boost/libs/spirit/test/karma/char_class.cpp new file mode 100644 index 00000000..88c5ad6b --- /dev/null +++ b/src/boost/libs/spirit/test/karma/char_class.cpp @@ -0,0 +1,197 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_directive.hpp> + +#include <string> +#include <iterator> + +#include "test.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace spirit_test; + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + BOOST_TEST(test("a", alpha, 'a')); + BOOST_TEST(!test("", alpha, '1')); + BOOST_TEST(test(" ", blank, ' ')); + BOOST_TEST(!test("", blank, 'x')); + BOOST_TEST(test("1", digit, '1')); + BOOST_TEST(!test("", digit, 'x')); + BOOST_TEST(test("a", lower, 'a')); + BOOST_TEST(!test("", lower, 'A')); + BOOST_TEST(test("!", punct, '!')); + BOOST_TEST(!test("", punct, 'x')); + BOOST_TEST(test(" ", space)); + BOOST_TEST(test(" ", space, ' ')); + BOOST_TEST(!test("", space, '\n')); + BOOST_TEST(test("\r", space, '\r')); + BOOST_TEST(test("\t", space, '\t')); + BOOST_TEST(test("A", upper, 'A')); + BOOST_TEST(!test("", upper, 'a')); + BOOST_TEST(test("A", xdigit, 'A')); + BOOST_TEST(test("0", xdigit, '0')); + BOOST_TEST(test("f", xdigit, 'f')); + BOOST_TEST(!test("", xdigit, 'g')); + } + + { + using namespace boost::spirit::ascii; + BOOST_TEST(!test("", ~alpha, 'a')); + BOOST_TEST(test("1", ~alpha, '1')); + BOOST_TEST(!test("", ~blank, ' ')); + BOOST_TEST(test("x", ~blank, 'x')); + BOOST_TEST(!test("", ~digit, '1')); + BOOST_TEST(test("x", ~digit, 'x')); + BOOST_TEST(!test("", ~lower, 'a')); + BOOST_TEST(test("A", ~lower, 'A')); + BOOST_TEST(!test("", ~punct, '!')); + BOOST_TEST(test("x", ~punct, 'x')); + BOOST_TEST(!test("", ~space)); + BOOST_TEST(!test("", ~space, ' ')); + BOOST_TEST(!test("", ~space, '\r')); + BOOST_TEST(!test("", ~space, '\t')); + BOOST_TEST(!test("", ~upper, 'A')); + BOOST_TEST(test("a", ~upper, 'a')); + BOOST_TEST(!test("", ~xdigit, 'A')); + BOOST_TEST(!test("", ~xdigit, '0')); + BOOST_TEST(!test("", ~xdigit, 'f')); + BOOST_TEST(test("g", ~xdigit, 'g')); + } + + { + using namespace boost::spirit::ascii; + BOOST_TEST(test("a", ~~alpha, 'a')); + BOOST_TEST(!test("", ~~alpha, '1')); + BOOST_TEST(test(" ", ~~blank, ' ')); + BOOST_TEST(!test("", ~~blank, 'x')); + BOOST_TEST(test("1", ~~digit, '1')); + BOOST_TEST(!test("", ~~digit, 'x')); + BOOST_TEST(test("a", ~~lower, 'a')); + BOOST_TEST(!test("", ~~lower, 'A')); + BOOST_TEST(test("!", ~~punct, '!')); + BOOST_TEST(!test("", ~~punct, 'x')); + BOOST_TEST(test(" ", ~~space)); + BOOST_TEST(test(" ", ~~space, ' ')); + BOOST_TEST(!test("", ~~space, '\n')); + BOOST_TEST(test("\r", ~~space, '\r')); + BOOST_TEST(test("\t", ~~space, '\t')); + BOOST_TEST(test("A", ~~upper, 'A')); + BOOST_TEST(!test("", ~~upper, 'a')); + BOOST_TEST(test("A", ~~xdigit, 'A')); + BOOST_TEST(test("0", ~~xdigit, '0')); + BOOST_TEST(test("f", ~~xdigit, 'f')); + BOOST_TEST(!test("", ~~xdigit, 'g')); + } + + { + using namespace boost::spirit::ascii; + BOOST_TEST(test("a", lower[alpha], 'a')); + BOOST_TEST(!test("", lower[alpha], 'A')); + BOOST_TEST(!test("", lower[alpha], '1')); + BOOST_TEST(test("a", lower[alnum], 'a')); + BOOST_TEST(!test("", lower[alnum], 'A')); + BOOST_TEST(test("1", lower[alnum], '1')); + + BOOST_TEST(!test("", upper[alpha], 'a')); + BOOST_TEST(test("A", upper[alpha], 'A')); + BOOST_TEST(!test("", upper[alpha], '1')); + BOOST_TEST(!test("", upper[alnum], 'a')); + BOOST_TEST(test("A", upper[alnum], 'A')); + BOOST_TEST(test("1", upper[alnum], '1')); + } + + { + using namespace boost::spirit::iso8859_1; + BOOST_TEST(test("a", alpha, 'a')); + BOOST_TEST(!test("", alpha, '1')); + BOOST_TEST(test(" ", blank, ' ')); + BOOST_TEST(!test("", blank, 'x')); + BOOST_TEST(test("1", digit, '1')); + BOOST_TEST(!test("", digit, 'x')); + BOOST_TEST(test("a", lower, 'a')); + BOOST_TEST(!test("", lower, 'A')); + BOOST_TEST(test("!", punct, '!')); + BOOST_TEST(!test("", punct, 'x')); + BOOST_TEST(test(" ", space)); + BOOST_TEST(test(" ", space, ' ')); + BOOST_TEST(!test("", space, '\n')); + BOOST_TEST(test("\r", space, '\r')); + BOOST_TEST(test("\t", space, '\t')); + BOOST_TEST(test("A", upper, 'A')); + BOOST_TEST(!test("", upper, 'a')); + BOOST_TEST(test("A", xdigit, 'A')); + BOOST_TEST(test("0", xdigit, '0')); + BOOST_TEST(test("f", xdigit, 'f')); + BOOST_TEST(!test("", xdigit, 'g')); + + + // test extended ASCII characters + BOOST_TEST(test("\xE9", alpha, '\xE9')); + BOOST_TEST(test("\xE9", lower, '\xE9')); + BOOST_TEST(!test("", upper, '\xE9')); + } + + { + using namespace boost::spirit::standard; + BOOST_TEST(test("a", alpha, 'a')); + BOOST_TEST(!test("", alpha, '1')); + BOOST_TEST(test(" ", blank, ' ')); + BOOST_TEST(!test("", blank, 'x')); + BOOST_TEST(test("1", digit, '1')); + BOOST_TEST(!test("", digit, 'x')); + BOOST_TEST(test("a", lower, 'a')); + BOOST_TEST(!test("", lower, 'A')); + BOOST_TEST(test("!", punct, '!')); + BOOST_TEST(!test("", punct, 'x')); + BOOST_TEST(test(" ", space)); + BOOST_TEST(test(" ", space, ' ')); + BOOST_TEST(!test("", space, '\n')); + BOOST_TEST(test("\r", space, '\r')); + BOOST_TEST(test("\t", space, '\t')); + BOOST_TEST(test("A", upper, 'A')); + BOOST_TEST(!test("", upper, 'a')); + BOOST_TEST(test("A", xdigit, 'A')); + BOOST_TEST(test("0", xdigit, '0')); + BOOST_TEST(test("f", xdigit, 'f')); + BOOST_TEST(!test("", xdigit, 'g')); + } + + { + using namespace boost::spirit::standard_wide; + BOOST_TEST(test(L"a", alpha, L'a')); + BOOST_TEST(!test(L"", alpha, L'1')); + BOOST_TEST(test(L" ", blank, L' ')); + BOOST_TEST(!test(L"", blank, L'x')); + BOOST_TEST(test(L"1", digit, L'1')); + BOOST_TEST(!test(L"", digit, L'x')); + BOOST_TEST(test(L"a", lower, L'a')); + BOOST_TEST(!test(L"", lower, L'A')); + BOOST_TEST(test(L"!", punct, L'!')); + BOOST_TEST(!test(L"", punct, L'x')); + BOOST_TEST(test(L" ", space)); + BOOST_TEST(test(L" ", space, L' ')); + BOOST_TEST(!test(L"", space, L'\n')); + BOOST_TEST(test(L"\r", space, L'\r')); + BOOST_TEST(test(L"\t", space, L'\t')); + BOOST_TEST(test(L"A", upper, L'A')); + BOOST_TEST(!test(L"", upper, L'a')); + BOOST_TEST(test(L"A", xdigit, L'A')); + BOOST_TEST(test(L"0", xdigit, L'0')); + BOOST_TEST(test(L"f", xdigit, L'f')); + BOOST_TEST(!test(L"", xdigit, L'g')); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/columns.cpp b/src/boost/libs/spirit/test/karma/columns.cpp new file mode 100644 index 00000000..070724b4 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/columns.cpp @@ -0,0 +1,97 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_directive.hpp> + +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_action.hpp> + +#include <boost/spirit/include/phoenix_core.hpp> + +#include "test.hpp" + +using namespace spirit_test; +namespace karma = boost::spirit::karma; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + { + using karma::columns; + using karma::int_; + + std::vector<int> v; + for (int i = 0; i < 11; ++i) + v.push_back(i); + + BOOST_TEST(test("01234\n56789\n10\n", columns[*int_], v)); + BOOST_TEST(test_delimited("0 1 2 3 4 \n5 6 7 8 9 \n10 \n", columns[*int_] + , v, karma::space)); + } + + { + using karma::columns; + using karma::int_; + + std::vector<int> v; + for (int i = 0; i < 11; ++i) + v.push_back(i); + + BOOST_TEST(test("012\n345\n678\n910\n", columns(3)[*int_], v)); + BOOST_TEST(test_delimited("0 1 2 \n3 4 5 \n6 7 8 \n9 10 \n" + , columns(3)[*int_], v, karma::space)); + } + + { + using karma::columns; + using karma::int_; + using boost::phoenix::ref; + + std::vector<int> v; + for (int i = 0; i < 11; ++i) + v.push_back(i); + + int count = 3; + BOOST_TEST(test("012\n345\n678\n910\n", columns(ref(count))[*int_], v)); + BOOST_TEST(test_delimited("0 1 2 \n3 4 5 \n6 7 8 \n9 10 \n" + , columns(val(ref(count)))[*int_], v, karma::space)); + } + + { + using karma::columns; + using karma::int_; + using karma::lit; + + std::vector<int> v; + for (int i = 0; i < 11; ++i) + v.push_back(i); + + BOOST_TEST(test("01234\t56789\t10\t", columns(lit('\t'))[*int_], v)); + BOOST_TEST(test_delimited("0 1 2 3 4 \t5 6 7 8 9 \t10 \t" + , columns(lit('\t'))[*int_], v, karma::space)); + } + + { + using karma::columns; + using karma::int_; + using karma::lit; + + std::vector<int> v; + for (int i = 0; i < 11; ++i) + v.push_back(i); + + BOOST_TEST(test("012\t345\t678\t910\t", columns(3, lit('\t'))[*int_], v)); + BOOST_TEST(test_delimited("0 1 2 \t3 4 5 \t6 7 8 \t9 10 \t" + , columns(3, lit('\t'))[*int_], v, karma::space)); + } + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/debug.cpp b/src/boost/libs/spirit/test/karma/debug.cpp new file mode 100644 index 00000000..19137d44 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/debug.cpp @@ -0,0 +1,107 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2001-2011 Joel de Guzman +// +// 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 BOOST_SPIRIT_KARMA_DEBUG + +#include <boost/detail/lightweight_test.hpp> +#include <boost/spirit/include/karma_operator.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_auxiliary.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/fusion/include/std_pair.hpp> + +#include <string> +#include <cstring> +#include <iostream> +#include "test.hpp" + +int main() +{ + using spirit_test::test; + using spirit_test::test_delimited; + + using namespace boost::spirit::ascii; + using namespace boost::spirit::karma::labels; + using boost::spirit::karma::locals; + using boost::spirit::karma::rule; + using boost::spirit::karma::char_; + using boost::spirit::karma::debug; + using boost::spirit::karma::space; + using boost::spirit::karma::eps; + + typedef spirit_test::output_iterator<char>::type outiter_type; + + { // basic tests + rule<outiter_type, char()> a, b, c; + rule<outiter_type, std::vector<char>()> start; + + std::vector<char> v; + v.push_back('a'); + v.push_back('b'); + v.push_back('a'); + v.push_back('c'); + v.push_back('a'); + v.push_back('b'); + v.push_back('b'); + v.push_back('a'); + + a = char_('a'); + b = char_('b'); + c = char_('c'); + BOOST_SPIRIT_DEBUG_NODE(a); + BOOST_SPIRIT_DEBUG_NODE(b); + BOOST_SPIRIT_DEBUG_NODE(c); + + start = *(a | b | c); + BOOST_SPIRIT_DEBUG_NODE(start); + BOOST_TEST(test("abacabba", start, v)); + + // ignore the delimiter + BOOST_TEST(test_delimited("abacabba ", start, v, space)); + + std::vector<char> v1; + v1.push_back('b'); + v1.push_back('c'); + + start = (a | b) << c; + BOOST_SPIRIT_DEBUG_NODE(start); + BOOST_TEST(test("bc", start, v1)); + } + + { // tests with locals + rule<outiter_type, char()> a, b, c; + rule<outiter_type, std::vector<char>(), locals<int, double> > start; + + std::vector<char> v; + v.push_back('a'); + v.push_back('b'); + v.push_back('a'); + v.push_back('c'); + v.push_back('a'); + v.push_back('b'); + v.push_back('b'); + v.push_back('a'); + + a = char_('a'); + b = char_('b'); + c = char_('c'); + BOOST_SPIRIT_DEBUG_NODE(a); + BOOST_SPIRIT_DEBUG_NODE(b); + BOOST_SPIRIT_DEBUG_NODE(c); + + start %= eps[_a = 0, _b = 2.0] << *(a[++_a] | b | c); + BOOST_SPIRIT_DEBUG_NODE(start); + BOOST_TEST(test("abacabba", start, v)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/delimiter.cpp b/src/boost/libs/spirit/test/karma/delimiter.cpp new file mode 100644 index 00000000..15133189 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/delimiter.cpp @@ -0,0 +1,83 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_string.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + BOOST_TEST(test("a b ", delimit[char_('a') << 'b'])); + BOOST_TEST(test("a*b*", delimit('*')[char_('a') << 'b'])); + + BOOST_TEST(test("ab c d", + char_('a') << delimit[char_('b') << 'c'] << 'd')); + BOOST_TEST(test("ab*c*d", + char_('a') << delimit('*')[char_('b') << 'c'] << 'd')); + + BOOST_TEST(test_delimited("a b ", delimit[char_('a') << 'b'], char_(' '))); + BOOST_TEST(test_delimited("a*b*", delimit('*')[char_('a') << 'b'], char_(' '))); + + BOOST_TEST(test_delimited("a b c d ", + char_('a') << delimit[char_('b') << 'c'] << 'd', char_(' '))); + BOOST_TEST(test_delimited("a b*c*d ", + char_('a') << delimit('*')[char_('b') << 'c'] << 'd', char_(' '))); + } + + { + BOOST_TEST(test("ab", verbatim[char_('a') << 'b'])); + BOOST_TEST(test("abcd", + char_('a') << verbatim[char_('b') << 'c'] << 'd')); + + BOOST_TEST(test_delimited("ab ", + verbatim[char_('a') << 'b'], char_(' '))); + BOOST_TEST(test_delimited("a bc d ", + char_('a') << verbatim[char_('b') << 'c'] << 'd', char_(' '))); + } + + { + BOOST_TEST(test("ab", no_delimit[char_('a') << 'b'])); + BOOST_TEST(test("abcd", + char_('a') << no_delimit[char_('b') << 'c'] << 'd')); + + BOOST_TEST(test_delimited("ab", + no_delimit[char_('a') << 'b'], char_(' '))); + BOOST_TEST(test_delimited("a bcd ", + char_('a') << no_delimit[char_('b') << 'c'] << 'd', char_(' '))); + } + + { + // The doubled delimiters at the end are generated by the 'b' generator + // and the verbatim[] directive. Currently, there is no easy way to + // avoid this. + BOOST_TEST(test("a b ", delimit[verbatim[delimit[char_('a') << 'b']]])); + BOOST_TEST(test_delimited("a*b**", + verbatim[delimit[char_('a') << 'b']], char_('*'))); + } + + { + karma::rule<output_iterator<char>::type, BOOST_TYPEOF(", ")> r = "abc"; + BOOST_TEST(test("abc, ", delimit(", ")[r])); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/duplicate.cpp b/src/boost/libs/spirit/test/karma/duplicate.cpp new file mode 100644 index 00000000..57f824b4 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/duplicate.cpp @@ -0,0 +1,56 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma.hpp> + +#include <iostream> +#include "test.hpp" + +using namespace spirit_test; + +int main() +{ + using boost::spirit::karma::double_; + using boost::spirit::karma::space; + using boost::spirit::karma::duplicate; + + // test for sequences + { + BOOST_TEST(test("2.02.0", duplicate[double_ << double_], 2.0)); + BOOST_TEST(test_delimited("2.0 2.0 ", + duplicate[double_ << double_], 2.0, space)); + BOOST_TEST(test("2.02.02.0", + duplicate[double_ << double_ << double_], 2.0)); + BOOST_TEST(test_delimited("2.0 2.0 2.0 ", + duplicate[double_ << double_ << double_], 2.0, space)); + } + + // test for non-sequences + { + BOOST_TEST(test("2.02.0", duplicate["2.0" << double_], 2.0)); + BOOST_TEST(test_delimited("2.0 2.0 ", + duplicate["2.0" << double_], 2.0, space)); + } + + // test for subjects exposing no attribute + { + BOOST_TEST(test("2.02.0", duplicate["2.0"] << double_, 2.0)); + BOOST_TEST(test_delimited("2.0 2.0 ", + duplicate["2.0"] << double_, 2.0, space)); + } + + // test for attribute reporting + { + BOOST_TEST(test("bar", (duplicate["bar"] | "foo"))); + BOOST_TEST(test("2.0", (duplicate[double_] | "foo"), 2.0)); + BOOST_TEST(test("2.02.0", + (duplicate[double_ << double_] | "foo"), 2.0)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/encoding.cpp b/src/boost/libs/spirit/test/karma/encoding.cpp new file mode 100644 index 00000000..05e8018c --- /dev/null +++ b/src/boost/libs/spirit/test/karma/encoding.cpp @@ -0,0 +1,55 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2001-2011 Joel de Guzman +// +// 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) + +#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_directive.hpp> +#include <boost/spirit/include/karma_action.hpp> + +#include <iostream> +#include "test.hpp" + +int +main() +{ + using spirit_test::test; + using boost::spirit::karma::lit; + using boost::spirit::karma::lower; + using boost::spirit::karma::upper; + using boost::spirit::karma::char_; + using boost::spirit::karma::encoding; + namespace char_encoding = boost::spirit::char_encoding; + + encoding<char_encoding::iso8859_1> iso8859_1; + + { // test extended ASCII characters + BOOST_TEST(test("\xE1", iso8859_1[lower['\xE1']])); + BOOST_TEST(test("\xC1", iso8859_1[upper['\xE1']])); + BOOST_TEST(test("\xE1", iso8859_1[lower[char_('\xE1')]])); + BOOST_TEST(test("\xC1", iso8859_1[upper[char_('\xE1')]])); + BOOST_TEST(test("\xE1", iso8859_1[lower[lit('\xE1')]])); + BOOST_TEST(test("\xC1", iso8859_1[upper[lit('\xE1')]])); + BOOST_TEST(test("\xE1", iso8859_1[lower[char_]], '\xE1')); + BOOST_TEST(test("\xC1", iso8859_1[upper[char_]], '\xE1')); + BOOST_TEST(test("\xE1", iso8859_1[lower['\xC1']])); + BOOST_TEST(test("\xC1", iso8859_1[upper['\xC1']])); + BOOST_TEST(test("\xE1", iso8859_1[lower[char_('\xC1')]])); + BOOST_TEST(test("\xC1", iso8859_1[upper[char_('\xC1')]])); + BOOST_TEST(test("\xE1", iso8859_1[lower[lit('\xC1')]])); + BOOST_TEST(test("\xC1", iso8859_1[upper[lit('\xC1')]])); + BOOST_TEST(test("\xE1", iso8859_1[lower[char_]], '\xC1')); + BOOST_TEST(test("\xC1", iso8859_1[upper[char_]], '\xC1')); + + BOOST_TEST(test("\xE4\xE4", iso8859_1[lower["\xC4\xE4"]])); + BOOST_TEST(test("\xE4\xE4", iso8859_1[lower[lit("\xC4\xE4")]])); + + BOOST_TEST(test("\xC4\xC4", iso8859_1[upper["\xC4\xE4"]])); + BOOST_TEST(test("\xC4\xC4", iso8859_1[upper[lit("\xC4\xE4")]])); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/eol.cpp b/src/boost/libs/spirit/test/karma/eol.cpp new file mode 100644 index 00000000..cf4e18d1 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/eol.cpp @@ -0,0 +1,33 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_generate.hpp> + +#include <iostream> +#include "test.hpp" + +int +main() +{ + using namespace spirit_test; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + BOOST_TEST((test("\n", eol))); + BOOST_TEST((test("\n", eol))); + } + + { + BOOST_TEST((test_delimited("\n ", eol, space))); + BOOST_TEST((test_delimited("\n ", eol, space))); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/eps.cpp b/src/boost/libs/spirit/test/karma/eps.cpp new file mode 100644 index 00000000..6833d273 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/eps.cpp @@ -0,0 +1,59 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_char.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/phoenix_core.hpp> + +#include <iostream> +#include "test.hpp" + +int +main() +{ + using namespace spirit_test; + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test("", eps)); + BOOST_TEST(test_delimited(" ", eps, space)); + + BOOST_TEST(!test("", !eps)); + BOOST_TEST(!test_delimited(" ", !eps, space)); + } + + { // test direct argument + using namespace boost::phoenix; + + BOOST_TEST(test("", eps(true))); + BOOST_TEST(!test("", eps(false))); + } + + { // test action + using namespace boost::phoenix; + + BOOST_TEST(test("", eps(val(true)))); + BOOST_TEST(!test("", eps(val(false)))); + } + + { // test no delimiter when argument is false + using namespace boost::spirit::ascii; + + std::string generated; + std::back_insert_iterator<std::string> outit(generated); + BOOST_TEST(!karma::generate_delimited(outit, eps(false), space)); + BOOST_TEST(generated.empty()); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/format_manip.cpp b/src/boost/libs/spirit/test/karma/format_manip.cpp new file mode 100644 index 00000000..494eee4a --- /dev/null +++ b/src/boost/libs/spirit/test/karma/format_manip.cpp @@ -0,0 +1,215 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/mpl/print.hpp> +#include <boost/config/warning_disable.hpp> +#include <boost/spirit/include/karma.hpp> +#include <boost/spirit/include/karma_format.hpp> +#include <boost/spirit/include/karma_format_auto.hpp> +#include <boost/spirit/include/karma_stream.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include <string> +#include <sstream> +#include <vector> +#include <list> + +#include <boost/detail/lightweight_test.hpp> +#include <boost/assign/std/vector.hpp> +#include <boost/assign/std/list.hpp> + +/////////////////////////////////////////////////////////////////////////////// +template <typename Char, typename Expr> +bool test(Char const *expected, Expr const& xpr) +{ + // Report invalid expression error as early as possible. + // If you got an error_invalid_expression error message here, + // then the expression (expr) is not a valid spirit karma expression. + BOOST_SPIRIT_ASSERT_MATCH(boost::spirit::karma::domain, Expr); + + std::ostringstream ostrm; + ostrm << boost::spirit::compile<boost::spirit::karma::domain>(xpr); + return ostrm.good() && ostrm.str() == expected; +} + +template <typename Char, typename Expr, typename CopyExpr, typename CopyAttr + , typename Delimiter, typename Attribute> +bool test(Char const *expected, + boost::spirit::karma::detail::format_manip< + Expr, CopyExpr, CopyAttr, Delimiter, Attribute> const& fm) +{ + std::ostringstream ostrm; + ostrm << fm; + return ostrm.good() && ostrm.str() == expected; +} + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + namespace fusion = boost::fusion; + using namespace boost::phoenix; + + { + BOOST_TEST(test( "a", + char_('a') + )); + BOOST_TEST(test( "a", + char_[_1 = val('a')] + )); + BOOST_TEST(test( "a", + karma::format(char_[_1 = val('a')]) + )); + BOOST_TEST(test( "a ", + karma::format_delimited(char_[_1 = val('a')], space) + )); + BOOST_TEST(test( "a", + karma::format(char_, 'a') + )); + BOOST_TEST(test( "a ", + karma::format_delimited(char_, space, 'a') + )); + } + + { + BOOST_TEST(test( "ab", + char_[_1 = val('a')] << char_[_1 = val('b')] + )); + BOOST_TEST(test( "ab", + karma::format(char_[_1 = val('a')] << char_[_1 = val('b')]) + )); + BOOST_TEST(test( "a b ", + karma::format_delimited(char_[_1 = val('a')] << char_[_1 = val('b')], space) + )); + + fusion::vector<char, char> t('a', 'b'); + + BOOST_TEST(test( "ab", + karma::format(char_ << char_, t) + )); + BOOST_TEST(test( "a b ", + karma::format_delimited(char_ << char_, space, t) + )); + + BOOST_TEST(test( "ab", + karma::format(t) + )); + BOOST_TEST(test( "a b ", + karma::format_delimited(t, space) + )); + } + + { + BOOST_TEST(test( "abc", + char_[_1 = 'a'] << char_[_1 = 'b'] << char_[_1 = 'c'] + )); + BOOST_TEST(test( "abc", + karma::format(char_('a') << char_('b') << char_('c')) + )); + BOOST_TEST(test( "a b c ", + karma::format_delimited(char_('a') << char_('b') << char_('c'), space) + )); + + fusion::vector<char, char, char> t('a', 'b', 'c'); + + BOOST_TEST(test( "abc", + karma::format(char_ << char_ << char_, t) + )); + BOOST_TEST(test( "a b c ", + karma::format_delimited(char_ << char_ << char_, space, t) + )); + } + + { + BOOST_TEST(test( "a2", + (char_ << int_)[_1 = 'a', _2 = 2] + )); + + fusion::vector<char, int> t('a', 2); + + BOOST_TEST(test( "a2", + karma::format(char_ << int_, t) + )); + BOOST_TEST(test( "a 2 ", + karma::format_delimited(char_ << int_, space, t) + )); + } + + using namespace boost::assign; + + { + // output all elements of a vector + std::vector<char> v; + v += 'a', 'b', 'c'; + + BOOST_TEST(test( "abc", + (*char_)[_1 = v] + )); + BOOST_TEST(test( "abc", + karma::format(*char_, v) + )); + BOOST_TEST(test( "a b c ", + karma::format_delimited(*char_, space, v) + )); + + BOOST_TEST(test( "abc", + karma::format(v) + )); + BOOST_TEST(test( "a b c ", + karma::format_delimited(v, space) + )); + + // output a comma separated list of vector elements + BOOST_TEST(test( "a, b, c", + (char_ % lit(", "))[_0 = fusion::make_single_view(v)] + )); + BOOST_TEST(test( "a, b, c", + karma::format((char_ % lit(", "))[_0 = fusion::make_single_view(v)]) + )); + BOOST_TEST(test( "a , b , c ", + karma::format_delimited((char_ % ',')[_0 = fusion::make_single_view(v)], space) + )); + BOOST_TEST(test( "a,b,c", + karma::format(char_ % ',', v) + )); + BOOST_TEST(test( "a , b , c ", + karma::format_delimited(char_ % ',', space, v) + )); + + // output all elements of a list + std::list<char> l; + l += 'a', 'b', 'c'; + +// BOOST_TEST(test( "abc", +// (*char_)[_1 = l] +// )); +// BOOST_TEST(test( "abc", +// karma::format((*char_)[_1 = l]) +// )); +// BOOST_TEST(test( "a b c ", +// karma::format_delimited((*char_)[_1 = l], space) +// )); + BOOST_TEST(test( "abc", + karma::format(*char_, l) + )); + BOOST_TEST(test( "a b c ", + karma::format_delimited(*char_, space, l) + )); + + BOOST_TEST(test( "abc", + karma::format(l) + )); + BOOST_TEST(test( "a b c ", + karma::format_delimited(l, space) + )); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/format_manip_attr.cpp b/src/boost/libs/spirit/test/karma/format_manip_attr.cpp new file mode 100644 index 00000000..75645aed --- /dev/null +++ b/src/boost/libs/spirit/test/karma/format_manip_attr.cpp @@ -0,0 +1,175 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/karma_stream.hpp> +#include <boost/spirit/include/karma_format_attr.hpp> + +#include "test_manip_attr.hpp" + +#if SPIRIT_ARGUMENTS_LIMIT < 10 +# error SPIRIT_ARGUMENTS_LIMIT must be at least 10 to run the test +#endif + +using spirit_test::test; +using spirit_test::test_delimited; +using spirit_test::test_predelimited; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test("1", char_, '1')); + BOOST_TEST(test("12", char_ << char_, '1', '2')); + BOOST_TEST(test("123", char_ << char_ << char_, '1', '2', '3')); + BOOST_TEST(test("1234" + , char_ << char_ << char_ << char_ + , '1', '2', '3', '4')); + BOOST_TEST(test("12345" + , char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5')); + BOOST_TEST(test("123456" + , char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6')); + BOOST_TEST(test("1234567" + , char_ << char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6', '7')); + BOOST_TEST(test("12345678" + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6', '7', '8')); + BOOST_TEST(test("123456789" + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6', '7', '8', '9')); + BOOST_TEST(test("1234567890" + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6', '7', '8', '9', '0')); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test_delimited("1 ", char_, space, '1')); + BOOST_TEST(test_delimited("1 2 " + , char_ << char_, space, '1', '2')); + BOOST_TEST(test_delimited("1 2 3 " + , char_ << char_ << char_, space, '1', '2', '3')); + BOOST_TEST(test_delimited("1 2 3 4 " + , char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4')); + BOOST_TEST(test_delimited("1 2 3 4 5 " + , char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 " + , char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 7 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6', '7')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 7 8 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6', '7', '8')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 7 8 9 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6', '7', '8', '9')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 7 8 9 0 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0')); + } + + { + using namespace boost::spirit::ascii; + using boost::spirit::karma::delimit_flag; + + BOOST_TEST(test_predelimited(" 1 ", char_, space + , delimit_flag::predelimit, '1')); + BOOST_TEST(test_predelimited(" 1 2 " + , char_ << char_, space, delimit_flag::predelimit + , '1', '2')); + BOOST_TEST(test_predelimited(" 1 2 3 " + , char_ << char_ << char_, space + , delimit_flag::predelimit, '1', '2', '3')); + BOOST_TEST(test_predelimited(" 1 2 3 4 " + , char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit, '1', '2', '3', '4')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 " + , char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit, '1', '2', '3', '4', '5')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 " + , char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 7 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6', '7')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 7 8 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6', '7', '8')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 7 8 9 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6', '7', '8', '9')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 7 8 9 0 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6', '7', '8', '9', '0')); + } + + { + using namespace boost::spirit::ascii; + using boost::spirit::karma::delimit_flag; + + BOOST_TEST(test_predelimited("1 ", char_, space + , delimit_flag::dont_predelimit, '1')); + BOOST_TEST(test_predelimited("1 2 " + , char_ << char_, space, delimit_flag::dont_predelimit + , '1', '2')); + BOOST_TEST(test_predelimited("1 2 3 " + , char_ << char_ << char_, space + , delimit_flag::dont_predelimit, '1', '2', '3')); + BOOST_TEST(test_predelimited("1 2 3 4 " + , char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit, '1', '2', '3', '4')); + BOOST_TEST(test_predelimited("1 2 3 4 5 " + , char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit, '1', '2', '3', '4', '5')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 " + , char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 7 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6', '7')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 7 8 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6', '7', '8')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 7 8 9 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6', '7', '8', '9')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 7 8 9 0 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6', '7', '8', '9', '0')); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/format_pointer_container.cpp b/src/boost/libs/spirit/test/karma/format_pointer_container.cpp new file mode 100644 index 00000000..98da2b36 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/format_pointer_container.cpp @@ -0,0 +1,59 @@ +// Copyright (c) 2009 Matthias Vallentin +// +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/iterator/indirect_iterator.hpp> +#include <boost/make_shared.hpp> +#include <boost/noncopyable.hpp> +#include <boost/spirit/include/karma.hpp> +#include <boost/spirit/include/karma_format.hpp> + +#include <sstream> +#include <string> +#include <vector> + +struct foo : boost::noncopyable +{ + foo() + : str("foo") + { + } + + std::string str; +}; + +template <typename Stream> +Stream& operator<<(Stream& out, const foo& f) +{ + out << f.str; + return out; +} + +int main() +{ + using namespace boost::spirit; + + typedef boost::shared_ptr<foo> foo_ptr; + std::vector<foo_ptr> v; + + std::size_t i = 10; + while (i--) + v.push_back(boost::make_shared<foo>()); + + typedef boost::indirect_iterator<std::vector<foo_ptr>::const_iterator> + iterator_type; + + std::stringstream strm; + strm + << karma::format(stream % ',', + boost::iterator_range<iterator_type>( + iterator_type(v.begin()), iterator_type(v.end()) + ) + ); + BOOST_TEST(strm.str() == "foo,foo,foo,foo,foo,foo,foo,foo,foo,foo"); + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/generate_attr.cpp b/src/boost/libs/spirit/test/karma/generate_attr.cpp new file mode 100644 index 00000000..7656f4c3 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/generate_attr.cpp @@ -0,0 +1,169 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_generate_attr.hpp> + +#include "test_attr.hpp" + +#if SPIRIT_ARGUMENTS_LIMIT < 10 +# error SPIRIT_ARGUMENTS_LIMIT must be at least 10 to run the test +#endif + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test("1", char_, '1')); + BOOST_TEST(test("12", char_ << char_, '1', '2')); + BOOST_TEST(test("123", char_ << char_ << char_, '1', '2', '3')); + BOOST_TEST(test("1234" + , char_ << char_ << char_ << char_ + , '1', '2', '3', '4')); + BOOST_TEST(test("12345" + , char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5')); + BOOST_TEST(test("123456" + , char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6')); + BOOST_TEST(test("1234567" + , char_ << char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6', '7')); + BOOST_TEST(test("12345678" + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6', '7', '8')); + BOOST_TEST(test("123456789" + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6', '7', '8', '9')); + BOOST_TEST(test("1234567890" + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , '1', '2', '3', '4', '5', '6', '7', '8', '9', '0')); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test_delimited("1 ", char_, space, '1')); + BOOST_TEST(test_delimited("1 2 " + , char_ << char_, space, '1', '2')); + BOOST_TEST(test_delimited("1 2 3 " + , char_ << char_ << char_, space, '1', '2', '3')); + BOOST_TEST(test_delimited("1 2 3 4 " + , char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4')); + BOOST_TEST(test_delimited("1 2 3 4 5 " + , char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 " + , char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 7 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6', '7')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 7 8 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6', '7', '8')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 7 8 9 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6', '7', '8', '9')); + BOOST_TEST(test_delimited("1 2 3 4 5 6 7 8 9 0 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0')); + } + + { + using namespace boost::spirit::ascii; + using boost::spirit::karma::delimit_flag; + + BOOST_TEST(test_predelimited(" 1 ", char_, space + , delimit_flag::predelimit, '1')); + BOOST_TEST(test_predelimited(" 1 2 " + , char_ << char_, space, delimit_flag::predelimit + , '1', '2')); + BOOST_TEST(test_predelimited(" 1 2 3 " + , char_ << char_ << char_, space + , delimit_flag::predelimit, '1', '2', '3')); + BOOST_TEST(test_predelimited(" 1 2 3 4 " + , char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit, '1', '2', '3', '4')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 " + , char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit, '1', '2', '3', '4', '5')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 " + , char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 7 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6', '7')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 7 8 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6', '7', '8')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 7 8 9 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6', '7', '8', '9')); + BOOST_TEST(test_predelimited(" 1 2 3 4 5 6 7 8 9 0 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::predelimit + , '1', '2', '3', '4', '5', '6', '7', '8', '9', '0')); + } + + { + using namespace boost::spirit::ascii; + using boost::spirit::karma::delimit_flag; + + BOOST_TEST(test_predelimited("1 ", char_, space + , delimit_flag::dont_predelimit, '1')); + BOOST_TEST(test_predelimited("1 2 " + , char_ << char_, space, delimit_flag::dont_predelimit + , '1', '2')); + BOOST_TEST(test_predelimited("1 2 3 " + , char_ << char_ << char_, space + , delimit_flag::dont_predelimit, '1', '2', '3')); + BOOST_TEST(test_predelimited("1 2 3 4 " + , char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit, '1', '2', '3', '4')); + BOOST_TEST(test_predelimited("1 2 3 4 5 " + , char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit, '1', '2', '3', '4', '5')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 " + , char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 7 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6', '7')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 7 8 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6', '7', '8')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 7 8 9 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6', '7', '8', '9')); + BOOST_TEST(test_predelimited("1 2 3 4 5 6 7 8 9 0 " + , char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ << char_ + , space, delimit_flag::dont_predelimit + , '1', '2', '3', '4', '5', '6', '7', '8', '9', '0')); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/grammar.cpp b/src/boost/libs/spirit/test/karma/grammar.cpp new file mode 100644 index 00000000..d95956de --- /dev/null +++ b/src/boost/libs/spirit/test/karma/grammar.cpp @@ -0,0 +1,57 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_operator.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_nonterminal.hpp> +#include <boost/spirit/include/karma_action.hpp> + +#include <string> +#include <iostream> + +#include "test.hpp" + +using namespace spirit_test; +using namespace boost::spirit; +using namespace boost::spirit::ascii; + +typedef spirit_test::output_iterator<char>::type outiter_type; + +struct num_list : karma::grammar<outiter_type, space_type> +{ + num_list() : num_list::base_type(start) + { + using boost::spirit::int_; + num1 = int_(123); + num2 = int_(456); + num3 = int_(789); + start = num1 << ',' << num2 << ',' << num3; + } + + karma::rule<outiter_type, space_type> start, num1, num2, num3; +}; + +int +main() +{ + { // simple grammar test + num_list nlist; + BOOST_TEST(test_delimited("123 , 456 , 789 ", nlist, space)); + } + + { // direct access to the rules + num_list def; + BOOST_TEST(test_delimited("123 ", def.num1, space)); + BOOST_TEST(test_delimited("123 , 456 , 789 ", def.start, space)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/grammar_fail.cpp b/src/boost/libs/spirit/test/karma/grammar_fail.cpp new file mode 100644 index 00000000..9af96765 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/grammar_fail.cpp @@ -0,0 +1,45 @@ +/*============================================================================= + Copyright (c) 2001-2011 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) +=============================================================================*/ + +#include <boost/config/warning_disable.hpp> + +#include <boost/spirit/include/karma_operator.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_nonterminal.hpp> +#include <boost/spirit/include/karma_generate.hpp> + +#include "test.hpp" + +using namespace boost::spirit; +using namespace boost::spirit::ascii; + +typedef spirit_test::output_iterator<char>::type outiter_type; + +struct num_list : karma::grammar<outiter_type, karma::rule<outiter_type> > +{ + num_list() : num_list::base_type(start) + { + start = int_(1) << ',' << int_(0); + } + + karma::rule<outiter_type, karma::rule<outiter_type> > start; +}; + +// this test must fail compiling as the rule is used with an incompatible +// delimiter type +int main() +{ + std::string generated; + + std::back_insert_iterator<std::string> outit(generated); + num_list def; + generate_delimited(outit, def, char_('%') << '\n'); + + return 0; +} diff --git a/src/boost/libs/spirit/test/karma/int1.cpp b/src/boost/libs/spirit/test/karma/int1.cpp new file mode 100644 index 00000000..4bb40a83 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/int1.cpp @@ -0,0 +1,170 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/mpl/vector.hpp> +#include <boost/mpl/for_each.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/bool.hpp> + +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_action.hpp> + +#include <boost/limits.hpp> +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + + /////////////////////////////////////////////////////////////////////// + // this is currently ambiguous with character literals + BOOST_TEST(test("0", 0)); + BOOST_TEST(test("123", 123)); + BOOST_TEST(test("-123", -123)); + + BOOST_TEST(test("0", int_, 0)); + BOOST_TEST(test("123", int_, 123)); + BOOST_TEST(test("-123", int_, -123)); + + BOOST_TEST(test_delimited("0 ", int_, 0, char_(' '))); + BOOST_TEST(test_delimited("123 ", int_, 123, char_(' '))); + BOOST_TEST(test_delimited("-123 ", int_, -123, char_(' '))); + + BOOST_TEST(test("0", lower[int_], 0)); + BOOST_TEST(test("123", lower[int_], 123)); + BOOST_TEST(test("-123", lower[int_], -123)); + + BOOST_TEST(test_delimited("0 ", lower[int_], 0, char_(' '))); + BOOST_TEST(test_delimited("123 ", lower[int_], 123, char_(' '))); + BOOST_TEST(test_delimited("-123 ", lower[int_], -123, char_(' '))); + + BOOST_TEST(test("0", upper[int_], 0)); + BOOST_TEST(test("123", upper[int_], 123)); + BOOST_TEST(test("-123", upper[int_], -123)); + + BOOST_TEST(test_delimited("0 ", upper[int_], 0, char_(' '))); + BOOST_TEST(test_delimited("123 ", upper[int_], 123, char_(' '))); + BOOST_TEST(test_delimited("-123 ", upper[int_], -123, char_(' '))); + + /////////////////////////////////////////////////////////////////////// + BOOST_TEST(test("0", int_(0))); + BOOST_TEST(test("123", int_(123))); + BOOST_TEST(test("-123", int_(-123))); + + BOOST_TEST(test_delimited("0 ", int_(0), char_(' '))); + BOOST_TEST(test_delimited("123 ", int_(123), char_(' '))); + BOOST_TEST(test_delimited("-123 ", int_(-123), char_(' '))); + + BOOST_TEST(test("0", lower[int_(0)])); + BOOST_TEST(test("123", lower[int_(123)])); + BOOST_TEST(test("-123", lower[int_(-123)])); + + BOOST_TEST(test_delimited("0 ", lower[int_(0)], char_(' '))); + BOOST_TEST(test_delimited("123 ", lower[int_(123)], char_(' '))); + BOOST_TEST(test_delimited("-123 ", lower[int_(-123)], char_(' '))); + + BOOST_TEST(test("0", upper[int_(0)])); + BOOST_TEST(test("123", upper[int_(123)])); + BOOST_TEST(test("-123", upper[int_(-123)])); + + BOOST_TEST(test_delimited("0 ", upper[int_(0)], char_(' '))); + BOOST_TEST(test_delimited("123 ", upper[int_(123)], char_(' '))); + BOOST_TEST(test_delimited("-123 ", upper[int_(-123)], char_(' '))); + } + + { // literals, make sure there are no ambiguities + BOOST_TEST(test("0", lit(short(0)))); + BOOST_TEST(test("0", lit(0))); + BOOST_TEST(test("0", lit(0L))); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(test("0", lit(0LL))); +#endif + + BOOST_TEST(test("0", lit((unsigned short)0))); + BOOST_TEST(test("0", lit(0U))); + BOOST_TEST(test("0", lit(0UL))); +#ifdef BOOST_HAS_LONG_LONG + BOOST_TEST(test("0", lit(0ULL))); +#endif + + BOOST_TEST(test("a", lit('a'))); + BOOST_TEST(test("a", 'a')); + BOOST_TEST(test(L"a", L'a')); + } + + { // lazy numerics + using namespace boost::phoenix; + + BOOST_TEST(test("0", int_(val(0)))); + BOOST_TEST(test("123", int_(val(123)))); + BOOST_TEST(test("-123", int_(val(-123)))); + + int i1 = 0, i2 = 123, i3 = -123; + BOOST_TEST(test("0", int_(ref(i1)))); + BOOST_TEST(test("123", int_(ref(i2)))); + BOOST_TEST(test("-123", int_(ref(i3)))); + } + + { + /////////////////////////////////////////////////////////////////////// + using namespace boost::spirit::ascii; + BOOST_TEST(test("1234", uint_(1234))); + BOOST_TEST(test("ff", hex(0xff))); + BOOST_TEST(test("1234", oct(01234))); + BOOST_TEST(test("11110000", bin(0xf0))); + + BOOST_TEST(test_delimited("1234 ", uint_(1234), char_(' '))); + BOOST_TEST(test_delimited("ff ", hex(0xff), char_(' '))); + BOOST_TEST(test_delimited("1234 ", oct(01234), char_(' '))); + BOOST_TEST(test_delimited("11110000 ", bin(0xf0), char_(' '))); + + BOOST_TEST(test("1234", lower[uint_(1234)])); + BOOST_TEST(test("ff", lower[hex(0xff)])); + BOOST_TEST(test("1234", lower[oct(01234)])); + BOOST_TEST(test("11110000", lower[bin(0xf0)])); + + BOOST_TEST(test_delimited("1234 ", lower[uint_(1234)], char_(' '))); + BOOST_TEST(test_delimited("ff ", lower[hex(0xff)], char_(' '))); + BOOST_TEST(test_delimited("1234 ", lower[oct(01234)], char_(' '))); + BOOST_TEST(test_delimited("11110000 ", lower[bin(0xf0)], char_(' '))); + + BOOST_TEST(test("1234", upper[uint_(1234)])); + BOOST_TEST(test("FF", upper[hex(0xff)])); + BOOST_TEST(test("1234", upper[oct(01234)])); + BOOST_TEST(test("11110000", upper[bin(0xf0)])); + + BOOST_TEST(test_delimited("1234 ", upper[uint_(1234)], char_(' '))); + BOOST_TEST(test_delimited("FF ", upper[hex(0xff)], char_(' '))); + BOOST_TEST(test_delimited("1234 ", upper[oct(01234)], char_(' '))); + BOOST_TEST(test_delimited("11110000 ", upper[bin(0xf0)], char_(' '))); + + BOOST_TEST(test("FF", upper[upper[hex(0xff)]])); + BOOST_TEST(test("FF", upper[lower[hex(0xff)]])); + BOOST_TEST(test("ff", lower[upper[hex(0xff)]])); + BOOST_TEST(test("ff", lower[lower[hex(0xff)]])); + + BOOST_TEST(test_delimited("FF ", upper[upper[hex(0xff)]], char_(' '))); + BOOST_TEST(test_delimited("FF ", upper[lower[hex(0xff)]], char_(' '))); + BOOST_TEST(test_delimited("ff ", lower[upper[hex(0xff)]], char_(' '))); + BOOST_TEST(test_delimited("ff ", lower[lower[hex(0xff)]], char_(' '))); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/int2.cpp b/src/boost/libs/spirit/test/karma/int2.cpp new file mode 100644 index 00000000..1912d73c --- /dev/null +++ b/src/boost/libs/spirit/test/karma/int2.cpp @@ -0,0 +1,177 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/mpl/vector.hpp> +#include <boost/mpl/for_each.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/bool.hpp> + +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/karma_rule.hpp> + +#include <boost/limits.hpp> +#include "test.hpp" + +using namespace spirit_test; + + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + + karma::int_generator<int, 10, true> const signed_int = + karma::int_generator<int, 10, true>(); + + /////////////////////////////////////////////////////////////////////// + BOOST_TEST(test(" 0", signed_int, 0)); + BOOST_TEST(test("+123", signed_int, 123)); + BOOST_TEST(test("-123", signed_int, -123)); + + BOOST_TEST(test_delimited(" 0 ", signed_int, 0, char_(' '))); + BOOST_TEST(test_delimited("+123 ", signed_int, 123, char_(' '))); + BOOST_TEST(test_delimited("-123 ", signed_int, -123, char_(' '))); + + BOOST_TEST(test(" 0", lower[signed_int], 0)); + BOOST_TEST(test("+123", lower[signed_int], 123)); + BOOST_TEST(test("-123", lower[signed_int], -123)); + + BOOST_TEST(test_delimited(" 0 ", lower[signed_int], 0, char_(' '))); + BOOST_TEST(test_delimited("+123 ", lower[signed_int], 123, char_(' '))); + BOOST_TEST(test_delimited("-123 ", lower[signed_int], -123, char_(' '))); + + BOOST_TEST(test(" 0", upper[signed_int], 0)); + BOOST_TEST(test("+123", upper[signed_int], 123)); + BOOST_TEST(test("-123", upper[signed_int], -123)); + + BOOST_TEST(test_delimited(" 0 ", upper[signed_int], 0, char_(' '))); + BOOST_TEST(test_delimited("+123 ", upper[signed_int], 123, char_(' '))); + BOOST_TEST(test_delimited("-123 ", upper[signed_int], -123, char_(' '))); + + /////////////////////////////////////////////////////////////////////// + BOOST_TEST(test(" 0", signed_int(0))); + BOOST_TEST(test("+123", signed_int(123))); + BOOST_TEST(test("-123", signed_int(-123))); + + BOOST_TEST(test_delimited(" 0 ", signed_int(0), char_(' '))); + BOOST_TEST(test_delimited("+123 ", signed_int(123), char_(' '))); + BOOST_TEST(test_delimited("-123 ", signed_int(-123), char_(' '))); + + BOOST_TEST(test(" 0", lower[signed_int(0)])); + BOOST_TEST(test("+123", lower[signed_int(123)])); + BOOST_TEST(test("-123", lower[signed_int(-123)])); + + BOOST_TEST(test_delimited(" 0 ", lower[signed_int(0)], char_(' '))); + BOOST_TEST(test_delimited("+123 ", lower[signed_int(123)], char_(' '))); + BOOST_TEST(test_delimited("-123 ", lower[signed_int(-123)], char_(' '))); + + BOOST_TEST(test(" 0", upper[signed_int(0)])); + BOOST_TEST(test("+123", upper[signed_int(123)])); + BOOST_TEST(test("-123", upper[signed_int(-123)])); + + BOOST_TEST(test_delimited(" 0 ", upper[signed_int(0)], char_(' '))); + BOOST_TEST(test_delimited("+123 ", upper[signed_int(123)], char_(' '))); + BOOST_TEST(test_delimited("-123 ", upper[signed_int(-123)], char_(' '))); + + using namespace boost::phoenix; + + BOOST_TEST(test(" 0", signed_int(val(0)))); + BOOST_TEST(test("+123", signed_int(val(123)))); + BOOST_TEST(test("-123", signed_int(val(-123)))); + + int i1 = 0, i2 = 123, i3 = -123; + BOOST_TEST(test(" 0", signed_int(ref(i1)))); + BOOST_TEST(test("+123", signed_int(ref(i2)))); + BOOST_TEST(test("-123", signed_int(ref(i3)))); + } + + { + /////////////////////////////////////////////////////////////////////// + using namespace boost::spirit::ascii; + + BOOST_TEST(test("1234", uint_, 1234)); + BOOST_TEST(test("ff", hex, 0xff)); + BOOST_TEST(test("1234", oct, 01234)); + BOOST_TEST(test("11110000", bin, 0xf0)); + + BOOST_TEST(test_delimited("1234 ", uint_, 1234, char_(' '))); + BOOST_TEST(test_delimited("ff ", hex, 0xff, char_(' '))); + BOOST_TEST(test_delimited("1234 ", oct, 01234, char_(' '))); + BOOST_TEST(test_delimited("11110000 ", bin, 0xf0, char_(' '))); + + // test unsigned generator with signed integral value + BOOST_TEST(test("ff", hex, (char)0xff)); + BOOST_TEST(test_delimited("ff ", hex, (char)0xff, char_(' '))); + + BOOST_TEST(test("1234", lower[uint_], 1234)); + BOOST_TEST(test("ff", lower[hex], 0xff)); + BOOST_TEST(test("1234", lower[oct], 01234)); + BOOST_TEST(test("11110000", lower[bin], 0xf0)); + + BOOST_TEST(test_delimited("1234 ", lower[uint_], 1234, char_(' '))); + BOOST_TEST(test_delimited("ff ", lower[hex], 0xff, char_(' '))); + BOOST_TEST(test_delimited("1234 ", lower[oct], 01234, char_(' '))); + BOOST_TEST(test_delimited("11110000 ", lower[bin], 0xf0, char_(' '))); + + BOOST_TEST(test("1234", upper[uint_], 1234)); + BOOST_TEST(test("FF", upper[hex], 0xff)); + BOOST_TEST(test("1234", upper[oct], 01234)); + BOOST_TEST(test("11110000", upper[bin], 0xf0)); + + BOOST_TEST(test_delimited("1234 ", upper[uint_], 1234, char_(' '))); + BOOST_TEST(test_delimited("FF ", upper[hex], 0xff, char_(' '))); + BOOST_TEST(test_delimited("1234 ", upper[oct], 01234, char_(' '))); + BOOST_TEST(test_delimited("11110000 ", upper[bin], 0xf0, char_(' '))); + + // no generator transformation should occur for uint_'s + BOOST_TEST(test("1234", upper[upper[uint_]], 1234)); + BOOST_TEST(test("1234", upper[lower[uint_]], 1234)); + BOOST_TEST(test("1234", lower[upper[uint_]], 1234)); + BOOST_TEST(test("1234", lower[lower[uint_]], 1234)); + + BOOST_TEST(test_delimited("1234 ", upper[upper[uint_]], 1234, char_(' '))); + BOOST_TEST(test_delimited("1234 ", upper[lower[uint_]], 1234, char_(' '))); + BOOST_TEST(test_delimited("1234 ", lower[upper[uint_]], 1234, char_(' '))); + BOOST_TEST(test_delimited("1234 ", lower[lower[uint_]], 1234, char_(' '))); + + BOOST_TEST(test("FF", upper[upper[hex]], 0xff)); + BOOST_TEST(test("FF", upper[lower[hex]], 0xff)); + BOOST_TEST(test("ff", lower[upper[hex]], 0xff)); + BOOST_TEST(test("ff", lower[lower[hex]], 0xff)); + + BOOST_TEST(test_delimited("FF ", upper[upper[hex]], 0xff, char_(' '))); + BOOST_TEST(test_delimited("FF ", upper[lower[hex]], 0xff, char_(' '))); + BOOST_TEST(test_delimited("ff ", lower[upper[hex]], 0xff, char_(' '))); + BOOST_TEST(test_delimited("ff ", lower[lower[hex]], 0xff, char_(' '))); + } + + /////////////////////////////////////////////////////////////////////////// + { + using boost::spirit::karma::int_; + using boost::spirit::karma::_1; + using boost::spirit::karma::_val; + using boost::spirit::karma::space; + + int i = 123; + int j = 456; + BOOST_TEST(test("123", int_[_1 = _val], i)); + BOOST_TEST(test_delimited("456 ", int_[_1 = _val], j, space)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/int3.cpp b/src/boost/libs/spirit/test/karma/int3.cpp new file mode 100644 index 00000000..47c5ad34 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/int3.cpp @@ -0,0 +1,126 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/lexical_cast.hpp> +#include <boost/mpl/vector.hpp> +#include <boost/mpl/for_each.hpp> +#include <boost/mpl/if.hpp> +#include <boost/mpl/bool.hpp> + +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/karma_phoenix_attributes.hpp> + +#include <boost/limits.hpp> +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +struct test_minmax +{ + template <typename T> + void operator()(T) const + { + using namespace boost::spirit; + using namespace boost::phoenix; + + T minval = (std::numeric_limits<T>::min)(); + T maxval = (std::numeric_limits<T>::max)(); + + std::string expected_minval = boost::lexical_cast<std::string>(minval); + std::string expected_maxval = boost::lexical_cast<std::string>(maxval); + + // create a correct generator type from the given integer type + typedef typename + boost::mpl::if_< + boost::mpl::bool_<std::numeric_limits<T>::is_signed>, + karma::int_generator<T>, + karma::uint_generator<T> + >::type + int_generator_type; + + int_generator_type const gen = int_generator_type(); + + BOOST_TEST(test(expected_maxval, gen, maxval)); + BOOST_TEST(test(expected_minval, gen, minval)); + BOOST_TEST(test(expected_maxval, gen(maxval))); + BOOST_TEST(test(expected_minval, gen(minval))); + BOOST_TEST(test(expected_maxval, gen(maxval), maxval)); + BOOST_TEST(test(expected_minval, gen(minval), minval)); + BOOST_TEST(!test("", gen(maxval), maxval-1)); + BOOST_TEST(!test("", gen(minval), minval+1)); + BOOST_TEST(test(expected_maxval, lit(maxval))); + BOOST_TEST(test(expected_minval, lit(minval))); + + BOOST_TEST(test_delimited(expected_maxval + " ", gen, maxval, char(' '))); + BOOST_TEST(test_delimited(expected_minval + " ", gen, minval, char(' '))); + BOOST_TEST(test_delimited(expected_maxval + " ", gen(maxval), char(' '))); + BOOST_TEST(test_delimited(expected_minval + " ", gen(minval), char(' '))); + BOOST_TEST(test_delimited(expected_maxval + " ", gen(maxval), maxval, char(' '))); + BOOST_TEST(test_delimited(expected_minval + " ", gen(minval), minval, char(' '))); + BOOST_TEST(!test_delimited("", gen(maxval), maxval-1, char(' '))); + BOOST_TEST(!test_delimited("", gen(minval), minval+1, char(' '))); + BOOST_TEST(test_delimited(expected_maxval + " ", lit(maxval), char(' '))); + BOOST_TEST(test_delimited(expected_minval + " ", lit(minval), char(' '))); + + // action tests + BOOST_TEST(test(expected_maxval, gen[_1 = val(maxval)])); + BOOST_TEST(test(expected_minval, gen[_1 = val(minval)])); + + // optional tests + boost::optional<T> optmin, optmax(maxval); + + BOOST_TEST(!test("", gen, optmin)); + BOOST_TEST(!test("", gen(minval), optmin)); + + optmin = minval; + BOOST_TEST(test(expected_minval, gen, optmin)); + BOOST_TEST(test(expected_maxval, gen, optmax)); + BOOST_TEST(test(expected_minval, gen(minval), optmin)); + BOOST_TEST(test(expected_maxval, gen(maxval), optmax)); + +// we support Phoenix attributes only starting with V2.2 +#if SPIRIT_VERSION >= 0x2020 + // Phoenix expression tests (only supported while including + // karma_phoenix_attributes.hpp + namespace phoenix = boost::phoenix; + + BOOST_TEST(test("1", gen, phoenix::val(1))); + + T val = 1; + BOOST_TEST(test("1", gen, phoenix::ref(val))); + BOOST_TEST(test("2", gen, ++phoenix::ref(val))); +#endif + } +}; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + +// test boundary values + typedef boost::mpl::vector< +#ifdef BOOST_HAS_LONG_LONG + boost::long_long_type, boost::ulong_long_type, +#endif + short, unsigned short, + int, unsigned int, + long, unsigned long + > integer_types; + boost::mpl::for_each<integer_types>(test_minmax()); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/kleene.cpp b/src/boost/libs/spirit/test/karma/kleene.cpp new file mode 100644 index 00000000..693c31e3 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/kleene.cpp @@ -0,0 +1,244 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/assign/std/vector.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_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/fusion/include/vector.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/fusion/include/std_pair.hpp> + +#include <boost/assign/std/vector.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +struct action +{ + action (std::vector<char>& vec) + : vec(vec), it(vec.begin()) + {} + + void operator()(unsigned& value, boost::spirit::unused_type, bool& pass) const + { + pass = (it != vec.end()); + if (pass) + value = *it++; + } + + std::vector<char>& vec; + mutable std::vector<char>::iterator it; +}; + +struct A +{ + double d1; + double d2; +}; + +BOOST_FUSION_ADAPT_STRUCT( + A, + (double, d1) + (double, d2) +) + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost::spirit; + using namespace boost::spirit::ascii; + namespace fusion = boost::fusion; + + { + std::string s1("aaaa"); + BOOST_TEST(test("aaaa", *char_, s1)); + BOOST_TEST(test_delimited("a a a a ", *char_, s1, ' ')); + + std::string s2(""); + BOOST_TEST(test("", *char_, s2)); + BOOST_TEST(test_delimited("", *char_, s2, ' ')); + } + + { + std::string s1("aaaaa"); + BOOST_TEST(test("aaaaa", char_ << *(char_ << char_), s1)); + BOOST_TEST(test_delimited("a a a a a ", + char_ << *(char_ << char_), s1, ' ')); + + s1 = "a"; + BOOST_TEST(test("a", char_ << *(char_ << char_), s1)); + s1 = "aa"; + BOOST_TEST(!test("", char_ << *(char_ << char_), s1)); +// BOOST_TEST(test("aa", char_ << *buffer[char_ << char_] << char_, s1)); + s1 = "aaaa"; + BOOST_TEST(!test("", char_ << *(char_ << char_), s1)); +// BOOST_TEST(test("aaaa", char_ << *buffer[char_ << char_] << char_, s1)); + } + + { + using boost::spirit::karma::strict; + using boost::spirit::karma::relaxed; + using namespace boost::assign; + + typedef std::pair<char, char> data; + std::vector<data> v1; + v1 += std::make_pair('a', 'a'), + std::make_pair('b', 'b'), + std::make_pair('c', 'c'), + std::make_pair('d', 'd'), + std::make_pair('e', 'e'), + std::make_pair('f', 'f'), + std::make_pair('g', 'g'); + + karma::rule<spirit_test::output_iterator<char>::type, data()> r; + r = &char_('a') << char_; + + BOOST_TEST(test("a", r << *(r << r), v1)); + BOOST_TEST(test("a", relaxed[r << *(r << r)], v1)); + BOOST_TEST(!test("", strict[r << *(r << r)], v1)); + + v1 += std::make_pair('a', 'a'); + + BOOST_TEST(!test("", r << *(r << r), v1)); + BOOST_TEST(!test("", relaxed[r << *(r << r)], v1)); + BOOST_TEST(!test("", strict[r << *(r << r)], v1)); + + v1 += std::make_pair('a', 'a'); + + BOOST_TEST(test("aaa", r << *(r << r), v1)); + BOOST_TEST(test("aaa", relaxed[r << *(r << r)], v1)); + BOOST_TEST(!test("", strict[r << *(r << r)], v1)); + } + + { + using namespace boost::assign; + + std::vector<char> v; + v += 'a', 'b', 'c'; + + BOOST_TEST(test("abc", *char_, v)); + BOOST_TEST(test_delimited("a b c ", *char_, v, ' ')); + } + + { + using namespace boost::assign; + + std::vector<int> v; + v += 10, 20, 30; + + BOOST_TEST(test("102030", *int_, v)); + BOOST_TEST(test_delimited("10, 20, 30, ", *int_, v, lit(", "))); + + BOOST_TEST(test("10,20,30,", *(int_ << ','), v)); + BOOST_TEST(test_delimited("10 , 20 , 30 , ", *(int_ << ','), v, lit(' '))); + +// leads to infinite loops +// fusion::vector<char, char> cc ('a', 'c'); +// BOOST_TEST(test("ac", char_ << *(lit(' ') << ',') << char_, cc)); +// BOOST_TEST(test_delimited("a c ", +// char_ << *(lit(' ') << ',') << char_, cc, " ")); + } + + { // actions + using namespace boost::assign; + namespace phx = boost::phoenix; + + std::vector<char> v; + v += 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'; + + BOOST_TEST(test("abcdefgh", (*char_)[_1 = phx::ref(v)])); + BOOST_TEST(test_delimited("a b c d e f g h ", + (*char_ )[_1 = phx::ref(v)], space)); + } + + // failing sub-generators + { + using boost::spirit::karma::strict; + using boost::spirit::karma::relaxed; + + using namespace boost::assign; + + typedef std::pair<char, char> data; + std::vector<data> v2; + v2 += std::make_pair('a', 'a'), + std::make_pair('b', 'b'), + std::make_pair('c', 'c'), + std::make_pair('d', 'd'), + std::make_pair('e', 'e'), + std::make_pair('f', 'f'), + std::make_pair('g', 'g'); + + karma::rule<spirit_test::output_iterator<char>::type, data()> r; + + r = &char_('d') << char_; + BOOST_TEST(test("d", *r, v2)); + BOOST_TEST(test("d", relaxed[*r], v2)); + BOOST_TEST(test("", strict[*r], v2)); + + r = &char_('a') << char_; + BOOST_TEST(test("a", *r, v2)); + BOOST_TEST(test("a", relaxed[*r], v2)); + BOOST_TEST(test("a", strict[*r], v2)); + + r = &char_('g') << char_; + BOOST_TEST(test("g", *r, v2)); + BOOST_TEST(test("g", relaxed[*r], v2)); + BOOST_TEST(test("", strict[*r], v2)); + + r = !char_('d') << char_; + BOOST_TEST(test("abcefg", *r, v2)); + BOOST_TEST(test("abcefg", relaxed[*r], v2)); + BOOST_TEST(test("abc", strict[*r], v2)); + + r = !char_('a') << char_; + BOOST_TEST(test("bcdefg", *r, v2)); + BOOST_TEST(test("bcdefg", relaxed[*r], v2)); + BOOST_TEST(test("", strict[*r], v2)); + + r = !char_('g') << char_; + BOOST_TEST(test("abcdef", *r, v2)); + BOOST_TEST(test("abcdef", relaxed[*r], v2)); + BOOST_TEST(test("abcdef", strict[*r], v2)); + + r = &char_('A') << char_; + BOOST_TEST(test("", *r, v2)); + } + + { + // make sure user defined end condition is applied if no attribute + // is passed in + using namespace boost::assign; + + std::vector<char> v; + v += 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'; + BOOST_TEST(test("[6162636465666768]", '[' << *hex[action(v)] << ']')); + } + + { + using boost::spirit::karma::double_; + + std::vector<A> v(1); + v[0].d1 = 1.0; + v[0].d2 = 2.0; + BOOST_TEST(test("A1.02.0", 'A' << *(double_ << double_), v)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/lazy.cpp b/src/boost/libs/spirit/test/karma/lazy.cpp new file mode 100644 index 00000000..86476f01 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/lazy.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2001-2011 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) + +#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_auxiliary.hpp> +#include <boost/spirit/include/karma_action.hpp> +// #include <boost/spirit/include/karma_nonterminal.hpp> +// #include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/support_argument.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include <iostream> +#include "test.hpp" + +int +main() +{ + namespace karma = boost::spirit::karma; + using spirit_test::test; + using namespace boost::spirit; + using namespace boost::spirit::karma; + namespace phx = boost::phoenix; + + { + BOOST_TEST(test("123", karma::lazy(phx::val(int_)), 123)); + } + + { + int result = 123; + BOOST_TEST(test("123", karma::lazy(phx::val(int_))[_1 = phx::ref(result)])); + } + +// { +// typedef spirit_test::output_iterator<char>::type outiter_type; +// rule<outiter_type, void(std::string)> r; +// +// r = char_('<') << karma::lazy(_r1) << '>' << "</" << karma::lazy(_r1) << '>'; +// +// std::string tag("tag"), foo("foo"); +// BOOST_TEST(test("<tag></tag>", r (phx::ref(tag)))); +// BOOST_TEST(!test("<foo></bar>", r (phx::ref(foo)))); +// } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/left_alignment.cpp b/src/boost/libs/spirit/test/karma/left_alignment.cpp new file mode 100644 index 00000000..5b189883 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/left_alignment.cpp @@ -0,0 +1,74 @@ +// Copyright (c) 2001-2011 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) + +#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_directive.hpp> +#include <boost/spirit/include/karma_upper_lower_case.hpp> + +#include "test.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace spirit_test; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + BOOST_TEST(test("x ", left_align[char_('x')])); + BOOST_TEST(test("x ", left_align[char_], 'x')); + BOOST_TEST(test("x ", left_align['x'])); + + BOOST_TEST(test("x ", left_align(10)[char_('x')])); + BOOST_TEST(test("x ", left_align(10)[char_], 'x')); + BOOST_TEST(test("x ", left_align(10)['x'])); + + BOOST_TEST(test("x*********", left_align(10, char_('*'))[char_('x')])); + BOOST_TEST(test("x*********", left_align(10, '*')[char_], 'x')); + BOOST_TEST(test("x*********", left_align(10, '*')['x'])); + BOOST_TEST(test("xaaaaaaaaa", lower[left_align(10, 'A')['X']])); + BOOST_TEST(test("XAAAAAAAAA", upper[left_align(10, 'a')['x']])); + + BOOST_TEST(test("x*********", left_align(char_('*'))[char_('x')])); + BOOST_TEST(test("x*********", left_align(char_('*'))[char_], 'x')); + BOOST_TEST(test("x*********", left_align(char_('*'))['x'])); + + BOOST_TEST(test("abc ", left_align[lit("abc")])); + BOOST_TEST(test("abc ", left_align[string], "abc")); + + BOOST_TEST(test("abc ", left_align(10)[lit("abc")])); + BOOST_TEST(test("abc ", left_align(10)[string], "abc")); + BOOST_TEST(test("abc ", left_align(10)["abc"])); + + BOOST_TEST(test("abc*******", left_align(10, char_('*'))[lit("abc")])); + BOOST_TEST(test("abc*******", left_align(10, '*')[string], "abc")); + BOOST_TEST(test("abc*******", left_align(10, '*')["abc"])); + + BOOST_TEST(test("abc*******", left_align(char_('*'))[lit("abc")])); + BOOST_TEST(test("abc*******", left_align(char_('*'))[string], "abc")); + BOOST_TEST(test("abc*******", left_align(char_('*'))["abc"])); + + BOOST_TEST(test("100 ", left_align[int_(100)])); + BOOST_TEST(test("100 ", left_align[int_], 100)); + + BOOST_TEST(test("100 ", left_align(10)[int_(100)])); + BOOST_TEST(test("100 ", left_align(10)[int_], 100)); + + BOOST_TEST(test("100*******", left_align(10, char_('*'))[int_(100)])); + BOOST_TEST(test("100*******", left_align(10, '*')[int_], 100)); + + BOOST_TEST(test("100*******", left_align(char_('*'))[int_(100)])); + BOOST_TEST(test("100*******", left_align(char_('*'))[int_], 100)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/list.cpp b/src/boost/libs/spirit/test/karma/list.cpp new file mode 100644 index 00000000..686b0ab4 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/list.cpp @@ -0,0 +1,151 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/mpl/print.hpp> + +#include <boost/spirit/include/karma_operator.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_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/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/fusion/include/std_pair.hpp> + +#include <boost/assign/std/vector.hpp> + +#include <string> +#include <vector> +#include <iostream> + +#include "test.hpp" + +using namespace spirit_test; +using boost::spirit::unused_type; + +/////////////////////////////////////////////////////////////////////////////// +struct action +{ + action (std::vector<char>& vec) + : vec(vec), it(vec.begin()) + {} + + void operator()(unsigned& value, unused_type const&, bool& pass) const + { + pass = (it != vec.end()); + if (pass) + value = *it++; + } + + std::vector<char>& vec; + mutable std::vector<char>::iterator it; +}; + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + using namespace boost::assign; + + std::vector<char> v; + v += 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'; + + { + BOOST_TEST(test("a,b,c,d,e,f,g,h", char_ % ',', v)); + BOOST_TEST(test_delimited("a , b , c , d , e , f , g , h ", + char_ % ',', v, space)); + } + + { + std::string s ("abcdefgh"); + BOOST_TEST(test("a,b,c,d,e,f,g,h", char_ % ',', s)); + BOOST_TEST(test_delimited("a , b , c , d , e , f , g , h ", + char_ % ',', s, space)); + } + + { + std::string s ("abcdefg"); + BOOST_TEST(test("abc,de,fg", char_ << ((char_ << char_) % ','), s)); + BOOST_TEST(test_delimited("a b c , d e , f g ", + char_ << ((char_ << char_) % ','), s, space)); + } + + { // actions + namespace phx = boost::phoenix; + + BOOST_TEST(test("a,b,c,d,e,f,g,h", (char_ % ',')[_1 = phx::ref(v)])); + BOOST_TEST(test_delimited("a , b , c , d , e , f , g , h ", + (char_ % ',')[_1 = phx::ref(v)], space)); + } + + // failing sub-generators + { + using boost::spirit::karma::strict; + using boost::spirit::karma::relaxed; + + typedef std::pair<char, char> data; + std::vector<data> v2; + v2 += std::make_pair('a', 'a'), + std::make_pair('b', 'b'), + std::make_pair('c', 'c'), + std::make_pair('d', 'd'), + std::make_pair('e', 'e'), + std::make_pair('f', 'f'), + std::make_pair('g', 'g'); + + karma::rule<spirit_test::output_iterator<char>::type, data()> r; + + r = &char_('d') << char_; + BOOST_TEST(test("d", r % ',', v2)); + BOOST_TEST(test("d", relaxed[r % ','], v2)); + BOOST_TEST(!test("", strict[r % ','], v2)); + + r = &char_('a') << char_; + BOOST_TEST(test("a", r % ',', v2)); + BOOST_TEST(test("a", relaxed[r % ','], v2)); + BOOST_TEST(test("a", strict[r % ','], v2)); + + r = &char_('g') << char_; + BOOST_TEST(test("g", r % ',', v2)); + BOOST_TEST(test("g", relaxed[r % ','], v2)); + BOOST_TEST(!test("", strict[r % ','], v2)); + + r = !char_('d') << char_; + BOOST_TEST(test("a,b,c,e,f,g", r % ',', v2)); + BOOST_TEST(test("a,b,c,e,f,g", relaxed[r % ','], v2)); + BOOST_TEST(test("a,b,c", strict[r % ','], v2)); + + r = !char_('a') << char_; + BOOST_TEST(test("b,c,d,e,f,g", r % ',', v2)); + BOOST_TEST(test("b,c,d,e,f,g", relaxed[r % ','], v2)); + BOOST_TEST(!test("", strict[r % ','], v2)); + + r = !char_('g') << char_; + BOOST_TEST(test("a,b,c,d,e,f", r % ',', v2)); + BOOST_TEST(test("a,b,c,d,e,f", relaxed[r % ','], v2)); + BOOST_TEST(test("a,b,c,d,e,f", strict[r % ','], v2)); + + r = &char_('A') << char_; + BOOST_TEST(!test("", r % ',', v2)); + } + + { + // make sure user defined end condition is applied if no attribute + // is passed in + BOOST_TEST(test("[61,62,63,64,65,66,67,68]", + '[' << hex[action(v)] % ',' << ']')); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/lit.cpp b/src/boost/libs/spirit/test/karma/lit.cpp new file mode 100644 index 00000000..9eb4d4f0 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/lit.cpp @@ -0,0 +1,194 @@ +// Copyright (c) 2001-2011 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) + +#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_generate.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/support_argument.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test("a", lit('a'))); + BOOST_TEST(!test("a", lit('b'))); + + BOOST_TEST(test("abc", "abc")); + BOOST_TEST(!test("abcd", "abc")); + + BOOST_TEST(test("abc", lit("abc"))); + BOOST_TEST(!test("abcd", lit("abc"))); + + BOOST_TEST(test("abc", string, "abc")); + BOOST_TEST(!test("abcd", string, "abc")); + + BOOST_TEST(test("abc", string("abc"))); + BOOST_TEST(!test("abcd", string("abc"))); + + BOOST_TEST(test("abc", string("abc"), "abc")); + BOOST_TEST(!test("", string("abc"), "abcd")); + BOOST_TEST(!test("", string("abcd"), "abc")); + BOOST_TEST(!test("", string("abc"), "abcd")); // don't match prefixes only + } + + { + using namespace boost::spirit::ascii; + + std::string str("abc"); + BOOST_TEST(test("abc", lit(str))); + BOOST_TEST(!test("abcd", lit(str))); + + BOOST_TEST(test("abc", string(str))); + BOOST_TEST(!test("abcd", string(str))); + + BOOST_TEST(test("abc", string, str)); + BOOST_TEST(!test("abcd", string, str)); + + BOOST_TEST(test("abc", str)); + BOOST_TEST(!test("abcd", str)); + } + + { + using namespace boost::spirit::standard_wide; + + std::basic_string<wchar_t> wstr(L"abc"); + BOOST_TEST(test(L"abc", lit(wstr))); + BOOST_TEST(!test(L"abcd", lit(wstr))); + + BOOST_TEST(test(L"abc", string, wstr)); + BOOST_TEST(!test(L"abcd", string, wstr)); + + BOOST_TEST(test(L"abc", wstr)); + BOOST_TEST(!test(L"abcd", wstr)); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test(L"a", lit(L'a'))); + BOOST_TEST(!test(L"a", lit(L'b'))); + + BOOST_TEST(test(L"abc", L"abc")); + BOOST_TEST(test(L"abc", "abc")); + BOOST_TEST(!test(L"abcd", L"abc")); + + BOOST_TEST(test(L"abc", lit(L"abc"))); + BOOST_TEST(!test(L"abcd", lit(L"abc"))); + + BOOST_TEST(test(L"abc", string(L"abc"))); + BOOST_TEST(!test(L"abcd", string(L"abc"))); + + BOOST_TEST(test(L"abc", string, L"abc")); + BOOST_TEST(!test(L"abcd", string, L"abc")); + + BOOST_TEST(test(L"abc", string, "abc")); + BOOST_TEST(!test(L"abcd", string, "abc")); + } + + { + using namespace boost::spirit::karma; + + const char test_data[] = "abc\x00s"; + const std::string str(test_data, sizeof(test_data) - 1); + + BOOST_TEST(test(str, lit(str))); + BOOST_TEST(!test("abc", lit(str))); + + BOOST_TEST(test(str, string(str))); + BOOST_TEST(!test("abc", string(str))); + + BOOST_TEST(test(str, string, str)); + BOOST_TEST(!test("abc", string, str)); + + BOOST_TEST(test(str, str)); + BOOST_TEST(!test("abc", str)); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test_delimited("a ", lit('a'), ' ')); + BOOST_TEST(!test_delimited("a ", lit('b'), ' ')); + + BOOST_TEST(test_delimited("abc ", "abc", ' ')); + BOOST_TEST(!test_delimited("abcd ", "abc", ' ')); + + BOOST_TEST(test_delimited("abc ", lit("abc"), ' ')); + BOOST_TEST(!test_delimited("abcd ", lit("abc"), ' ')); + + BOOST_TEST(test_delimited("abc ", string, "abc", ' ')); + BOOST_TEST(!test_delimited("abcd ", string, "abc", ' ')); + + BOOST_TEST(test_delimited("abc ", string("abc"), ' ')); + BOOST_TEST(!test_delimited("abcd ", string("abc"), ' ')); + + BOOST_TEST(test_delimited("abc ", string("abc"), "abc", ' ')); + BOOST_TEST(!test_delimited("", string("abc"), "abcd", ' ')); + BOOST_TEST(!test_delimited("", string("abcd"), "abc", ' ')); + BOOST_TEST(!test_delimited("", string("abc"), "abcd", ' ')); // don't match prefixes only + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test_delimited(L"a ", lit(L'a'), ' ')); + BOOST_TEST(!test_delimited(L"a ", lit(L'b'), ' ')); + + BOOST_TEST(test_delimited(L"abc ", L"abc", ' ')); + BOOST_TEST(!test_delimited(L"abcd ", L"abc", ' ')); + + BOOST_TEST(test_delimited(L"abc ", lit(L"abc"), ' ')); + BOOST_TEST(!test_delimited(L"abcd ", lit(L"abc"), ' ')); + + BOOST_TEST(test_delimited(L"abc ", string, L"abc", ' ')); + BOOST_TEST(!test_delimited(L"abcd ", string, L"abc", ' ')); + + BOOST_TEST(test_delimited(L"abc ", string(L"abc"), ' ')); + BOOST_TEST(!test_delimited(L"abcd ", string(L"abc"), ' ')); + } + + { // test action + namespace phx = boost::phoenix; + using namespace boost::spirit::ascii; + + std::string str("abc"); + BOOST_TEST(test("abc", string[_1 = phx::ref(str)])); + BOOST_TEST(test_delimited("abc ", string[_1 = phx::ref(str)], space)); + } + + { // lazy strings + namespace phx = boost::phoenix; + using namespace boost::spirit::ascii; + + std::basic_string<char> s("abc"); + BOOST_TEST((test("abc", lit(phx::val(s))))); + BOOST_TEST((test("abc", string(phx::val(s))))); + + BOOST_TEST(test("abc", string(phx::val(s)), "abc")); + BOOST_TEST(!test("", string(phx::val(s)), "abcd")); + BOOST_TEST(!test("", string(phx::val(s)), "abc")); + + std::basic_string<wchar_t> ws(L"abc"); + BOOST_TEST((test(L"abc", lit(phx::ref(ws))))); + BOOST_TEST((test(L"abc", string(phx::ref(ws))))); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/maxwidth.cpp b/src/boost/libs/spirit/test/karma/maxwidth.cpp new file mode 100644 index 00000000..75066a11 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/maxwidth.cpp @@ -0,0 +1,77 @@ +// Copyright (c) 2001-2011 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) + +#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_directive.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + BOOST_TEST(test("0123456789", maxwidth[lit("0123456789")])); + BOOST_TEST(test("012345678", maxwidth[lit("012345678")])); + BOOST_TEST(test("0123456789", maxwidth[lit("01234567890")])); + + BOOST_TEST(test("0123456789", maxwidth[string], "0123456789")); + BOOST_TEST(test("012345678", maxwidth[string], "012345678")); + BOOST_TEST(test("0123456789", maxwidth[string], "01234567890")); + } + + { + BOOST_TEST(test("01234567", maxwidth(8)[lit("01234567")])); + BOOST_TEST(test("0123456", maxwidth(8)[lit("0123456")])); + BOOST_TEST(test("01234567", maxwidth(8)[lit("012345678")])); + + BOOST_TEST(test("01234567", maxwidth(8)[string], "01234567")); + BOOST_TEST(test("0123456", maxwidth(8)[string], "0123456")); + BOOST_TEST(test("01234567", maxwidth(8)[string], "012345678")); + } + + { + std::string str; + BOOST_TEST(test("01234567", + maxwidth(8, std::back_inserter(str))[lit("01234567")]) && + str.empty()); + + str = ""; + BOOST_TEST(test("0123456", + maxwidth(8, std::back_inserter(str))[lit("0123456")]) && + str.empty()); + + str = ""; + BOOST_TEST(test("01234567", + maxwidth(8, std::back_inserter(str))[lit("012345678")]) && + str == "8"); + } + + { + using namespace boost::phoenix; + + BOOST_TEST(test("01234567", maxwidth(val(8))[lit("01234567")])); + BOOST_TEST(test("0123456", maxwidth(val(8))[lit("0123456")])); + BOOST_TEST(test("01234567", maxwidth(val(8))[lit("012345678")])); + + int w = 8; + BOOST_TEST(test("01234567", maxwidth(ref(w))[string], "01234567")); + BOOST_TEST(test("0123456", maxwidth(ref(w))[string], "0123456")); + BOOST_TEST(test("01234567", maxwidth(ref(w))[string], "012345678")); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/not_predicate.cpp b/src/boost/libs/spirit/test/karma/not_predicate.cpp new file mode 100644 index 00000000..6b4abeb9 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/not_predicate.cpp @@ -0,0 +1,36 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_string.hpp> + +#include <iostream> +#include "test.hpp" + +int +main() +{ + using namespace spirit_test; + using namespace boost::spirit; + + { + using boost::spirit::ascii::char_; + using boost::spirit::ascii::string; + + BOOST_TEST(test("c", !char_('a') << 'b' | 'c', 'a')); + BOOST_TEST(test("b", !char_('a') << 'b' | 'c', 'x')); + + BOOST_TEST(test("def", !string("123") << "abc" | "def", "123")); + BOOST_TEST(test("abc", !string("123") << "abc" | "def", "456")); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/omit.cpp b/src/boost/libs/spirit/test/karma/omit.cpp new file mode 100644 index 00000000..9a349697 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/omit.cpp @@ -0,0 +1,79 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma.hpp> +#include <boost/fusion/include/std_pair.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include <iostream> +#include "test.hpp" + +using namespace spirit_test; + +int main() +{ + using boost::spirit::karma::_1; + using boost::spirit::karma::_a; + using boost::spirit::karma::double_; + using boost::spirit::karma::int_; + using boost::spirit::karma::omit; + using boost::spirit::karma::skip; + using boost::spirit::karma::rule; + using boost::spirit::karma::locals; + + typedef spirit_test::output_iterator<char>::type outiter_type; + typedef std::pair<std::vector<int>, int> attribute_type; + + rule<outiter_type, attribute_type(), locals<int> > r; + + attribute_type a; + a.first.push_back(0x01); + a.first.push_back(0x02); + a.first.push_back(0x04); + a.first.push_back(0x08); + a.second = 0; + + // omit[] is supposed to execute the embedded generator + { + std::pair<double, double> p (1.0, 2.0); + BOOST_TEST(test("2.0", omit[double_] << double_, p)); + + r %= omit[ *(int_[_a = _a + _1]) ] << int_[_1 = _a]; + BOOST_TEST(test("15", r, a)); + } + + // even if omit[] never fails, it has to honor the result of the + // embedded generator + { + typedef std::pair<double, double> attribute_type; + rule<outiter_type, attribute_type()> r; + + r %= omit[double_(1.0) << double_] | "42"; + + attribute_type p1 (1.0, 2.0); + BOOST_TEST(test("", r, p1)); + + attribute_type p2 (10.0, 2.0); + BOOST_TEST(test("42", r, p2)); + } + + // skip[] is not supposed to execute the embedded generator + { + using boost::spirit::karma::double_; + using boost::spirit::karma::skip; + + std::pair<double, double> p (1.0, 2.0); + BOOST_TEST(test("2.0", skip[double_] << double_, p)); + + r %= skip[ *(int_[_a = _a + _1]) ] << int_[_1 = _a]; + BOOST_TEST(test("0", r, a)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/optional.cpp b/src/boost/libs/spirit/test/karma/optional.cpp new file mode 100644 index 00000000..3369c1e6 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/optional.cpp @@ -0,0 +1,90 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include <iostream> +#include "test.hpp" + +int main() +{ + using namespace spirit_test; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + boost::optional<int> opt; + BOOST_TEST(test("", -int_, opt)); + + opt = 10; + BOOST_TEST(test("10", -int_, opt)); + } + + { + int opt = 10; + BOOST_TEST(test("10", -int_, opt)); + } + + { + boost::optional<int> opt; + BOOST_TEST(test_delimited("", -int_, opt, space)); + + opt = 10; + BOOST_TEST(test_delimited("10 ", -int_, opt, space)); + } + + { + int opt = 10; + BOOST_TEST(test_delimited("10 ", -int_, opt, space)); + } + + { // test action + using namespace boost::phoenix; + namespace phoenix = boost::phoenix; + + boost::optional<int> n ; + BOOST_TEST(test("", (-int_)[_1 = phoenix::ref(n)])); + + n = 1234; + BOOST_TEST(test("1234", (-int_)[_1 = phoenix::ref(n)])); + } + + { // test action + using namespace boost::phoenix; + namespace phoenix = boost::phoenix; + + int n = 1234; + BOOST_TEST(test("1234", (-int_)[_1 = phoenix::ref(n)])); + } + + { // test action + using namespace boost::phoenix; + namespace phoenix = boost::phoenix; + + boost::optional<int> n; + BOOST_TEST(test_delimited("", (-int_)[_1 = phoenix::ref(n)], space)); + + n = 1234; + BOOST_TEST(test_delimited("1234 ", (-int_)[_1 = phoenix::ref(n)], space)); + } + + { // test action + using namespace boost::phoenix; + namespace phoenix = boost::phoenix; + + int n = 1234; + BOOST_TEST(test_delimited("1234 ", (-int_)[_1 = phoenix::ref(n)], space)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/pattern1.cpp b/src/boost/libs/spirit/test/karma/pattern1.cpp new file mode 100644 index 00000000..9892bb05 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/pattern1.cpp @@ -0,0 +1,112 @@ +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/spirit/include/phoenix_fusion.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + typedef spirit_test::output_iterator<char>::type outiter_type; + + // test rule parameter propagation + { + using boost::phoenix::at_c; + + karma::rule<outiter_type, fusion::vector<char, int, double>()> start; + fusion::vector<char, int, double> vec('a', 10, 12.4); + + start %= char_ << int_ << double_; + BOOST_TEST(test("a1012.4", start, vec)); + + karma::rule<outiter_type, char()> a; + karma::rule<outiter_type, int()> b; + karma::rule<outiter_type, double()> c; + + a %= char_ << eps; + b %= int_; + c %= double_; + start = a[_1 = at_c<0>(_r0)] << b[_1 = at_c<1>(_r0)] << c[_1 = at_c<2>(_r0)]; + BOOST_TEST(test("a1012.4", start, vec)); + + start = (a << b << c)[_1 = at_c<0>(_r0), _2 = at_c<1>(_r0), _3 = at_c<2>(_r0)]; + BOOST_TEST(test("a1012.4", start, vec)); + + start = a << b << c; + BOOST_TEST(test("a1012.4", start, vec)); + + start %= a << b << c; + BOOST_TEST(test("a1012.4", start, vec)); + } + + { + using boost::phoenix::at_c; + + karma::rule<outiter_type, space_type, fusion::vector<char, int, double>()> start; + fusion::vector<char, int, double> vec('a', 10, 12.4); + + start %= char_ << int_ << double_; + BOOST_TEST(test_delimited("a 10 12.4 ", start, vec, space)); + + karma::rule<outiter_type, space_type, char()> a; + karma::rule<outiter_type, space_type, int()> b; + karma::rule<outiter_type, space_type, double()> c; + + a %= char_ << eps; + b %= int_; + c %= double_; + start = a[_1 = at_c<0>(_r0)] << b[_1 = at_c<1>(_r0)] << c[_1 = at_c<2>(_r0)]; + BOOST_TEST(test_delimited("a 10 12.4 ", start, vec, space)); + + start = (a << b << c)[_1 = at_c<0>(_r0), _2 = at_c<1>(_r0), _3 = at_c<2>(_r0)]; + BOOST_TEST(test_delimited("a 10 12.4 ", start, vec, space)); + + start = a << b << c; + BOOST_TEST(test_delimited("a 10 12.4 ", start, vec, space)); + + start %= a << b << c; + BOOST_TEST(test_delimited("a 10 12.4 ", start, vec, space)); + } + + // test direct initalization + { + using boost::phoenix::at_c; + + fusion::vector<char, int, double> vec('a', 10, 12.4); + karma::rule<outiter_type, space_type, fusion::vector<char, int, double>()> + start = char_ << int_ << double_;; + + BOOST_TEST(test_delimited("a 10 12.4 ", start, vec, space)); + + karma::rule<outiter_type, space_type, char()> a = char_ << eps; + karma::rule<outiter_type, space_type, int()> b = int_; + karma::rule<outiter_type, space_type, double()> c = double_; + + start = a[_1 = at_c<0>(_r0)] << b[_1 = at_c<1>(_r0)] << c[_1 = at_c<2>(_r0)]; + BOOST_TEST(test_delimited("a 10 12.4 ", start, vec, space)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/pattern2.cpp b/src/boost/libs/spirit/test/karma/pattern2.cpp new file mode 100644 index 00000000..4621065e --- /dev/null +++ b/src/boost/libs/spirit/test/karma/pattern2.cpp @@ -0,0 +1,153 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + typedef spirit_test::output_iterator<char>::type outiter_type; + + // locals test + { + karma::rule<outiter_type, locals<std::string> > start; + + start = string[_1 = "abc", _a = _1] << int_[_1 = 10] << string[_1 = _a]; + BOOST_TEST(test("abc10abc", start)); + } + + { + karma::rule<outiter_type, space_type, locals<std::string> > start; + + start = string[_1 = "abc", _a = _1] << int_[_1 = 10] << string[_1 = _a]; + BOOST_TEST(test_delimited("abc 10 abc ", start, space)); + } + + // alias tests + { + typedef variant<char, int, double> var_type; + + karma::rule<outiter_type, var_type()> d, start; + + d = start.alias(); // d will always track start + + start = (char_ | int_ | double_)[_1 = _val]; + + var_type v ('a'); + BOOST_TEST(test("a", d, v)); + v = 10; + BOOST_TEST(test("10", d, v)); + v = 12.4; + BOOST_TEST(test("12.4", d, v)); + } + + { + typedef variant<char, int, double> var_type; + + karma::rule<outiter_type, space_type, var_type()> d, start; + + d = start.alias(); // d will always track start + + start = (char_ | int_ | double_)[_1 = _val]; + + var_type v ('a'); + BOOST_TEST(test_delimited("a ", d, v, space)); + v = 10; + BOOST_TEST(test_delimited("10 ", d, v, space)); + v = 12.4; + BOOST_TEST(test_delimited("12.4 ", d, v, space)); + } + + { + typedef variant<char, int, double> var_type; + + karma::rule<outiter_type, var_type()> d, start; + + d = start.alias(); // d will always track start + + start %= char_ | int_ | double_; + + var_type v ('a'); + BOOST_TEST(test("a", d, v)); + v = 10; + BOOST_TEST(test("10", d, v)); + v = 12.4; + BOOST_TEST(test("12.4", d, v)); + + start = char_ | int_ | double_; + + v = 'a'; + BOOST_TEST(test("a", d, v)); + v = 10; + BOOST_TEST(test("10", d, v)); + v = 12.4; + BOOST_TEST(test("12.4", d, v)); + } + + { + typedef variant<char, int, double> var_type; + + karma::rule<outiter_type, space_type, var_type()> d, start; + + d = start.alias(); // d will always track start + + start %= char_ | int_ | double_; + + var_type v ('a'); + BOOST_TEST(test_delimited("a ", d, v, space)); + v = 10; + BOOST_TEST(test_delimited("10 ", d, v, space)); + v = 12.4; + BOOST_TEST(test_delimited("12.4 ", d, v, space)); + + start = char_ | int_ | double_; + + v = 'a'; + BOOST_TEST(test_delimited("a ", d, v, space)); + v = 10; + BOOST_TEST(test_delimited("10 ", d, v, space)); + v = 12.4; + BOOST_TEST(test_delimited("12.4 ", d, v, space)); + } + + /////////////////////////////////////////////////////////////////////////// + { + using boost::spirit::karma::int_; + using boost::spirit::karma::_1; + using boost::spirit::karma::_val; + using boost::spirit::karma::space; + using boost::spirit::karma::space_type; + + karma::rule<outiter_type, int()> r1 = int_; + karma::rule<outiter_type, space_type, int()> r2 = int_; + + int i = 123; + int j = 456; + BOOST_TEST(test("123", r1[_1 = _val], i)); + BOOST_TEST(test_delimited("456 ", r2[_1 = _val], j, space)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/pattern3.cpp b/src/boost/libs/spirit/test/karma/pattern3.cpp new file mode 100644 index 00000000..f5ff2bc0 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/pattern3.cpp @@ -0,0 +1,120 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + typedef spirit_test::output_iterator<char>::type outiter_type; + + // basic tests + { + karma::rule<outiter_type> start; + + start = char_[_1 = 'a'] << int_[_1 = 10] << double_[_1 = 12.4]; + BOOST_TEST(test("a1012.4", start)); + + start = (char_ << int_ << double_)[_1 = 'a', _2 = 10, _3 = 12.4]; + BOOST_TEST(test("a1012.4", start)); + + karma::rule<outiter_type> a, b, c; + a = char_[_1 = 'a']; + b = int_[_1 = 10]; + c = double_[_1 = 12.4]; + + start = a << b << c; + BOOST_TEST(test("a1012.4", start)); + } + + // basic tests with delimiter + { + karma::rule<outiter_type, space_type> start; + + start = char_[_1 = 'a'] << int_[_1 = 10] << double_[_1 = 12.4]; + BOOST_TEST(test_delimited("a 10 12.4 ", start, space)); + + start = (char_ << int_ << double_)[_1 = 'a', _2 = 10, _3 = 12.4]; + BOOST_TEST(test_delimited("a 10 12.4 ", start, space)); + + karma::rule<outiter_type, space_type> a, b, c; + a = char_[_1 = 'a']; + b = int_[_1 = 10]; + c = double_[_1 = 12.4]; + + start = a << b << c; + BOOST_TEST(test_delimited("a 10 12.4 ", start, space)); + } + + // basic tests involving a direct parameter + { + typedef variant<char, int, double> var_type; + + karma::rule<outiter_type, var_type()> start; + + start = (char_ | int_ | double_)[_1 = _r0]; + + var_type v ('a'); + BOOST_TEST(test("a", start, v)); + v = 10; + BOOST_TEST(test("10", start, v)); + v = 12.4; + BOOST_TEST(test("12.4", start, v)); + } + + { + typedef variant<char, int, double> var_type; + + karma::rule<outiter_type, space_type, var_type()> start; + + start = (char_ | int_ | double_)[_1 = _r0]; + + var_type v ('a'); + BOOST_TEST(test_delimited("a ", start, v, space)); + v = 10; + BOOST_TEST(test_delimited("10 ", start, v, space)); + v = 12.4; + BOOST_TEST(test_delimited("12.4 ", start, v, space)); + } + + // test handling of single element fusion sequences + { + using boost::fusion::vector; + karma::rule<outiter_type, vector<int>()> r = int_; + + vector<int> v(1); + BOOST_TEST(test("1", r, v)); + } + + { + using boost::fusion::vector; + karma::rule<outiter_type, space_type, vector<int>()> r = int_; + + vector<int> v(1); + BOOST_TEST(test_delimited("1 ", r, v, space)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/pattern4.cpp b/src/boost/libs/spirit/test/karma/pattern4.cpp new file mode 100644 index 00000000..b67939c6 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/pattern4.cpp @@ -0,0 +1,141 @@ +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_action.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + typedef spirit_test::output_iterator<char>::type outiter_type; + + { + karma::rule<outiter_type, void(char, int, double)> start; + fusion::vector<char, int, double> vec('a', 10, 12.4); + + start = char_[_1 = _r1] << int_[_1 = _r2] << double_[_1 = _r3]; + BOOST_TEST(test("a1012.4", start('a', 10, 12.4))); + + start = (char_ << int_ << double_)[_1 = _r1, _2 = _r2, _3 = _r3]; + BOOST_TEST(test("a1012.4", start('a', 10, 12.4))); + + karma::rule<outiter_type, void(char)> a; + karma::rule<outiter_type, void(int)> b; + karma::rule<outiter_type, void(double)> c; + + a = char_[_1 = _r1]; + b = int_[_1 = _r1]; + c = double_[_1 = _r1]; + start = a(_r1) << b(_r2) << c(_r3); + BOOST_TEST(test("a1012.4", start('a', 10, 12.4))); + } + + { + karma::rule<outiter_type, space_type, void(char, int, double)> start; + fusion::vector<char, int, double> vec('a', 10, 12.4); + + start = char_[_1 = _r1] << int_[_1 = _r2] << double_[_1 = _r3]; + BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space)); + + start = (char_ << int_ << double_)[_1 = _r1, _2 = _r2, _3 = _r3]; + BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space)); + + karma::rule<outiter_type, space_type, void(char)> a; + karma::rule<outiter_type, space_type, void(int)> b; + karma::rule<outiter_type, space_type, void(double)> c; + + a = char_[_1 = _r1]; + b = int_[_1 = _r1]; + c = double_[_1 = _r1]; + start = a(_r1) << b(_r2) << c(_r3); + BOOST_TEST(test_delimited("a 10 12.4 ", start('a', 10, 12.4), space)); + } + + // copy tests + { + karma::rule<outiter_type> a, b, c, start; + + a = 'a'; + b = int_(10); + c = double_(12.4); + + // The FF is the dynamic equivalent of start = a << b << c; + start = a; + start = start.copy() << b; + start = start.copy() << c; + start = start.copy(); + + BOOST_TEST(test("a1012.4", start)); + } + + { + karma::rule<outiter_type, space_type> a, b, c, start; + + a = 'a'; + b = int_(10); + c = double_(12.4); + + // The FF is the dynamic equivalent of start = a << b << c; + start = a; + start = start.copy() << b; + start = start.copy() << c; + start = start.copy(); + + BOOST_TEST(test_delimited("a 10 12.4 ", start, space)); + } + + { // specifying the encoding + using karma::lower; + using karma::upper; + using karma::string; + + typedef boost::spirit::char_encoding::iso8859_1 iso8859_1; + karma::rule<outiter_type, iso8859_1> r; + + r = lower['\xE1']; + BOOST_TEST(test("\xE1", r)); + r = lower[char_('\xC1')]; + BOOST_TEST(test("\xE1", r)); + r = upper['\xE1']; + BOOST_TEST(test("\xC1", r)); + r = upper[char_('\xC1')]; + BOOST_TEST(test("\xC1", r)); + + r = lower["\xE1\xC1"]; + BOOST_TEST(test("\xE1\xE1", r)); + r = lower[lit("\xE1\xC1")]; + BOOST_TEST(test("\xE1\xE1", r)); + r = lower[string("\xE1\xC1")]; + BOOST_TEST(test("\xE1\xE1", r)); + r = upper["\xE1\xC1"]; + BOOST_TEST(test("\xC1\xC1", r)); + r = upper[lit("\xE1\xC1")]; + BOOST_TEST(test("\xC1\xC1", r)); + r = upper[string("\xE1\xC1")]; + BOOST_TEST(test("\xC1\xC1", r)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/pch.hpp b/src/boost/libs/spirit/test/karma/pch.hpp new file mode 100644 index 00000000..dd711908 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/pch.hpp @@ -0,0 +1,21 @@ +/*============================================================================= + Copyright (c) 2019 Nikita Kniazev + + 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) +=============================================================================*/ +#ifdef BOOST_BUILD_PCH_ENABLED + +#include <boost/spirit/include/karma.hpp> +#include <boost/spirit/include/support_argument.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/core/lightweight_test.hpp> +#include <boost/optional.hpp> +#include <boost/variant.hpp> +#include <vector> +#include <string> +#include <sstream> +#include <iostream> + +#endif diff --git a/src/boost/libs/spirit/test/karma/plus.cpp b/src/boost/libs/spirit/test/karma/plus.cpp new file mode 100644 index 00000000..1bd2daab --- /dev/null +++ b/src/boost/libs/spirit/test/karma/plus.cpp @@ -0,0 +1,223 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/assign/std/vector.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_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/fusion/include/vector.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/fusion/include/std_pair.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +struct action +{ + action (std::vector<char>& vec) + : vec(vec), it(vec.begin()) + {} + + void operator()(unsigned& value, boost::spirit::unused_type, bool& pass) const + { + pass = (it != vec.end()); + if (pass) + value = *it++; + } + + std::vector<char>& vec; + mutable std::vector<char>::iterator it; +}; + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost::spirit; + using namespace boost::spirit::ascii; + namespace fusion = boost::fusion; + + { + std::string s1("aaaa"); + BOOST_TEST(test("aaaa", +char_, s1)); + BOOST_TEST(test_delimited("a a a a ", +char_, s1, ' ')); + + std::string s2("a"); + BOOST_TEST(test("a", +char_, s2)); + BOOST_TEST(test_delimited("a ", +char_, s2, ' ')); + + std::string s3(""); + BOOST_TEST(!test("", +char_, s2)); + BOOST_TEST(!test_delimited("", +char_, s3, ' ')); + } + + { + std::string s1("aaaaa"); + BOOST_TEST(test("aaaaa", char_ << +(char_ << char_), s1)); + BOOST_TEST(test_delimited("a a a a a ", + char_ << +(char_ << char_), s1, ' ')); + + s1 = "a"; + BOOST_TEST(!test("", char_ << +(char_ << char_), s1)); + s1 = "aa"; + BOOST_TEST(!test("", char_ << +(char_ << char_), s1)); + s1 = "aaaa"; + BOOST_TEST(!test("", char_ << +(char_ << char_), s1)); + } + + { + using boost::spirit::karma::strict; + using boost::spirit::karma::relaxed; + using namespace boost::assign; + + typedef std::pair<char, char> data; + std::vector<data> v1; + v1 += std::make_pair('a', 'a'), + std::make_pair('b', 'b'), + std::make_pair('c', 'c'), + std::make_pair('d', 'd'), + std::make_pair('e', 'e'), + std::make_pair('f', 'f'), + std::make_pair('g', 'g'); + + karma::rule<spirit_test::output_iterator<char>::type, data()> r; + r = &char_('a') << char_; + + BOOST_TEST(!test("", r << +(r << r), v1)); + BOOST_TEST(!test("", relaxed[r << +(r << r)], v1)); + BOOST_TEST(!test("", strict[r << +(r << r)], v1)); + + v1 += std::make_pair('a', 'a'); + + BOOST_TEST(!test("", r << *(r << r), v1)); + BOOST_TEST(!test("", relaxed[r << +(r << r)], v1)); + BOOST_TEST(!test("", strict[r << +(r << r)], v1)); + + v1 += std::make_pair('a', 'a'); + + BOOST_TEST(test("aaa", r << +(r << r), v1)); + BOOST_TEST(test("aaa", relaxed[r << +(r << r)], v1)); + BOOST_TEST(!test("", strict[r << +(r << r)], v1)); + } + + { + using namespace boost::assign; + + std::vector<char> v; + v += 'a', 'b', 'c'; + + BOOST_TEST(test("abc", +char_, v)); + BOOST_TEST(test_delimited("a b c ", +char_, v, ' ')); + } + + { + using namespace boost::assign; + + std::vector<int> v; + v += 10, 20, 30; + + BOOST_TEST(test("102030", +int_, v)); + BOOST_TEST(test_delimited("10, 20, 30, ", +int_, v, lit(", "))); + + BOOST_TEST(test("10,20,30,", +(int_ << ','), v)); + BOOST_TEST(test_delimited("10 , 20 , 30 , ", +(int_ << ','), v, lit(' '))); + +// leads to infinite loops +// fusion::vector<char, char> cc ('a', 'c'); +// BOOST_TEST(test("ac", char_ << !+(lit(' ') << ',') << char_, cc)); +// BOOST_TEST(test_delimited("a c ", +// char_ << !+(lit(' ') << ',') << char_, cc, " ")); + } + + { // actions + using namespace boost::assign; + namespace phx = boost::phoenix; + + std::vector<char> v; + v += 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'; + + BOOST_TEST(test("abcdefgh", (+char_)[_1 = phx::ref(v)])); + BOOST_TEST(test_delimited("a b c d e f g h ", + (+char_ )[_1 = phx::ref(v)], space)); + } + + // failing sub-generators + { + using boost::spirit::karma::strict; + using boost::spirit::karma::relaxed; + + using namespace boost::assign; + + typedef std::pair<char, char> data; + std::vector<data> v2; + v2 += std::make_pair('a', 'a'), + std::make_pair('b', 'b'), + std::make_pair('c', 'c'), + std::make_pair('d', 'd'), + std::make_pair('e', 'e'), + std::make_pair('f', 'f'), + std::make_pair('g', 'g'); + + karma::rule<spirit_test::output_iterator<char>::type, data()> r; + + r = &char_('d') << char_; + BOOST_TEST(test("d", +r, v2)); + BOOST_TEST(test("d", relaxed[+r], v2)); + BOOST_TEST(!test("", strict[+r], v2)); + + r = &char_('a') << char_; + BOOST_TEST(test("a", +r, v2)); + BOOST_TEST(test("a", relaxed[+r], v2)); + BOOST_TEST(test("a", strict[+r], v2)); + + r = &char_('g') << char_; + BOOST_TEST(test("g", +r, v2)); + BOOST_TEST(test("g", relaxed[+r], v2)); + BOOST_TEST(!test("", strict[+r], v2)); + + r = !char_('d') << char_; + BOOST_TEST(test("abcefg", +r, v2)); + BOOST_TEST(test("abcefg", relaxed[+r], v2)); + BOOST_TEST(test("abc", strict[+r], v2)); + + r = !char_('a') << char_; + BOOST_TEST(test("bcdefg", +r, v2)); + BOOST_TEST(test("bcdefg", relaxed[+r], v2)); + BOOST_TEST(!test("", strict[+r], v2)); + + r = !char_('g') << char_; + BOOST_TEST(test("abcdef", +r, v2)); + BOOST_TEST(test("abcdef", +r, v2)); + BOOST_TEST(test("abcdef", +r, v2)); + + r = &char_('A') << char_; + BOOST_TEST(!test("", +r, v2)); + } + + { + // make sure user defined end condition is applied if no attribute + // is passed in + using namespace boost::assign; + + std::vector<char> v; + v += 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'; + BOOST_TEST(test("[6162636465666768]", '[' << +hex[action(v)] << ']')); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/real.hpp b/src/boost/libs/spirit/test/karma/real.hpp new file mode 100644 index 00000000..0acc7ed8 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/real.hpp @@ -0,0 +1,115 @@ +/*============================================================================== + Copyright (c) 2001-2010 Hartmut Kaiser + Copyright (c) 2010 Bryce Lelbach + + 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) +==============================================================================*/ + +#if !defined(BOOST_SPIRIT_TEST_REAL_NUMERICS_HPP) +#define BOOST_SPIRIT_TEST_REAL_NUMERICS_HPP + +#include <boost/version.hpp> +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/math/concepts/real_concept.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_directive.hpp> + +#include <boost/limits.hpp> +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +// policy for real_generator, which forces the scientific notation +template <typename T> +struct scientific_policy : boost::spirit::karma::real_policies<T> +{ + // we want the numbers always to be in scientific format + typedef boost::spirit::karma::real_policies<T> base_type; + static int floatfield(T) { return base_type::fmtflags::scientific; } +}; + +/////////////////////////////////////////////////////////////////////////////// +// policy for real_generator, which forces the fixed notation +template <typename T> +struct fixed_policy : boost::spirit::karma::real_policies<T> +{ + typedef boost::spirit::karma::real_policies<T> base_type; + + // we want the numbers always to be in fixed format + static int floatfield(T) { return base_type::fmtflags::fixed; } +}; + +/////////////////////////////////////////////////////////////////////////////// +// policy for real_generator, which forces to output trailing zeros in the +// fractional part +template <typename T> +struct trailing_zeros_policy : boost::spirit::karma::real_policies<T> // 4 digits +{ + // we want the numbers always to contain trailing zeros up to 4 digits in + // the fractional part + static bool trailing_zeros(T) { return true; } + + // we want to generate up to 4 fractional digits + static unsigned int precision(T) { return 4; } +}; + +/////////////////////////////////////////////////////////////////////////////// +// policy for real_generator, which forces the sign to be generated +template <typename T> +struct signed_policy : boost::spirit::karma::real_policies<T> +{ + // we want to always have a sign generated + static bool force_sign(T) + { + return true; + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// policy for real_generator, which forces to output trailing zeros in the +// fractional part +template <typename T> +struct bordercase_policy : boost::spirit::karma::real_policies<T> +{ + // we want to generate up to the maximum significant amount of fractional + // digits + static unsigned int precision(T) + { + return std::numeric_limits<T>::digits10 + 1; + } +}; + +/////////////////////////////////////////////////////////////////////////////// +// policy for real_generator, which forces to output trailing zeros in the +// fractional part +template <typename T> +struct statefull_policy : boost::spirit::karma::real_policies<T> +{ + statefull_policy(int precision = 4, bool trailingzeros = false) + : precision_(precision), trailingzeros_(trailingzeros) + {} + + // we want to generate up to the maximum significant amount of fractional + // digits + unsigned int precision(T) const + { + return precision_; + } + + bool trailing_zeros(T) const + { + return trailingzeros_; + } + + int precision_; + bool trailingzeros_; +}; + +#endif // BOOST_SPIRIT_TEST_REAL_NUMERICS_HPP + diff --git a/src/boost/libs/spirit/test/karma/real1.cpp b/src/boost/libs/spirit/test/karma/real1.cpp new file mode 100644 index 00000000..8bb41102 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/real1.cpp @@ -0,0 +1,180 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2011 Bryce Lelbach +// +// 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) + +#include "real.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost::spirit; + + { + /////////////////////////////////////////////////////////////////////// + // use the default real_policies + BOOST_TEST(test("0.0", double_, 0.0)); + BOOST_TEST(test("1.0", double_, 1.0)); + BOOST_TEST(test("1.0", double_, 1.0001)); + BOOST_TEST(test("1.001", double_, 1.001)); + BOOST_TEST(test("1.01", double_, 1.010)); + BOOST_TEST(test("1.1", double_, 1.100)); + + BOOST_TEST(test("1.234e-04", double_, 0.00012345)); + BOOST_TEST(test("0.001", double_, 0.0012345)); + BOOST_TEST(test("0.012", double_, 0.012345)); + BOOST_TEST(test("0.123", double_, 0.12345)); + BOOST_TEST(test("1.234", double_, 1.2345)); + BOOST_TEST(test("12.346", double_, 12.346)); + BOOST_TEST(test("123.46", double_, 123.46)); + BOOST_TEST(test("1234.5", double_, 1234.5)); + BOOST_TEST(test("12342.0", double_, 12342.)); + BOOST_TEST(test("1.234e05", double_, 123420.)); + + BOOST_TEST(test("-1.0", double_, -1.0)); + BOOST_TEST(test("-1.234", double_, -1.2345)); + BOOST_TEST(test("-1.235", double_, -1.2346)); + BOOST_TEST(test("-1234.2", double_, -1234.2)); + + BOOST_TEST(test("1.0", double_(1.0))); + BOOST_TEST(test("1.0", double_(1.0001))); + BOOST_TEST(test("1.001", double_(1.001))); + BOOST_TEST(test("1.01", double_(1.010))); + BOOST_TEST(test("1.1", double_(1.100))); + + BOOST_TEST(test("1.234e-04", double_(0.00012345))); + BOOST_TEST(test("0.001", double_(0.0012345))); + BOOST_TEST(test("0.012", double_(0.012345))); + BOOST_TEST(test("0.123", double_(0.12345))); + BOOST_TEST(test("1.234", double_(1.2345))); + BOOST_TEST(test("12.346", double_(12.346))); + BOOST_TEST(test("123.46", double_(123.46))); + BOOST_TEST(test("1234.5", double_(1234.5))); + BOOST_TEST(test("12342.0", double_(12342.))); + BOOST_TEST(test("1.234e05", double_(123420.))); + } + + { + /////////////////////////////////////////////////////////////////////// + // test NaN and Inf + BOOST_TEST(test("nan", double_, std::numeric_limits<double>::quiet_NaN())); + BOOST_TEST(test("-nan", double_, -std::numeric_limits<double>::quiet_NaN())); + BOOST_TEST(test("inf", double_, std::numeric_limits<double>::infinity())); + BOOST_TEST(test("-inf", double_, -std::numeric_limits<double>::infinity())); + + typedef karma::real_generator<double, signed_policy<double> > signed_type; + signed_type const signed_ = signed_type(); + + BOOST_TEST(test("+nan", signed_, std::numeric_limits<double>::quiet_NaN())); + BOOST_TEST(test("-nan", signed_, -std::numeric_limits<double>::quiet_NaN())); + BOOST_TEST(test("+inf", signed_, std::numeric_limits<double>::infinity())); + BOOST_TEST(test("-inf", signed_, -std::numeric_limits<double>::infinity())); +#if defined(BOOST_SPIRIT_ZERO_PROBLEM) + BOOST_TEST(test(" 0.0", signed_, 0.0)); +#endif + + BOOST_TEST(test("+nan", signed_(std::numeric_limits<double>::quiet_NaN()))); + BOOST_TEST(test("-nan", signed_(-std::numeric_limits<double>::quiet_NaN()))); + BOOST_TEST(test("+inf", signed_(std::numeric_limits<double>::infinity()))); + BOOST_TEST(test("-inf", signed_(-std::numeric_limits<double>::infinity()))); +#if defined(BOOST_SPIRIT_ZERO_PROBLEM) + BOOST_TEST(test(" 0.0", signed_(0.0))); +#endif + } + + { + /////////////////////////////////////////////////////////////////////// + typedef karma::real_generator<double, statefull_policy<double> > + statefull_type; + + statefull_policy<double> policy(5, true); + statefull_type const statefull = statefull_type(policy); + + BOOST_TEST(test("0.00000", statefull, 0.0)); + BOOST_TEST(test("0.00000", statefull(0.0))); + + using namespace boost::phoenix; + BOOST_TEST(test("0.00000", statefull(val(0.0)))); + } + + { + /////////////////////////////////////////////////////////////////////// + typedef karma::real_generator<double, trailing_zeros_policy<double> > + trailing_zeros_type; + trailing_zeros_type const trail_zeros = trailing_zeros_type(); + + BOOST_TEST(test("0.0000", trail_zeros, 0.0)); + BOOST_TEST(test("1.0000", trail_zeros, 1.0)); + BOOST_TEST(test("1.0001", trail_zeros, 1.0001)); + BOOST_TEST(test("1.0010", trail_zeros, 1.001)); + BOOST_TEST(test("1.0100", trail_zeros, 1.010)); + BOOST_TEST(test("1.1000", trail_zeros, 1.100)); + + BOOST_TEST(test("1.2345e-04", trail_zeros, 0.00012345)); + BOOST_TEST(test("0.0012", trail_zeros, 0.0012345)); + BOOST_TEST(test("0.0123", trail_zeros, 0.012345)); + BOOST_TEST(test("0.1235", trail_zeros, 0.12345)); + BOOST_TEST(test("1.2345", trail_zeros, 1.2345)); + BOOST_TEST(test("12.3460", trail_zeros, 12.346)); + BOOST_TEST(test("123.4600", trail_zeros, 123.46)); + BOOST_TEST(test("1234.5000", trail_zeros, 1234.5)); + BOOST_TEST(test("12342.0000", trail_zeros, 12342.)); + BOOST_TEST(test("1.2342e05", trail_zeros, 123420.)); + + BOOST_TEST(test("-1.0000", trail_zeros, -1.0)); + BOOST_TEST(test("-1.2345", trail_zeros, -1.2345)); + BOOST_TEST(test("-1.2346", trail_zeros, -1.2346)); + BOOST_TEST(test("-1234.2000", trail_zeros, -1234.2)); + + BOOST_TEST(test("1.0000", trail_zeros(1.0))); + BOOST_TEST(test("1.0001", trail_zeros(1.0001))); + BOOST_TEST(test("1.0010", trail_zeros(1.001))); + BOOST_TEST(test("1.0100", trail_zeros(1.010))); + BOOST_TEST(test("1.1000", trail_zeros(1.100))); + + BOOST_TEST(test("1.2345e-04", trail_zeros(0.00012345))); + BOOST_TEST(test("0.0012", trail_zeros(0.0012345))); + BOOST_TEST(test("0.0123", trail_zeros(0.012345))); + BOOST_TEST(test("0.1235", trail_zeros(0.12345))); + BOOST_TEST(test("1.2345", trail_zeros(1.2345))); + BOOST_TEST(test("12.3460", trail_zeros(12.346))); + BOOST_TEST(test("123.4600", trail_zeros(123.46))); + BOOST_TEST(test("1234.5000", trail_zeros(1234.5))); + BOOST_TEST(test("12342.0000", trail_zeros(12342.))); + BOOST_TEST(test("1.2342e05", trail_zeros(123420.))); + } + + { + using namespace boost::spirit::ascii; + + /////////////////////////////////////////////////////////////////////// + // test NaN and Inf + BOOST_TEST(test("NAN", upper[double_], + std::numeric_limits<double>::quiet_NaN())); + BOOST_TEST(test("-NAN", upper[double_], + -std::numeric_limits<double>::quiet_NaN())); + BOOST_TEST(test("INF", upper[double_], + std::numeric_limits<double>::infinity())); + BOOST_TEST(test("-INF", upper[double_], + -std::numeric_limits<double>::infinity())); + + typedef karma::real_generator<double, signed_policy<double> > signed_type; + signed_type const signed_ = signed_type(); + + BOOST_TEST(test("+NAN", upper[signed_], + std::numeric_limits<double>::quiet_NaN())); + BOOST_TEST(test("-NAN", upper[signed_], + -std::numeric_limits<double>::quiet_NaN())); + BOOST_TEST(test("+INF", upper[signed_], + std::numeric_limits<double>::infinity())); + BOOST_TEST(test("-INF", upper[signed_], + -std::numeric_limits<double>::infinity())); +#if defined(BOOST_SPIRIT_ZERO_PROBLEM) + BOOST_TEST(test(" 0.0", upper[signed_], 0.0)); +#endif + } + + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/real2.cpp b/src/boost/libs/spirit/test/karma/real2.cpp new file mode 100644 index 00000000..62ff60d6 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/real2.cpp @@ -0,0 +1,163 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2011 Bryce Lelbach +// +// 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) + +#include "real.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + + /////////////////////////////////////////////////////////////////////// + BOOST_TEST(test_delimited("0.0 ", double_, 0.0, char_(' '))); + BOOST_TEST(test_delimited("1.0 ", double_, 1.0, char_(' '))); + BOOST_TEST(test_delimited("1.0 ", double_, 1.0001, char_(' '))); + BOOST_TEST(test_delimited("1.001 ", double_, 1.001, char_(' '))); + BOOST_TEST(test_delimited("1.01 ", double_, 1.010, char_(' '))); + BOOST_TEST(test_delimited("1.1 ", double_, 1.100, char_(' '))); + + BOOST_TEST(test_delimited("1.234e-04 ", double_, 0.00012345, char_(' '))); + BOOST_TEST(test_delimited("0.001 ", double_, 0.0012345, char_(' '))); + BOOST_TEST(test_delimited("0.012 ", double_, 0.012345, char_(' '))); + BOOST_TEST(test_delimited("0.123 ", double_, 0.12345, char_(' '))); + BOOST_TEST(test_delimited("1.234 ", double_, 1.2345, char_(' '))); + BOOST_TEST(test_delimited("12.346 ", double_, 12.346, char_(' '))); + BOOST_TEST(test_delimited("123.46 ", double_, 123.46, char_(' '))); + BOOST_TEST(test_delimited("1234.5 ", double_, 1234.5, char_(' '))); + BOOST_TEST(test_delimited("12342.0 ", double_, 12342., char_(' '))); + BOOST_TEST(test_delimited("1.234e05 ", double_, 123420., char_(' '))); + + BOOST_TEST(test_delimited("-1.0 ", double_, -1.0, char_(' '))); + BOOST_TEST(test_delimited("-1.234 ", double_, -1.2345, char_(' '))); + BOOST_TEST(test_delimited("-1.235 ", double_, -1.2346, char_(' '))); + BOOST_TEST(test_delimited("-1234.2 ", double_, -1234.2, char_(' '))); + + BOOST_TEST(test_delimited("1.0 ", double_(1.0), char_(' '))); + BOOST_TEST(test_delimited("1.0 ", double_(1.0001), char_(' '))); + BOOST_TEST(test_delimited("1.001 ", double_(1.001), char_(' '))); + BOOST_TEST(test_delimited("1.01 ", double_(1.010), char_(' '))); + BOOST_TEST(test_delimited("1.1 ", double_(1.100), char_(' '))); + + BOOST_TEST(test_delimited("1.234e-04 ", double_(0.00012345), char_(' '))); + BOOST_TEST(test_delimited("0.001 ", double_(0.0012345), char_(' '))); + BOOST_TEST(test_delimited("0.012 ", double_(0.012345), char_(' '))); + BOOST_TEST(test_delimited("0.123 ", double_(0.12345), char_(' '))); + BOOST_TEST(test_delimited("1.234 ", double_(1.2345), char_(' '))); + BOOST_TEST(test_delimited("12.346 ", double_(12.346), char_(' '))); + BOOST_TEST(test_delimited("123.46 ", double_(123.46), char_(' '))); + BOOST_TEST(test_delimited("1234.5 ", double_(1234.5), char_(' '))); + BOOST_TEST(test_delimited("12342.0 ", double_(12342.), char_(' '))); + BOOST_TEST(test_delimited("1.234e05 ", double_(123420.), char_(' '))); + } + + { + using namespace boost::spirit::ascii; + + /////////////////////////////////////////////////////////////////////// + // test NaN and Inf + BOOST_TEST(test_delimited("nan ", double_, + std::numeric_limits<double>::quiet_NaN(), char_(' '))); + BOOST_TEST(test_delimited("-nan ", double_, + -std::numeric_limits<double>::quiet_NaN(), char_(' '))); + BOOST_TEST(test_delimited("inf ", double_, + std::numeric_limits<double>::infinity(), char_(' '))); + BOOST_TEST(test_delimited("-inf ", double_, + -std::numeric_limits<double>::infinity(), char_(' '))); + + typedef karma::real_generator<double, signed_policy<double> > signed_type; + signed_type const signed_ = signed_type(); + + BOOST_TEST(test_delimited("+nan ", signed_, + std::numeric_limits<double>::quiet_NaN(), char_(' '))); + BOOST_TEST(test_delimited("-nan ", signed_, + -std::numeric_limits<double>::quiet_NaN(), char_(' '))); + BOOST_TEST(test_delimited("+inf ", signed_, + std::numeric_limits<double>::infinity(), char_(' '))); + BOOST_TEST(test_delimited("-inf ", signed_, + -std::numeric_limits<double>::infinity(), char_(' '))); +#if defined(BOOST_SPIRIT_ZERO_PROBLEM) + BOOST_TEST(test_delimited(" 0.0 ", signed_, 0.0, char_(' '))); +#endif + } + + { + using namespace boost::spirit::ascii; + + /////////////////////////////////////////////////////////////////////// + typedef karma::real_generator<double, scientific_policy<double> > + science_type; + science_type const science = science_type(); + + BOOST_TEST(test("0.0e00", science, 0.0)); + BOOST_TEST(test("1.0e00", science, 1.0)); + + BOOST_TEST(test("1.234e-05", science, 0.000012345)); + BOOST_TEST(test("1.234e-04", science, 0.00012345)); + BOOST_TEST(test("1.234e-03", science, 0.0012345)); + BOOST_TEST(test("1.234e-02", science, 0.012345)); + BOOST_TEST(test("1.235e-01", science, 0.12345)); // note the rounding error! + BOOST_TEST(test("1.234e00", science, 1.2345)); + BOOST_TEST(test("1.235e01", science, 12.346)); + BOOST_TEST(test("1.235e02", science, 123.46)); + BOOST_TEST(test("1.234e03", science, 1234.5)); + BOOST_TEST(test("1.234e04", science, 12342.)); + BOOST_TEST(test("1.234e05", science, 123420.)); + + BOOST_TEST(test("-1.234e-05", science, -0.000012345)); + BOOST_TEST(test("-1.234e-04", science, -0.00012345)); + BOOST_TEST(test("-1.234e-03", science, -0.0012345)); + BOOST_TEST(test("-1.234e-02", science, -0.012345)); + BOOST_TEST(test("-1.235e-01", science, -0.12345)); // note the rounding error! + BOOST_TEST(test("-1.234e00", science, -1.2345)); + BOOST_TEST(test("-1.235e01", science, -12.346)); + BOOST_TEST(test("-1.235e02", science, -123.46)); + BOOST_TEST(test("-1.234e03", science, -1234.5)); + BOOST_TEST(test("-1.234e04", science, -12342.)); + BOOST_TEST(test("-1.234e05", science, -123420.)); + + BOOST_TEST(test("1.234E-05", upper[science], 0.000012345)); + BOOST_TEST(test("1.234E-04", upper[science], 0.00012345)); + BOOST_TEST(test("1.234E-03", upper[science], 0.0012345)); + BOOST_TEST(test("1.234E-02", upper[science], 0.012345)); + BOOST_TEST(test("1.235E-01", upper[science], 0.12345)); // note the rounding error! + BOOST_TEST(test("1.234E00", upper[science], 1.2345)); + BOOST_TEST(test("1.235E01", upper[science], 12.346)); + BOOST_TEST(test("1.235E02", upper[science], 123.46)); + BOOST_TEST(test("1.234E03", upper[science], 1234.5)); + BOOST_TEST(test("1.234E04", upper[science], 12342.)); + BOOST_TEST(test("1.234E05", upper[science], 123420.)); + + BOOST_TEST(test("-1.234E-05", upper[science], -0.000012345)); + BOOST_TEST(test("-1.234E-04", upper[science], -0.00012345)); + BOOST_TEST(test("-1.234E-03", upper[science], -0.0012345)); + BOOST_TEST(test("-1.234E-02", upper[science], -0.012345)); + BOOST_TEST(test("-1.235E-01", upper[science], -0.12345)); // note the rounding error! + BOOST_TEST(test("-1.234E00", upper[science], -1.2345)); + BOOST_TEST(test("-1.235E01", upper[science], -12.346)); + BOOST_TEST(test("-1.235E02", upper[science], -123.46)); + BOOST_TEST(test("-1.234E03", upper[science], -1234.5)); + BOOST_TEST(test("-1.234E04", upper[science], -12342.)); + BOOST_TEST(test("-1.234E05", upper[science], -123420.)); + } + + { + BOOST_TEST(test("1.0", lit(1.0))); + BOOST_TEST(test("1.0", lit(1.0f))); + BOOST_TEST(test("1.0", lit(1.0l))); + + BOOST_TEST(test("1.0", double_(1.0), 1.0)); + BOOST_TEST(test("1.0", float_(1.0), 1.0f)); + BOOST_TEST(test("1.0", long_double(1.0), 1.0l)); + BOOST_TEST(!test("", double_(1.0), 2.0)); + BOOST_TEST(!test("", float_(1.0), 2.0f)); + BOOST_TEST(!test("", long_double(1.0), 2.0l)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/real3.cpp b/src/boost/libs/spirit/test/karma/real3.cpp new file mode 100644 index 00000000..fda1508c --- /dev/null +++ b/src/boost/libs/spirit/test/karma/real3.cpp @@ -0,0 +1,185 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2011 Bryce Lelbach +// +// 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) + +#include <boost/spirit/include/version.hpp> +#include <boost/spirit/include/karma_phoenix_attributes.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include "real.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// the customization points below have been added only recently +#if SPIRIT_VERSION >= 0x2050 +// does not provide proper std::numeric_limits, we need to roll our own +namespace boost { namespace spirit { namespace traits +{ + template <> + struct is_nan<boost::math::concepts::real_concept> + { + static bool call(boost::math::concepts::real_concept n) + { + return test_nan(n.value()); + } + }; + + template <> + struct is_infinite<boost::math::concepts::real_concept> + { + static bool call(boost::math::concepts::real_concept n) + { + return test_infinite(n.value()); + } + }; +}}} +#endif + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost::spirit; + + { + using namespace boost::spirit::ascii; + + /////////////////////////////////////////////////////////////////////// + typedef karma::real_generator<double, fixed_policy<double> > fixed_type; + fixed_type const fixed = fixed_type(); + + BOOST_TEST(test("0.0", fixed, 0.0)); + BOOST_TEST(test("1.0", fixed, 1.0)); + + BOOST_TEST(test("0.0", fixed, 0.000012345)); + BOOST_TEST(test("0.0", fixed, 0.00012345)); + BOOST_TEST(test("0.001", fixed, 0.0012345)); + BOOST_TEST(test("0.012", fixed, 0.012345)); + BOOST_TEST(test("0.123", fixed, 0.12345)); + BOOST_TEST(test("1.234", fixed, 1.2345)); + BOOST_TEST(test("12.345", fixed, 12.345)); + BOOST_TEST(test("123.45", fixed, 123.45)); + BOOST_TEST(test("1234.5", fixed, 1234.5)); + BOOST_TEST(test("12342.0", fixed, 12342.)); + BOOST_TEST(test("123420.0", fixed, 123420.)); + BOOST_TEST(test("123420000000000000000.0", fixed, 1.23420e20)); + + BOOST_TEST(test("0.0", fixed, -0.000012345)); + BOOST_TEST(test("0.0", fixed, -0.00012345)); + BOOST_TEST(test("-0.001", fixed, -0.0012345)); + BOOST_TEST(test("-0.012", fixed, -0.012345)); + BOOST_TEST(test("-0.123", fixed, -0.12345)); + BOOST_TEST(test("-1.234", fixed, -1.2345)); + BOOST_TEST(test("-12.346", fixed, -12.346)); + BOOST_TEST(test("-123.46", fixed, -123.46)); + BOOST_TEST(test("-1234.5", fixed, -1234.5)); + BOOST_TEST(test("-12342.0", fixed, -12342.)); + BOOST_TEST(test("-123420.0", fixed, -123420.)); + BOOST_TEST(test("-123420000000000000000.0", fixed, -1.23420e20)); + } + +// support for using real_concept with a Karma generator has been implemented +// in Boost versions > 1.36 only, additionally real_concept is available only +// if BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS is not defined +#if BOOST_VERSION > 103600 && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS) + { + using boost::math::concepts::real_concept; + typedef karma::real_generator<real_concept> custom_type; + custom_type const custom = custom_type(); + + BOOST_TEST(test("0.0", custom, real_concept(0.0))); + BOOST_TEST(test("1.0", custom, real_concept(1.0))); + BOOST_TEST(test("1.0", custom, real_concept(1.0001))); + BOOST_TEST(test("1.001", custom, real_concept(1.001))); + BOOST_TEST(test("1.01", custom, real_concept(1.010))); + BOOST_TEST(test("1.1", custom, real_concept(1.100))); + + BOOST_TEST(test("1.234e-04", custom, real_concept(0.00012345))); + BOOST_TEST(test("0.001", custom, real_concept(0.0012345))); + BOOST_TEST(test("0.012", custom, real_concept(0.012345))); + BOOST_TEST(test("0.123", custom, real_concept(0.12345))); + BOOST_TEST(test("1.234", custom, real_concept(1.2345))); + BOOST_TEST(test("12.346", custom, real_concept(12.346))); + BOOST_TEST(test("123.46", custom, real_concept(123.46))); + BOOST_TEST(test("1234.5", custom, real_concept(1234.5))); + BOOST_TEST(test("12342.0", custom, real_concept(12342.))); + BOOST_TEST(test("1.234e05", custom, real_concept(123420.))); + + BOOST_TEST(test("-1.0", custom, real_concept(-1.0))); + BOOST_TEST(test("-1.234", custom, real_concept(-1.2345))); + BOOST_TEST(test("-1.235", custom, real_concept(-1.2346))); + BOOST_TEST(test("-1234.2", custom, real_concept(-1234.2))); + + BOOST_TEST(test("1.0", custom(real_concept(1.0)))); + BOOST_TEST(test("1.0", custom(real_concept(1.0001)))); + BOOST_TEST(test("1.001", custom(real_concept(1.001)))); + BOOST_TEST(test("1.01", custom(real_concept(1.010)))); + BOOST_TEST(test("1.1", custom(real_concept(1.100)))); + + BOOST_TEST(test("1.234e-04", custom(real_concept(0.00012345)))); + BOOST_TEST(test("0.001", custom(real_concept(0.0012345)))); + BOOST_TEST(test("0.012", custom(real_concept(0.012345)))); + BOOST_TEST(test("0.123", custom(real_concept(0.12345)))); + BOOST_TEST(test("1.234", custom(real_concept(1.2345)))); + BOOST_TEST(test("12.346", custom(real_concept(12.346)))); + BOOST_TEST(test("123.46", custom(real_concept(123.46)))); + BOOST_TEST(test("1234.5", custom(real_concept(1234.5)))); + BOOST_TEST(test("12342.0", custom(real_concept(12342.)))); + BOOST_TEST(test("1.234e05", custom(real_concept(123420.)))); + } +#endif + +// this appears to be broken on Apple Tiger x86 with gcc4.0.1 +#if (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__ != 40001) || \ + !defined(__APPLE__) + { + /////////////////////////////////////////////////////////////////////// + typedef karma::real_generator<double, bordercase_policy<double> > + bordercase_type; + bordercase_type const bordercase = bordercase_type(); + +// BOOST_TEST(test("-5.7222349715140557e307", +// bordercase(-5.7222349715140557e307))); + + BOOST_TEST(test("1.7976931348623158e308", + bordercase(1.7976931348623158e308))); // DBL_MAX + BOOST_TEST(test("-1.7976931348623158e308", + bordercase(-1.7976931348623158e308))); // -DBL_MAX + BOOST_TEST(test("2.2250738585072014e-308", + bordercase(2.2250738585072014e-308))); // DBL_MIN + BOOST_TEST(test("-2.2250738585072014e-308", + bordercase(-2.2250738585072014e-308))); // -DBL_MIN + } +#endif + + { + boost::optional<double> v; + BOOST_TEST(!test("", double_, v)); + BOOST_TEST(!test("", double_(1.0), v)); + + v = 1.0; + BOOST_TEST(test("1.0", double_, v)); + BOOST_TEST(test("1.0", double_(1.0), v)); + } + +// we support Phoenix attributes only starting with V2.2 +#if SPIRIT_VERSION >= 0x2020 + { // Phoenix expression tests (requires to include + // karma_phoenix_attributes.hpp) + namespace phoenix = boost::phoenix; + + BOOST_TEST(test("1.0", double_, phoenix::val(1.0))); + + double d = 1.2; + BOOST_TEST(test("1.2", double_, phoenix::ref(d))); + BOOST_TEST(test("2.2", double_, ++phoenix::ref(d))); + } +#endif + + // test for denormalized numbers + { + BOOST_TEST(test("4.941e-324", double_, std::numeric_limits<double>::denorm_min())); + } + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/regression_adapt_adt.cpp b/src/boost/libs/spirit/test/karma/regression_adapt_adt.cpp new file mode 100644 index 00000000..41e88dc5 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_adapt_adt.cpp @@ -0,0 +1,176 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2011 Colin Rundel +// +// 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) + +#include <boost/mpl/print.hpp> +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/fusion/include/adapt_adt.hpp> + +#include <boost/spirit/include/karma.hpp> +#include <boost/spirit/include/support_adapt_adt_attributes.hpp> + +#include "test.hpp" + +/////////////////////////////////////////////////////////////////////////////// +class data1 +{ +private: + int width_; + int height_; + +public: + data1() + : width_(400), height_(400) + {} + + data1(int width, int height) + : width_(width), height_(height) + {} + + int width() const { return width_;} + int height() const { return height_;} + + void set_width(int width) { width_ = width;} + void set_height(int height) { height_ = height;} +}; + +BOOST_FUSION_ADAPT_ADT( + data1, + (int, int, obj.width(), obj.set_width(val)) + (int, int, obj.height(), obj.set_height(val)) +) + +/////////////////////////////////////////////////////////////////////////////// +class data2 +{ +private: + std::string data_; + +public: + data2() + : data_("test") + {} + + data2(std::string const& data) + : data_(data) + {} + + std::string const& data() const { return data_;} + void set_data(std::string const& data) { data_ = data;} +}; + +BOOST_FUSION_ADAPT_ADT( + data2, + (std::string, std::string const&, obj.data(), obj.set_data(val)) +) + +/////////////////////////////////////////////////////////////////////////////// +class data3 +{ +private: + double data_; + +public: + data3(double data = 0.0) + : data_(data) + {} + + double data() const { return data_;} + void set_data(double data) { data_ = data;} +}; + +BOOST_FUSION_ADAPT_ADT( + data3, + (double, double, obj.data(), obj.set_data(val)) +) + +/////////////////////////////////////////////////////////////////////////////// +class data4 +{ +public: + boost::optional<int> a_; + boost::optional<double> b_; + boost::optional<std::string> c_; + + boost::optional<int> const& a() const { return a_; } + boost::optional<double> const& b() const { return b_; } + boost::optional<std::string> const& c() const { return c_; } +}; + + +BOOST_FUSION_ADAPT_ADT( + data4, + (boost::optional<int>, boost::optional<int> const&, obj.a(), /**/) + (boost::optional<double>, boost::optional<double> const&, obj.b(), /**/) + (boost::optional<std::string>, boost::optional<std::string> const&, obj.c(), /**/) +) + +/////////////////////////////////////////////////////////////////////////////// +int main () +{ + using spirit_test::test; + + { + using boost::spirit::karma::int_; + + data1 b(800, 600); + BOOST_TEST(test("width: 800\nheight: 600\n", + "width: " << int_ << "\n" << "height: " << int_ << "\n", b)); + } + + { + using boost::spirit::karma::char_; + using boost::spirit::karma::string; + + data2 d("test"); + BOOST_TEST(test("data: test\n", "data: " << +char_ << "\n", d)); + BOOST_TEST(test("data: test\n", "data: " << string << "\n", d)); + } + + { + using boost::spirit::karma::double_; + + BOOST_TEST(test("x=0.0\n", "x=" << double_ << "\n", data3(0))); + BOOST_TEST(test("x=1.1\n", "x=" << double_ << "\n", data3(1.1))); + BOOST_TEST(test("x=1.0e10\n", "x=" << double_ << "\n", data3(1e10))); + +#if defined(_MSC_VER) && _MSC_VER < 1900 +# pragma warning(push) +# pragma warning(disable: 4127) // conditional expression is constant +#endif + BOOST_TEST(test("x=inf\n", "x=" << double_ << "\n", + data3(std::numeric_limits<double>::infinity()))); + if (std::numeric_limits<double>::has_quiet_NaN) { + BOOST_TEST(test("x=nan\n", "x=" << double_ << "\n", + data3(std::numeric_limits<double>::quiet_NaN()))); + } + if (std::numeric_limits<double>::has_signaling_NaN) { + BOOST_TEST(test("x=nan\n", "x=" << double_ << "\n", + data3(std::numeric_limits<double>::signaling_NaN()))); + } +#if defined(_MSC_VER) && _MSC_VER < 1900 +# pragma warning(pop) +#endif + } + + { + using boost::spirit::karma::double_; + using boost::spirit::karma::int_; + using boost::spirit::karma::string; + + data4 d; + d.b_ = 10; + + BOOST_TEST(test( + "Testing: b: 10.0\n", + "Testing: " << -("a: " << int_ << "\n") + << -("b: " << double_ << "\n") + << -("c: " << string << "\n"), d)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/regression_center_alignment.cpp b/src/boost/libs/spirit/test/karma/regression_center_alignment.cpp new file mode 100644 index 00000000..a2ff3b3c --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_center_alignment.cpp @@ -0,0 +1,66 @@ +// Copyright (c) 2001-2012 Hartmut Kaiser +// Copyright (c) 2012 yyyy yyyy <typhoonking77@hotmail.com> +// +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <string> +#include <vector> + +#include<boost/spirit/include/karma.hpp> + +int main() +{ + namespace karma = boost::spirit::karma; + + int num[] = {0, 1, 2, 3, 4, 5}; + std::vector<int> contents(num, num + sizeof(num) / sizeof(int)); + + { + std::string result; + BOOST_TEST(karma::generate(std::back_inserter(result), + *karma::center[karma::int_], contents)); + BOOST_TEST(result == " 0 1 2 3 4 5 "); + } + + { + std::string result; + BOOST_TEST(karma::generate(std::back_inserter(result), + *karma::center(5)[karma::int_], contents)); + BOOST_TEST(result == " 0 1 2 3 4 5 "); + } + + { + std::string result; + BOOST_TEST(karma::generate(std::back_inserter(result), + *karma::center("_")[karma::int_], contents)); + BOOST_TEST(result == "_____0_________1_________2_________3_________4_________5____"); + } + + { + std::string result; + BOOST_TEST(karma::generate(std::back_inserter(result), + *karma::center(5, "_")[karma::int_], contents)); + BOOST_TEST(result == "__0____1____2____3____4____5__"); + } + + { + std::string result; + BOOST_TEST(karma::generate(std::back_inserter(result), + *karma::center(karma::char_("_"))[karma::int_], contents)); + BOOST_TEST(result == "_____0_________1_________2_________3_________4_________5____"); + } + + { + std::string result; + BOOST_TEST(karma::generate(std::back_inserter(result), + *karma::center(5, karma::char_("_"))[karma::int_], contents)); + BOOST_TEST(result == "__0____1____2____3____4____5__"); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/regression_const_real_policies.cpp b/src/boost/libs/spirit/test/karma/regression_const_real_policies.cpp new file mode 100644 index 00000000..122ceea1 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_const_real_policies.cpp @@ -0,0 +1,25 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2011 Jeroen Habraken +// +// 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) + +// compile test verifying it's possible to use const types for real_policies. + +#include <boost/spirit/include/karma.hpp> + +#include <iterator> +#include <string> + +int main() +{ + using namespace boost::spirit::karma; + + typedef real_generator<double const, real_policies<double const> > + double_const_type; + + std::string generated; + generate(std::back_inserter(generated), double_const_type(), 1.0); + + return 0; +} diff --git a/src/boost/libs/spirit/test/karma/regression_container_variant_sequence.cpp b/src/boost/libs/spirit/test/karma/regression_container_variant_sequence.cpp new file mode 100644 index 00000000..56df14e2 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_container_variant_sequence.cpp @@ -0,0 +1,71 @@ +// Copyright (c) 2001-2012 Hartmut Kaiser +// Copyright (c) 2012 Benjamin Schindler +// +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/spirit/include/karma.hpp> +#include <boost/fusion/include/adapt_struct.hpp> +#include <set> + +namespace generator +{ + struct Enum + { + std::string enumName; + std::vector<std::string> enumEntries; + }; + typedef boost::variant<std::string, Enum> VariantType; + + namespace karma = boost::spirit::karma; + + // Our grammar definition + template<typename Iterator> + struct SettingsHeaderGenerator: karma::grammar<Iterator, VariantType()> + { + SettingsHeaderGenerator() : SettingsHeaderGenerator::base_type(baseRule) + { + using karma::lit; + using karma::string; + + enumRule = lit("enum ") << string << lit("\n{\n") << string % ",\n" << "}"; + declarationRule = lit("class ") << string << ';'; + baseRule = (declarationRule | enumRule) << lit("\n"); + + baseRule.name("base"); + enumRule.name("enum"); + declarationRule.name("declaration"); + } + + karma::rule<Iterator, std::string()> declarationRule; + karma::rule<Iterator, Enum()> enumRule; + karma::rule<Iterator, VariantType()> baseRule; + }; + + template <typename OutputIterator> + bool generate_header(OutputIterator& sink, VariantType& data) + { + SettingsHeaderGenerator<OutputIterator> generator; + return karma::generate(sink, generator, data); + } +} + +BOOST_FUSION_ADAPT_STRUCT(generator::Enum, + (std::string, enumName) + (std::vector<std::string>, enumEntries) +) + +int main() +{ + generator::VariantType variant = "bla"; + std::string generated; + std::back_insert_iterator<std::string> sink(generated); + BOOST_TEST(generator::generate_header(sink, variant)); + BOOST_TEST(generated == "class bla;\n"); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/regression_iterator.cpp b/src/boost/libs/spirit/test/karma/regression_iterator.cpp new file mode 100644 index 00000000..915d61aa --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_iterator.cpp @@ -0,0 +1,42 @@ +// Copyright (c) 2013 Louis Dionne +// Copyright (c) 2001-2013 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/range/adaptor/transformed.hpp> +#include <boost/spirit/include/karma.hpp> + +#include <iostream> + +// Note how the return is made by value instead of by reference. +template <typename T> T identity(T const& t) { return t; } + +template <typename Char, typename Expr, typename CopyExpr, typename CopyAttr + , typename Delimiter, typename Attribute> +bool test(Char const *expected, + boost::spirit::karma::detail::format_manip< + Expr, CopyExpr, CopyAttr, Delimiter, Attribute> const& fm) +{ + std::ostringstream ostrm; + ostrm << fm; + return ostrm.good() && ostrm.str() == expected; +} + +int main() +{ + namespace karma = boost::spirit::karma; + namespace adaptors = boost::adaptors; + int ints[] = {0, 1, 2, 3, 4}; + + BOOST_TEST((test("0 1 2 3 4", + karma::format(karma::int_ % ' ', + ints | adaptors::transformed(&identity<int>))) + )); + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/regression_optional_double.cpp b/src/boost/libs/spirit/test/karma/regression_optional_double.cpp new file mode 100644 index 00000000..b1fc422a --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_optional_double.cpp @@ -0,0 +1,52 @@ +// Copyright (c) 2010 Olaf Peter +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/spirit/include/karma.hpp> +#include <boost/detail/lightweight_test.hpp> + +namespace client +{ + namespace karma = boost::spirit::karma; + + template <typename OutputIterator> + struct grammar + : karma::grammar<OutputIterator, boost::optional<double>()> + { + grammar() + : grammar::base_type(start) + { + using karma::double_; + + u = double_ << "U"; + start = ( !double_ << "NA" ) | u; + + start.name("start"); + u.name("u"); + } + + karma::rule<OutputIterator, double()> u; + karma::rule<OutputIterator, boost::optional<double>()> start; + }; +} + +int main() +{ + namespace karma = boost::spirit::karma; + + typedef std::back_insert_iterator<std::string> sink_type; + + boost::optional<double> d1, d2; + d2 = 1.0; + + std::string generated1, generated2; + client::grammar<sink_type> g; + + BOOST_TEST(karma::generate(sink_type(generated1), g, d1) && generated1 == "NA"); + BOOST_TEST(karma::generate(sink_type(generated2), g, d2) && generated2 == "1.0U"); + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/regression_real_0.cpp b/src/boost/libs/spirit/test/karma/regression_real_0.cpp new file mode 100644 index 00000000..c04c1424 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_real_0.cpp @@ -0,0 +1,24 @@ +// Copyright (c) 2012 Agustin K-ballo Berge +// Copyright (c) 2001-2012 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/spirit/include/karma.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <iterator> +#include <sstream> +#include <string> + +int main() +{ + namespace karma = boost::spirit::karma; + std::string output; + std::back_insert_iterator< std::string > sink = std::back_inserter( output ); + karma::generate( sink, karma::double_, 0 ); // prints ¨inf¨ instead of ¨0.0¨ + BOOST_TEST((output == "0.0")); + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/regression_real_policy_sign.cpp b/src/boost/libs/spirit/test/karma/regression_real_policy_sign.cpp new file mode 100644 index 00000000..e4225f7f --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_real_policy_sign.cpp @@ -0,0 +1,43 @@ +// Copyright (c) 2013 Alex Korobka +// +// 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) + +// This test checks whether #8970 was fixed + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <iostream> +#include <boost/spirit/include/karma.hpp> + +#include "test.hpp" + +using namespace spirit_test; +using namespace boost::spirit; + +template <typename Num> +struct signed_policy : karma::real_policies<Num> +{ + static bool force_sign(Num /*n*/) { return true; } +}; + +int main() +{ + karma::real_generator<double, signed_policy<double> > const force_sign_double = + karma::real_generator<double, signed_policy<double> >(); + + BOOST_TEST(test("-0.123", force_sign_double, -0.123)); + BOOST_TEST(test("-1.123", force_sign_double, -1.123)); + BOOST_TEST(test("0.0", force_sign_double, 0)); + BOOST_TEST(test("+0.123", force_sign_double, 0.123)); + BOOST_TEST(test("+1.123", force_sign_double, 1.123)); + + using karma::double_; + BOOST_TEST(test("-0.123", double_, -0.123)); + BOOST_TEST(test("-1.123", double_, -1.123)); + BOOST_TEST(test("0.0", double_, 0)); + BOOST_TEST(test("0.123", double_, 0.123)); + BOOST_TEST(test("1.123", double_, 1.123)); + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/regression_real_scientific.cpp b/src/boost/libs/spirit/test/karma/regression_real_scientific.cpp new file mode 100644 index 00000000..45f67965 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_real_scientific.cpp @@ -0,0 +1,40 @@ +// Copyright (c) 2010 Lars Kielhorn +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/spirit/include/karma.hpp> + +#include <iostream> +#include <string> +#include <iterator> + +namespace karma = boost::spirit::karma; + +// define a new real number formatting policy +template <typename Num> +struct scientific_policy : karma::real_policies<Num> +{ + // we want the numbers always to be in scientific format + static int floatfield(Num) { return std::ios_base::scientific; } +}; + +int main() +{ + // define a new generator type based on the new policy + typedef karma::real_generator<double, scientific_policy<double> > + science_type; + science_type const scientific = science_type(); + + std::string output; + typedef std::back_insert_iterator<std::string> output_iterator; + output_iterator sink(output); + + // should output: 1.0e-01, but will output: 10.0e-02 + BOOST_TEST(karma::generate(sink, scientific, 0.1) && output == "1.0e-01"); + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/regression_semantic_action_attribute.cpp b/src/boost/libs/spirit/test/karma/regression_semantic_action_attribute.cpp new file mode 100644 index 00000000..01265d9f --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_semantic_action_attribute.cpp @@ -0,0 +1,36 @@ +// Copyright (c) 2010 Michael Caisse +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <string> +#include <vector> +#include <boost/spirit/include/karma.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +namespace karma = boost::spirit::karma; +namespace phx = boost::phoenix; + +int main() +{ + using karma::int_; + using karma::_1; + + BOOST_TEST(test("16909060", int_[ _1 = phx::val(0x01020304) ])); + + // make sure the passed attribute type does not enforce the attribute type + // for the semantic action + unsigned char char_value = 8; + BOOST_TEST(test("16909060", int_[ _1 = phx::val(0x01020304) ], char_value)); + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/regression_unicode_char.cpp b/src/boost/libs/spirit/test/karma/regression_unicode_char.cpp new file mode 100644 index 00000000..ab76acab --- /dev/null +++ b/src/boost/libs/spirit/test/karma/regression_unicode_char.cpp @@ -0,0 +1,63 @@ +// Copyright (c) 2012 David Bailey +// Copyright (c) 2001-2012 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#ifndef BOOST_SPIRIT_UNICODE +#define BOOST_SPIRIT_UNICODE +#endif + +#include <boost/spirit/home/karma/nonterminal/grammar.hpp> +#include <boost/spirit/home/karma/nonterminal/rule.hpp> +#include <boost/spirit/home/karma/char.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +template <typename OutputIterator> +struct unicode_char_grammar_ + : public boost::spirit::karma::grammar< + OutputIterator, boost::spirit::char_encoding::unicode::char_type()> +{ + unicode_char_grammar_() : unicode_char_grammar_::base_type(thechar) + { + using boost::spirit::karma::unicode::char_; + thechar = char_; + } + + boost::spirit::karma::rule< + OutputIterator, boost::spirit::char_encoding::unicode::char_type() + > thechar; +}; + +int +main() +{ + using namespace boost::spirit; + + { + typedef std::basic_string<char_encoding::unicode::char_type> unicode_string; + typedef std::back_insert_iterator<unicode_string> unicode_back_insert_iterator_type; + + using namespace boost::spirit::unicode; + + BOOST_TEST(test("x", char_, 'x')); + BOOST_TEST(test(L"x", char_, L'x')); + + char_encoding::unicode::char_type unicodeCharacter = 0x00000078u; + std::basic_string<char_encoding::unicode::char_type> expected; + expected.push_back(unicodeCharacter); + + unicode_char_grammar_<unicode_back_insert_iterator_type> unichar; + + BOOST_TEST(test(expected, unichar, unicodeCharacter)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/repeat1.cpp b/src/boost/libs/spirit/test/karma/repeat1.cpp new file mode 100644 index 00000000..ed0bc5d9 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/repeat1.cpp @@ -0,0 +1,144 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/assign/std/vector.hpp> + +#include <boost/spirit/include/karma_operator.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_directive.hpp> +#include <boost/spirit/include/karma_operator.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/karma_phoenix_attributes.hpp> +#include <boost/spirit/include/support_argument.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/fusion/include/std_pair.hpp> + +#include <string> +#include <iostream> +#include <vector> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +struct action +{ + action (std::vector<char>& vec) + : vec(vec), it(vec.begin()) + {} + + void operator()(unsigned& value, boost::spirit::unused_type, bool& pass) const + { + pass = (it != vec.end()); + if (pass) + value = *it++; + } + + std::vector<char>& vec; + mutable std::vector<char>::iterator it; +}; + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost::spirit::ascii; + using boost::spirit::karma::repeat; + using boost::spirit::karma::inf; + using boost::spirit::karma::int_; + using boost::spirit::karma::hex; + using boost::spirit::karma::_1; + + { // lazy repeats + using boost::phoenix::val; + + std::string str8("aaaaaaaa"); + BOOST_TEST(test("aaaaaaaa", repeat[char_], str8)); // kleene synonym + BOOST_TEST(test("aaaaaaaa", repeat(val(8))[char_], str8)); + BOOST_TEST(test("aaa", repeat(val(3))[char_], str8)); + BOOST_TEST(!test("aaaaaaaa", repeat(val(9))[char_], str8)); + + std::string str3("aaa"); + BOOST_TEST(test("aaaaa", repeat(val(3), val(5))[char_], str8)); + BOOST_TEST(test("aaa", repeat(val(3), val(5))[char_], str3)); + BOOST_TEST(!test("aaa", repeat(val(4), val(5))[char_], str3)); + + BOOST_TEST(test("aaa", repeat(val(3), val(inf))[char_], str3)); + BOOST_TEST(test("aaaaaaaa", repeat(val(3), val(inf))[char_], str8)); + BOOST_TEST(!test("aaa", repeat(val(4), val(inf))[char_], str3)); + } + + + { + std::string str8("aaaaaaaa"); + BOOST_TEST(test("aaaaaaaa", repeat[char_], str8)); // kleene synonym + BOOST_TEST(test("aaaaaaaa", repeat(8)[char_], str8)); + BOOST_TEST(test("aaa", repeat(3)[char_], str8)); + BOOST_TEST(!test("aaaaaaaa", repeat(9)[char_], str8)); + + std::string str3("aaa"); + BOOST_TEST(test("aaaaa", repeat(3, 5)[char_], str8)); + BOOST_TEST(test("aaa", repeat(3, 5)[char_], str3)); + BOOST_TEST(!test("aaa", repeat(4, 5)[char_], str3)); + + BOOST_TEST(test("aaa", repeat(3, inf)[char_], str3)); + BOOST_TEST(test("aaaaaaaa", repeat(3, inf)[char_], str8)); + BOOST_TEST(!test("aaa", repeat(4, inf)[char_], str3)); + } + + { + std::string str8("aaaaaaaa"); + BOOST_TEST(test_delimited("a a a a a a a a ", repeat[char_], str8, space)); + BOOST_TEST(test_delimited("a a a a a a a a ", repeat(8)[char_], str8, space)); + BOOST_TEST(test_delimited("a a a ", repeat(3)[char_], str8, space)); + BOOST_TEST(!test_delimited("a a a a a a a a ", repeat(9)[char_], str8, space)); + + std::string str3("aaa"); + BOOST_TEST(test_delimited("a a a a a ", repeat(3, 5)[char_], str8, space)); + BOOST_TEST(test_delimited("a a a ", repeat(3, 5)[char_], str3, space)); + BOOST_TEST(!test_delimited("a a a ", repeat(4, 5)[char_], str3, space)); + + BOOST_TEST(test_delimited("a a a ", repeat(3, inf)[char_], str3, space)); + BOOST_TEST(test_delimited("a a a a a a a a ", repeat(3, inf)[char_], str8, space)); + BOOST_TEST(!test_delimited("a a a ", repeat(4, inf)[char_], str3, space)); + } + + { + // make sure user defined end condition is applied if no attribute + // is passed in + using namespace boost::assign; + + std::vector<char> v; + v += 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'; + BOOST_TEST(test("[6162636465666768]", + '[' << repeat[hex[action(v)]] << ']')); + } + +// we support Phoenix attributes only starting with V2.2 +#if SPIRIT_VERSION >= 0x2020 + { + namespace ascii = boost::spirit::ascii; + namespace phoenix = boost::phoenix; + + char c = 'a'; + BOOST_TEST(test("bcd", repeat(3)[ascii::char_[_1 = ++phoenix::ref(c)]])); + + c = 'a'; + BOOST_TEST(test("bcd", repeat(3)[ascii::char_], ++phoenix::ref(c))); + } +#endif + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/repeat2.cpp b/src/boost/libs/spirit/test/karma/repeat2.cpp new file mode 100644 index 00000000..68464f33 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/repeat2.cpp @@ -0,0 +1,152 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/assign/std/vector.hpp> + +#include <boost/spirit/include/karma_operator.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_directive.hpp> +#include <boost/spirit/include/karma_operator.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/karma_phoenix_attributes.hpp> +#include <boost/spirit/include/support_argument.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> +#include <boost/fusion/include/std_pair.hpp> + +#include <string> +#include <iostream> +#include <vector> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +int main() +{ + using namespace boost::spirit::ascii; + using boost::spirit::karma::repeat; + using boost::spirit::karma::inf; + using boost::spirit::karma::int_; + using boost::spirit::karma::hex; + using boost::spirit::karma::_1; + + { + std::string str("aBcdeFGH"); + BOOST_TEST(test("abcdefgh", lower[repeat(8)[char_]], str)); + BOOST_TEST(test_delimited("A B C D E F G H ", upper[repeat(8)[char_]], str, space)); + } + + { + std::string s1 = "aaaaa"; + BOOST_TEST(test("aaaaa", char_ << repeat(2)[char_ << char_], s1)); + s1 = "aaa"; + BOOST_TEST(test("aaa", char_ << repeat(1, 2)[char_ << char_], s1)); + s1 = "aa"; + BOOST_TEST(!test("", char_ << repeat(1)[char_ << char_], s1)); + } + + { // actions + namespace phx = boost::phoenix; + + std::vector<char> v; + v.push_back('a'); + v.push_back('a'); + v.push_back('a'); + v.push_back('a'); + BOOST_TEST(test("aaaa", repeat(4)[char_][_1 = phx::ref(v)])); + } + + { // more actions + namespace phx = boost::phoenix; + + std::vector<int> v; + v.push_back(123); + v.push_back(456); + v.push_back(789); + BOOST_TEST(test_delimited("123 456 789 ", repeat(3)[int_][_1 = phx::ref(v)], space)); + } + + // failing sub-generators + { + using boost::spirit::karma::strict; + using boost::spirit::karma::relaxed; + + using namespace boost::assign; + namespace karma = boost::spirit::karma; + + typedef std::pair<char, char> data; + std::vector<data> v2, v3; + v2 += std::make_pair('a', 'a'), + std::make_pair('b', 'b'), + std::make_pair('c', 'c'), + std::make_pair('d', 'd'), + std::make_pair('e', 'e'), + std::make_pair('f', 'f'), + std::make_pair('g', 'g'); + v3 += std::make_pair('a', 'a'), + std::make_pair('b', 'b'), + std::make_pair('c', 'c'), + std::make_pair('d', 'd'); + + karma::rule<spirit_test::output_iterator<char>::type, data()> r; + + r = &char_('d') << char_; + BOOST_TEST(test("d", repeat[r], v2)); + BOOST_TEST(test("d", relaxed[repeat[r]], v2)); + BOOST_TEST(test("", strict[repeat[r]], v2)); + + r = !char_('d') << char_; + BOOST_TEST(test("abcefg", repeat(6)[r], v2)); + BOOST_TEST(!test("", repeat(5)[r], v2)); + BOOST_TEST(test("abcefg", relaxed[repeat(6)[r]], v2)); + BOOST_TEST(!test("", relaxed[repeat(5)[r]], v2)); + BOOST_TEST(!test("", strict[repeat(6)[r]], v2)); + BOOST_TEST(!test("", strict[repeat(5)[r]], v2)); + + r = !char_('c') << char_; + BOOST_TEST(test("abd", repeat(3)[r], v2)); + BOOST_TEST(test("abd", relaxed[repeat(3)[r]], v2)); + BOOST_TEST(!test("", strict[repeat(3)[r]], v2)); + + r = !char_('a') << char_; + BOOST_TEST(test("bcdef", repeat(3, 5)[r], v2)); + BOOST_TEST(test("bcd", repeat(3, 5)[r], v3)); + BOOST_TEST(!test("", repeat(4, 5)[r], v3)); + BOOST_TEST(test("bcdef", relaxed[repeat(3, 5)[r]], v2)); + BOOST_TEST(test("bcd", relaxed[repeat(3, 5)[r]], v3)); + BOOST_TEST(!test("", relaxed[repeat(4, 5)[r]], v3)); + BOOST_TEST(!test("", strict[repeat(3, 5)[r]], v2)); + BOOST_TEST(!test("", strict[repeat(3, 5)[r]], v3)); + BOOST_TEST(!test("", strict[repeat(4, 5)[r]], v3)); + + BOOST_TEST(test("bcd", repeat(3, inf)[r], v3)); + BOOST_TEST(test("bcdefg", repeat(3, inf)[r], v2)); + BOOST_TEST(!test("", repeat(4, inf)[r], v3)); + + r = !char_('g') << char_; + BOOST_TEST(test("abcde", repeat(3, 5)[r], v2)); + BOOST_TEST(test("abcd", repeat(3, 5)[r], v3)); + BOOST_TEST(!test("", repeat(4, 5)[r], v3)); + BOOST_TEST(test("abcde", relaxed[repeat(3, 5)[r]], v2)); + BOOST_TEST(test("abcd", relaxed[repeat(3, 5)[r]], v3)); + BOOST_TEST(!test("", relaxed[repeat(4, 5)[r]], v3)); + BOOST_TEST(test("abcde", strict[repeat(3, 5)[r]], v2)); + BOOST_TEST(test("abcd", strict[repeat(3, 5)[r]], v3)); + BOOST_TEST(!test("", strict[repeat(5)[r]], v3)); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/right_alignment.cpp b/src/boost/libs/spirit/test/karma/right_alignment.cpp new file mode 100644 index 00000000..ba505b66 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/right_alignment.cpp @@ -0,0 +1,74 @@ +// Copyright (c) 2001-2011 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) + +#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_directive.hpp> +#include <boost/spirit/include/karma_upper_lower_case.hpp> + +#include "test.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace spirit_test; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + BOOST_TEST(test(" x", right_align[char_('x')])); + BOOST_TEST(test(" x", right_align[char_], 'x')); + BOOST_TEST(test(" x", right_align['x'])); + + BOOST_TEST(test(" x", right_align(10)[char_('x')])); + BOOST_TEST(test(" x", right_align(10)[char_], 'x')); + BOOST_TEST(test(" x", right_align(10)['x'])); + + BOOST_TEST(test("*********x", right_align(10, char_('*'))[char_('x')])); + BOOST_TEST(test("*********x", right_align(10, '*')[char_], 'x')); + BOOST_TEST(test("*********x", right_align(10, '*')['x'])); + BOOST_TEST(test("aaaaaaaaax", lower[right_align(10, 'A')['X']])); + BOOST_TEST(test("AAAAAAAAAX", upper[right_align(10, 'a')['x']])); + + BOOST_TEST(test("*********x", right_align(char_('*'))[char_('x')])); + BOOST_TEST(test("*********x", right_align(char_('*'))[char_], 'x')); + BOOST_TEST(test("*********x", right_align(char_('*'))['x'])); + + BOOST_TEST(test(" abc", right_align[lit("abc")])); + BOOST_TEST(test(" abc", right_align[string], "abc")); + + BOOST_TEST(test(" abc", right_align(10)[lit("abc")])); + BOOST_TEST(test(" abc", right_align(10)[string], "abc")); + BOOST_TEST(test(" abc", right_align(10)["abc"])); + + BOOST_TEST(test("*******abc", right_align(10, char_('*'))[lit("abc")])); + BOOST_TEST(test("*******abc", right_align(10, '*')[string], "abc")); + BOOST_TEST(test("*******abc", right_align(10, '*')["abc"])); + + BOOST_TEST(test("*******abc", right_align(char_('*'))[lit("abc")])); + BOOST_TEST(test("*******abc", right_align(char_('*'))[string], "abc")); + BOOST_TEST(test("*******abc", right_align(char_('*'))["abc"])); + + BOOST_TEST(test(" 100", right_align[int_(100)])); + BOOST_TEST(test(" 100", right_align[int_], 100)); + + BOOST_TEST(test(" 100", right_align(10)[int_(100)])); + BOOST_TEST(test(" 100", right_align(10)[int_], 100)); + + BOOST_TEST(test("*******100", right_align(10, char_('*'))[int_(100)])); + BOOST_TEST(test("*******100", right_align(10, '*')[int_], 100)); + + BOOST_TEST(test("*******100", right_align(char_('*'))[int_(100)])); + BOOST_TEST(test("*******100", right_align(char_('*'))[int_], 100)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/rule_fail.cpp b/src/boost/libs/spirit/test/karma/rule_fail.cpp new file mode 100644 index 00000000..36143416 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/rule_fail.cpp @@ -0,0 +1,36 @@ +/*============================================================================= + Copyright (c) 2001-2011 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) +=============================================================================*/ + +#include <boost/config/warning_disable.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_numeric.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/function_output_iterator.hpp> + +#include "test.hpp" + +using namespace boost::spirit; +using namespace boost::spirit::ascii; + +// this test must fail compiling as the rule is used with an incompatible +// delimiter type +int main() +{ + typedef spirit_test::output_iterator<char>::type outiter_type; + + std::string generated; + + karma::rule<outiter_type, karma::rule<outiter_type> > def; + def = int_(1) << ',' << int_(0); + + std::back_insert_iterator<std::string> outit(generated); + generate_delimited(outit, def, char_('%') << '\n'); + + return 0; +} diff --git a/src/boost/libs/spirit/test/karma/sequence1.cpp b/src/boost/libs/spirit/test/karma/sequence1.cpp new file mode 100644 index 00000000..e35efe80 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/sequence1.cpp @@ -0,0 +1,140 @@ +// Copyright (c) 2001-2011 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) + +#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/fusion/include/vector.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +/////////////////////////////////////////////////////////////////////////////// +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(' '))); + } + + return boost::report_errors(); +} + diff --git a/src/boost/libs/spirit/test/karma/sequence2.cpp b/src/boost/libs/spirit/test/karma/sequence2.cpp new file mode 100644 index 00000000..926d2487 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/sequence2.cpp @@ -0,0 +1,183 @@ +// Copyright (c) 2001-2011 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) + +#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_function.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 This, typename Sequence> + struct result<This(Sequence)> + : result<typename boost::proto::detail::uncvref<Sequence>::type> + {}; + + 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; + + { + 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(); +} + diff --git a/src/boost/libs/spirit/test/karma/stream.cpp b/src/boost/libs/spirit/test/karma/stream.cpp new file mode 100644 index 00000000..36ab6e6c --- /dev/null +++ b/src/boost/libs/spirit/test/karma/stream.cpp @@ -0,0 +1,134 @@ +// Copyright (c) 2001-2011 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) + +#include <cwchar> +#include <streambuf> +#include <iostream> + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/cstdint.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_stream.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +// a simple complex number representation z = a + bi +struct complex +{ + complex (double a, double b) + : a(a), b(b) + {} + + double a; + double b; + + template <typename Char> + friend std::basic_ostream<Char>& + operator<< (std::basic_ostream<Char>& os, complex z) + { + os << "{" << z.a << "," << z.b << "}"; + return os; + } +}; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { + BOOST_TEST(test("x", stream, 'x')); + BOOST_TEST(test("xyz", stream, "xyz")); + BOOST_TEST(test("xyz", stream, std::string("xyz"))); + BOOST_TEST(test("1", stream, 1)); + BOOST_TEST(test("1.1", stream, 1.1)); + BOOST_TEST(test("{1.2,2.4}", stream, complex(1.2, 2.4))); + } + + { + BOOST_TEST(test("x", stream('x'))); + BOOST_TEST(test("xyz", stream("xyz"))); + BOOST_TEST(test("xyz", stream(std::string("xyz")))); + BOOST_TEST(test("1", stream(1))); + BOOST_TEST(test("1.1", stream(1.1))); + BOOST_TEST(test("{1.2,2.4}", stream(complex(1.2, 2.4)))); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test("x", lower[stream], 'X')); + BOOST_TEST(test("xyz", lower[stream], "XYZ")); + BOOST_TEST(test("xyz", lower[stream], std::string("XYZ"))); + BOOST_TEST(test("X", upper[stream], 'x')); + BOOST_TEST(test("XYZ", upper[stream], "xyz")); + BOOST_TEST(test("XYZ", upper[stream], std::string("xyz"))); + } + + { + BOOST_TEST(test_delimited("x ", stream, 'x', ' ')); + BOOST_TEST(test_delimited("xyz ", stream, "xyz", ' ')); + BOOST_TEST(test_delimited("xyz ", stream, std::string("xyz"), ' ')); + BOOST_TEST(test_delimited("1 ", stream, 1, ' ')); + BOOST_TEST(test_delimited("1.1 ", stream, 1.1, ' ')); + BOOST_TEST(test_delimited("{1.2,2.4} ", stream, complex(1.2, 2.4), ' ')); + } + + { + typedef karma::stream_generator<utf8_char> utf8_stream_type; + utf8_stream_type const utf8_stream = utf8_stream_type(); + + BOOST_TEST(test_delimited("x ", utf8_stream, 'x', ' ')); + BOOST_TEST(test_delimited("xyz ", utf8_stream, "xyz", ' ')); + BOOST_TEST(test_delimited("xyz ", utf8_stream, std::string("xyz"), ' ')); + BOOST_TEST(test_delimited("1 ", utf8_stream, 1, ' ')); + BOOST_TEST(test_delimited("1.1 ", utf8_stream, 1.1, ' ')); + BOOST_TEST(test_delimited("{1.2,2.4} ", utf8_stream, complex(1.2, 2.4), ' ')); + + BOOST_TEST(test("x", utf8_stream('x'))); + BOOST_TEST(test("xyz", utf8_stream("xyz"))); + BOOST_TEST(test("xyz", utf8_stream(std::string("xyz")))); + BOOST_TEST(test("1", utf8_stream(1))); + BOOST_TEST(test("1.1", utf8_stream(1.1))); + BOOST_TEST(test("{1.2,2.4}", utf8_stream(complex(1.2, 2.4)))); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test_delimited("x ", lower[stream], 'X', ' ')); + BOOST_TEST(test_delimited("xyz ", lower[stream], "XYZ", ' ')); + BOOST_TEST(test_delimited("xyz ", lower[stream], std::string("XYZ"), ' ')); + BOOST_TEST(test_delimited("X ", upper[stream], 'x', ' ')); + BOOST_TEST(test_delimited("XYZ ", upper[stream], "xyz", ' ')); + BOOST_TEST(test_delimited("XYZ ", upper[stream], std::string("xyz"), ' ')); + } + + { // lazy streams + namespace phx = boost::phoenix; + + std::basic_string<char> s("abc"); + BOOST_TEST((test("abc", stream(phx::val(s))))); + BOOST_TEST((test("abc", stream(phx::ref(s))))); + } + + { + boost::optional<char> c; + BOOST_TEST(!test("", stream, c)); + c = 'x'; + BOOST_TEST(test("x", stream, c)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/symbols1.cpp b/src/boost/libs/spirit/test/karma/symbols1.cpp new file mode 100644 index 00000000..0fcea278 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/symbols1.cpp @@ -0,0 +1,106 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> + +#include <boost/core/lightweight_test.hpp> +#include <boost/core/lightweight_test_trait.hpp> + +#include "test.hpp" + +namespace fusion = boost::fusion; + +template <typename T> +inline std::vector<T> +make_vector(T const& t1, T const& t2) +{ + std::vector<T> v; + v.push_back(t1); + v.push_back(t2); + return v; +} + +int main() +{ + using spirit_test::test; + using boost::spirit::karma::symbols; + + { // basics + symbols<char, std::string> sym; + + sym.add + ('j', "Joel") + ('h', "Hartmut") + ('t', "Tom") + ('k', "Kim") + ; + + BOOST_TEST_TRAIT_TRUE(( + boost::spirit::traits::is_generator< + symbols<char, std::string> >)); + + BOOST_TEST((test("Joel", sym, 'j'))); + BOOST_TEST((test("Hartmut", sym, 'h'))); + BOOST_TEST((test("Tom", sym, 't'))); + BOOST_TEST((test("Kim", sym, 'k'))); + BOOST_TEST((!test("", sym, 'x'))); + + // test copy + symbols<char, std::string> sym2; + sym2 = sym; + BOOST_TEST((test("Joel", sym2, 'j'))); + BOOST_TEST((test("Hartmut", sym2, 'h'))); + BOOST_TEST((test("Tom", sym2, 't'))); + BOOST_TEST((test("Kim", sym2, 'k'))); + BOOST_TEST((!test("", sym2, 'x'))); + + // make sure it plays well with other generators + BOOST_TEST((test("Joelyo", sym << "yo", 'j'))); + + sym.remove + ('j') + ('h') + ; + + BOOST_TEST((!test("", sym, 'j'))); + BOOST_TEST((!test("", sym, 'h'))); + } + + { // lower/upper handling + using namespace boost::spirit::ascii; + using boost::spirit::karma::lower; + using boost::spirit::karma::upper; + + symbols<char, std::string> sym; + sym.add + ('j', "Joel") + ('h', "Hartmut") + ('t', "Tom") + ('k', "Kim") + ; + + BOOST_TEST((test("joel", lower[sym], 'j'))); + BOOST_TEST((test("hartmut", lower[sym], 'h'))); + BOOST_TEST((test("tom", lower[sym], 't'))); + BOOST_TEST((test("kim", lower[sym], 'k'))); + + BOOST_TEST((test("JOEL", upper[sym], 'j'))); + BOOST_TEST((test("HARTMUT", upper[sym], 'h'))); + BOOST_TEST((test("TOM", upper[sym], 't'))); + BOOST_TEST((test("KIM", upper[sym], 'k'))); + + // make sure it plays well with other generators + BOOST_TEST((test("joelyo", lower[sym] << "yo", 'j'))); + BOOST_TEST((test("JOELyo", upper[sym] << "yo", 'j'))); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/symbols2.cpp b/src/boost/libs/spirit/test/karma/symbols2.cpp new file mode 100644 index 00000000..e2fdcd53 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/symbols2.cpp @@ -0,0 +1,146 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> + +#include <boost/core/lightweight_test.hpp> +#include <boost/core/lightweight_test_trait.hpp> + +#include "test.hpp" + +namespace fusion = boost::fusion; + +template <typename T> +inline std::vector<T> +make_vector(T const& t1, T const& t2) +{ + std::vector<T> v; + v.push_back(t1); + v.push_back(t2); + return v; +} + +int main() +{ + using spirit_test::test; + using boost::spirit::karma::symbols; + + { // advanced + using boost::spirit::karma::rule; + using boost::spirit::karma::lit; + + typedef spirit_test::output_iterator<char>::type output_iterator_type; + + symbols<char, rule<output_iterator_type> > sym; + + rule<output_iterator_type> r1 = lit("Joel"); + rule<output_iterator_type> r2 = lit("Hartmut"); + rule<output_iterator_type> r3 = lit("Tom"); + rule<output_iterator_type> r4 = lit("Kim"); + + sym.add + ('j', r1.alias()) + ('h', r2.alias()) + ('t', r3.alias()) + ('k', r4.alias()) + ; + + BOOST_TEST_TRAIT_TRUE(( + boost::spirit::traits::is_generator< + symbols<char, rule<output_iterator_type> > >)); + + BOOST_TEST((test("Joel", sym, 'j'))); + BOOST_TEST((test("Hartmut", sym, 'h'))); + BOOST_TEST((test("Tom", sym, 't'))); + BOOST_TEST((test("Kim", sym, 'k'))); + BOOST_TEST((!test("", sym, 'x'))); + + // test copy + symbols<char, rule<output_iterator_type> > sym2; + sym2 = sym; + BOOST_TEST((test("Joel", sym2, 'j'))); + BOOST_TEST((test("Hartmut", sym2, 'h'))); + BOOST_TEST((test("Tom", sym2, 't'))); + BOOST_TEST((test("Kim", sym2, 'k'))); + BOOST_TEST((!test("", sym2, 'x'))); + + // make sure it plays well with other generators + BOOST_TEST((test("Joelyo", sym << "yo", 'j'))); + + sym.remove + ('j') + ('h') + ; + + BOOST_TEST((!test("", sym, 'j'))); + BOOST_TEST((!test("", sym, 'h'))); + } + + { // more advanced + using boost::spirit::karma::rule; + using boost::spirit::karma::lit; + using boost::spirit::karma::string; + + typedef spirit_test::output_iterator<char>::type output_iterator_type; + + symbols<char, rule<output_iterator_type, std::string()> > sym; + rule<output_iterator_type, std::string()> r1 = string; + + sym.add + ('j', r1.alias()) + ('h', r1.alias()) + ('t', r1.alias()) + ('k', r1.alias()) + ; + + BOOST_TEST_TRAIT_TRUE(( + boost::spirit::traits::is_generator< + symbols<char, std::string> >)); + + BOOST_TEST((test("Joel", sym, fusion::make_vector('j', "Joel")))); + BOOST_TEST((test("Hartmut", sym, fusion::make_vector('h', "Hartmut")))); + BOOST_TEST((test("Tom", sym, fusion::make_vector('t', "Tom")))); + BOOST_TEST((test("Kim", sym, fusion::make_vector('k', "Kim")))); + BOOST_TEST((!test("", sym, 'x'))); + + // test copy + symbols<char, rule<output_iterator_type, std::string()> > sym2; + sym2 = sym; + BOOST_TEST((test("Joel", sym2, fusion::make_vector('j', "Joel")))); + BOOST_TEST((test("Hartmut", sym2, fusion::make_vector('h', "Hartmut")))); + BOOST_TEST((test("Tom", sym2, fusion::make_vector('t', "Tom")))); + BOOST_TEST((test("Kim", sym2, fusion::make_vector('k', "Kim")))); + BOOST_TEST((!test("", sym2, 'x'))); + + // make sure it plays well with other generators + BOOST_TEST((test("Joelyo", sym << "yo", fusion::make_vector('j', "Joel")))); + + sym.remove + ('j') + ('h') + ; + + BOOST_TEST((!test("", sym, 'j'))); + BOOST_TEST((!test("", sym, 'h'))); + } + + { // test for proto problem with rvalue references (10-11-2011) + symbols<char, std::string> sym; + + sym += std::make_pair('j', "Joel"); + sym += std::make_pair('h', "Hartmut"); + + BOOST_TEST((test("Joel", sym, 'j'))); + BOOST_TEST((test("Hartmut", sym, 'h'))); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/symbols3.cpp b/src/boost/libs/spirit/test/karma/symbols3.cpp new file mode 100644 index 00000000..fd07dbf5 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/symbols3.cpp @@ -0,0 +1,139 @@ +// Copyright (c) 2001-2011 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) + +#include <boost/spirit/include/karma_auxiliary.hpp> +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_operator.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_nonterminal.hpp> + +#include <boost/core/lightweight_test.hpp> +#include <boost/core/lightweight_test_trait.hpp> + +#include "test.hpp" + +namespace fusion = boost::fusion; + +template <typename T> +inline std::vector<T> +make_vector(T const& t1, T const& t2) +{ + std::vector<T> v; + v.push_back(t1); + v.push_back(t2); + return v; +} + +int main() +{ + using spirit_test::test; + using boost::spirit::karma::symbols; + + { // more advanced + using boost::spirit::karma::rule; + using boost::spirit::karma::lit; + using boost::spirit::karma::char_; + + typedef spirit_test::output_iterator<char>::type output_iterator_type; + + symbols<char, rule<output_iterator_type, char()> > sym; + rule<output_iterator_type, char()> r1 = char_; + + sym.add + ('j', r1.alias()) + ('h', r1.alias()) + ('t', r1.alias()) + ('k', r1.alias()) + ; + + BOOST_TEST_TRAIT_TRUE(( + boost::spirit::traits::is_generator< + symbols<char, rule<output_iterator_type, char()> > >)); + + BOOST_TEST((test("J", sym, make_vector('j', 'J')))); + BOOST_TEST((test("H", sym, make_vector('h', 'H')))); + BOOST_TEST((test("T", sym, make_vector('t', 'T')))); + BOOST_TEST((test("K", sym, make_vector('k', 'K')))); + BOOST_TEST((!test("", sym, 'x'))); + + // test copy + symbols<char, rule<output_iterator_type, char()> > sym2; + sym2 = sym; + BOOST_TEST((test("J", sym2, make_vector('j', 'J')))); + BOOST_TEST((test("H", sym2, make_vector('h', 'H')))); + BOOST_TEST((test("T", sym2, make_vector('t', 'T')))); + BOOST_TEST((test("K", sym2, make_vector('k', 'K')))); + BOOST_TEST((!test("", sym2, 'x'))); + + // make sure it plays well with other generators + BOOST_TEST((test("Jyo", sym << "yo", make_vector('j', 'J')))); + + sym.remove + ('j') + ('h') + ; + + BOOST_TEST((!test("", sym, 'j'))); + BOOST_TEST((!test("", sym, 'h'))); + } + + { // basics + symbols<std::string> sym; + + sym.add + ("Joel") + ("Hartmut") + ("Tom") + ("Kim") + ; + + BOOST_TEST_TRAIT_TRUE(( + boost::spirit::traits::is_generator< + symbols<char, std::string> >)); + + BOOST_TEST((test("Joel", sym, "Joel"))); + BOOST_TEST((test("Hartmut", sym, "Hartmut"))); + BOOST_TEST((test("Tom", sym, "Tom"))); + BOOST_TEST((test("Kim", sym, "Kim"))); + BOOST_TEST((!test("", sym, "X"))); + + // test copy + symbols<std::string> sym2; + sym2 = sym; + BOOST_TEST((test("Joel", sym2, "Joel"))); + BOOST_TEST((test("Hartmut", sym2, "Hartmut"))); + BOOST_TEST((test("Tom", sym2, "Tom"))); + BOOST_TEST((test("Kim", sym2, "Kim"))); + BOOST_TEST((!test("", sym2, "X"))); + + // make sure it plays well with other generators + BOOST_TEST((test("Joelyo", sym << "yo", "Joel"))); + + sym.remove + ("Joel") + ("Hartmut") + ; + + BOOST_TEST((!test("", sym, "Joel"))); + BOOST_TEST((!test("", sym, "Hartmut"))); + } + + { // name + symbols <std::string> sym("test1"), sym2; + BOOST_TEST(sym.name() == "test1"); + + sym.name("test"); + BOOST_TEST(sym.name() == "test"); + sym2 = sym; + BOOST_TEST(sym2.name() == "test"); + + symbols <std::string> sym3(sym); + BOOST_TEST(sym3.name() == "test"); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/test.hpp b/src/boost/libs/spirit/test/karma/test.hpp new file mode 100644 index 00000000..be6ac500 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/test.hpp @@ -0,0 +1,328 @@ +// Copyright (c) 2001-2011 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) + +#if !defined(BOOST_SPIRIT_KARMA_TEST_FEB_23_2007_1221PM) +#define BOOST_SPIRIT_KARMA_TEST_FEB_23_2007_1221PM + +#include <cstring> +#include <string> +#include <iterator> +#include <iostream> +#include <iomanip> +#include <typeinfo> + +#include <boost/foreach.hpp> +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_what.hpp> + +namespace spirit_test +{ + /////////////////////////////////////////////////////////////////////////// + struct display_type + { + template<typename T> + void operator()(T const &) const + { + std::cout << typeid(T).name() << std::endl; + } + + template<typename T> + static void print() + { + std::cout << typeid(T).name() << std::endl; + } + }; + + display_type const display = {}; + + /////////////////////////////////////////////////////////////////////////// + template <typename Char> + struct output_iterator + { + typedef std::basic_string<Char> string_type; + typedef std::back_insert_iterator<string_type> type; + }; + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename T> + void print_if_failed(char const* func, bool result + , std::basic_string<Char> const& generated, T const& expected) + { + if (!result) + std::cerr << "in " << func << ": result is false" << std::endl; + else if (generated != expected) + std::cerr << "in " << func << ": generated \"" + << std::string(generated.begin(), generated.end()) + << "\"" << std::endl; + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename T> + void print_binary_if_failed(char const* func, bool result + , std::basic_string<Char> const& generated, T const& expected) + { + if (!result) + std::cerr << "in " << func << ": result is false" << std::endl; + else if (generated.size() != expected.size() || + std::memcmp(generated.c_str(), expected.c_str(), generated.size())) + { + std::cerr << "in " << func << ": generated \""; + BOOST_FOREACH(int c, generated) + std::cerr << "\\x" << std::hex << std::setfill('0') << std::setw(2) << c; + std::cerr << "\"" << std::endl; + } + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator> + inline bool test(Char const *expected, Generator const& g) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate(outit, g); + + print_if_failed("test", result, generated, expected); + return result && generated == expected; + } + + template <typename Char, typename Generator> + inline bool test(std::basic_string<Char> const& expected, Generator const& g) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate(outit, g); + + print_if_failed("test", result, generated, expected); + return result && generated == expected; + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator, typename Attribute> + inline bool test(Char const *expected, Generator const& g, + Attribute const &attrib) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate(outit, g, attrib); + + print_if_failed("test", result, generated, expected); + return result && generated == expected; + } + + template <typename Char, typename Generator, typename Attribute> + inline bool test(std::basic_string<Char> const& expected, Generator const& g, + Attribute const &attrib) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate(outit, g, attrib); + + print_if_failed("test", result, generated, expected); + return result && generated == expected; + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator, typename Delimiter> + inline bool test_delimited(Char const *expected, Generator const& g, + Delimiter const& d) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate_delimited(outit, g, d); + + print_if_failed("test_delimited", result, generated, expected); + return result && generated == expected; + } + + template <typename Char, typename Generator, typename Delimiter> + inline bool test_delimited(std::basic_string<Char> const& expected, + Generator const& g, Delimiter const& d) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate_delimited(outit, g, d); + + print_if_failed("test_delimited", result, generated, expected); + return result && generated == expected; + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator, typename Attribute, + typename Delimiter> + inline bool test_delimited(Char const *expected, Generator const& g, + Attribute const &attrib, Delimiter const& d) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate_delimited(outit, g, d, attrib); + + print_if_failed("test_delimited", result, generated, expected); + return result && generated == expected; + } + + template <typename Char, typename Generator, typename Attribute, + typename Delimiter> + inline bool test_delimited(std::basic_string<Char> const& expected, + Generator const& g, Attribute const &attrib, Delimiter const& d) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate_delimited(outit, g, d, attrib); + + print_if_failed("test_delimited", result, generated, expected); + return result && generated == expected; + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Generator> + inline bool + binary_test(char const *expected, std::size_t size, + Generator const& g) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate(outit, g); + + print_binary_if_failed("binary_test", result, generated + , std::string(expected, size)); + return result && generated.size() == size + && !std::memcmp(generated.c_str(), expected, size); + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Generator, typename Attribute> + inline bool + binary_test(char const *expected, std::size_t size, + Generator const& g, Attribute const &attrib) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate(outit, g, attrib); + + print_binary_if_failed("binary_test", result, generated + , std::string(expected, size)); + return result && generated.size() == size + && !std::memcmp(generated.c_str(), expected, size); + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Generator, typename Delimiter> + inline bool + binary_test_delimited(char const *expected, std::size_t size, + Generator const& g, Delimiter const& d) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate_delimited(outit, g, d); + + print_binary_if_failed("binary_test_delimited", result, generated + , std::string(expected, size)); + return result && generated.size() == size + && !std::memcmp(generated.c_str(), expected, size); + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Generator, typename Attribute, typename Delimiter> + inline bool + binary_test_delimited(char const *expected, std::size_t size, + Generator const& g, Attribute const &attrib, Delimiter const& d) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate_delimited(outit, g, d, attrib); + + print_binary_if_failed("binary_test_delimited", result, generated + , std::string(expected, size)); + return result && generated.size() == size + && !std::memcmp(generated.c_str(), expected, size); + } + +} // namespace spirit_test + +#endif // !BOOST_SPIRIT_KARMA_TEST_FEB_23_2007_1221PM diff --git a/src/boost/libs/spirit/test/karma/test_attr.hpp b/src/boost/libs/spirit/test/karma/test_attr.hpp new file mode 100644 index 00000000..ad0f0441 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/test_attr.hpp @@ -0,0 +1,137 @@ +// Copyright (c) 2001-2011 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) + +#if !defined(BOOST_PP_IS_ITERATING) + +#if !defined(BOOST_SPIRIT_KARMA_TEST_ATTR_APR_23_2009_0605PM) +#define BOOST_SPIRIT_KARMA_TEST_ATTR_APR_23_2009_0605PM + +#include <cstring> +#include <string> +#include <iterator> +#include <iostream> +#include <typeinfo> + +#include <boost/spirit/include/karma_generate.hpp> +#include <boost/spirit/include/karma_what.hpp> + +#include <boost/preprocessor/iterate.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> + +namespace spirit_test +{ + /////////////////////////////////////////////////////////////////////////// + template <typename Char> + struct output_iterator + { + typedef std::basic_string<Char> string_type; + typedef std::back_insert_iterator<string_type> type; + }; + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename T> + void print_if_failed(char const* func, bool result + , std::basic_string<Char> const& generated, T const& expected) + { + if (!result) + std::cerr << "in " << func << ": result is false" << std::endl; + else if (generated != expected) + std::cerr << "in " << func << ": generated \"" + << std::string(generated.begin(), generated.end()) + << "\"" << std::endl; + } +} + +#define BOOST_PP_FILENAME_1 "test_attr.hpp" +#define BOOST_PP_ITERATION_LIMITS (1, SPIRIT_ARGUMENTS_LIMIT) +#include BOOST_PP_ITERATE() + +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Preprocessor vertical repetition code +// +/////////////////////////////////////////////////////////////////////////////// +#else // defined(BOOST_PP_IS_ITERATING) + +#define N BOOST_PP_ITERATION() + +namespace spirit_test +{ + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator + , BOOST_PP_ENUM_PARAMS(N, typename A)> + inline bool test(Char const *expected, Generator const& g + , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr)) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate(outit, g, BOOST_PP_ENUM_PARAMS(N, attr)); + + print_if_failed("test", result, generated, expected); + return result && generated == expected; + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator, typename Delimiter + , BOOST_PP_ENUM_PARAMS(N, typename A)> + inline bool test_delimited(Char const *expected, Generator const& g + , Delimiter const& d, BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr)) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate_delimited(outit, g, d + , BOOST_PP_ENUM_PARAMS(N, attr)); + + print_if_failed("test_delimited", result, generated, expected); + return result && generated == expected; + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator, typename Delimiter + , BOOST_PP_ENUM_PARAMS(N, typename A)> + inline bool test_predelimited(Char const *expected, Generator const& g + , Delimiter const& d + , BOOST_SCOPED_ENUM(boost::spirit::karma::delimit_flag) pre_delimit + , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr)) + { + namespace karma = boost::spirit::karma; + typedef std::basic_string<Char> string_type; + + // we don't care about the result of the "what" function. + // we only care that all generators have it: + karma::what(g); + + string_type generated; + std::back_insert_iterator<string_type> outit(generated); + bool result = karma::generate_delimited(outit, g, d + , pre_delimit, BOOST_PP_ENUM_PARAMS(N, attr)); + + print_if_failed("test_predelimited", result, generated, expected); + return result && generated == expected; + } + +} // namespace spirit_test + +#undef N + +#endif diff --git a/src/boost/libs/spirit/test/karma/test_manip_attr.hpp b/src/boost/libs/spirit/test/karma/test_manip_attr.hpp new file mode 100644 index 00000000..4b8e7be0 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/test_manip_attr.hpp @@ -0,0 +1,109 @@ +// Copyright (c) 2001-2011 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) + +#if !defined(BOOST_PP_IS_ITERATING) + +#if !defined(BOOST_SPIRIT_KARMA_TEST_MANIP_ATTR_APR_24_2009_0834AM) +#define BOOST_SPIRIT_KARMA_TEST_MANIP_ATTR_APR_24_2009_0834AM + +#include <cstring> +#include <string> +#include <iterator> +#include <iostream> +#include <typeinfo> + +#include <boost/spirit/include/karma_stream.hpp> + +#include <boost/preprocessor/iterate.hpp> +#include <boost/preprocessor/repetition/enum.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> + +namespace spirit_test +{ + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename T> + void print_if_failed(char const* func, bool result + , std::basic_string<Char> const& generated, T const& expected) + { + if (!result) + std::cerr << "in " << func << ": result is false" << std::endl; + else if (generated != expected) + std::cerr << "in " << func << ": generated \"" + << std::string(generated.begin(), generated.end()) + << "\"" << std::endl; + } +} + +#define BOOST_PP_FILENAME_1 "test_manip_attr.hpp" +#define BOOST_PP_ITERATION_LIMITS (1, SPIRIT_ARGUMENTS_LIMIT) +#include BOOST_PP_ITERATE() + +#endif + +/////////////////////////////////////////////////////////////////////////////// +// +// Preprocessor vertical repetition code +// +/////////////////////////////////////////////////////////////////////////////// +#else // defined(BOOST_PP_IS_ITERATING) + +#define N BOOST_PP_ITERATION() + +namespace spirit_test +{ + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator + , BOOST_PP_ENUM_PARAMS(N, typename A)> + inline bool test(Char const *expected, Generator const& g + , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr)) + { + namespace karma = boost::spirit::karma; + + std::ostringstream ostrm; + ostrm << karma::format(g, BOOST_PP_ENUM_PARAMS(N, attr)); + + print_if_failed("test", ostrm.good(), ostrm.str(), expected); + return ostrm.good() && ostrm.str() == expected; + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator, typename Delimiter + , BOOST_PP_ENUM_PARAMS(N, typename A)> + inline bool test_delimited(Char const *expected, Generator const& g + , Delimiter const& d, BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr)) + { + namespace karma = boost::spirit::karma; + + std::ostringstream ostrm; + ostrm << karma::format_delimited(g, d, BOOST_PP_ENUM_PARAMS(N, attr)); + + print_if_failed("test_delimited", ostrm.good(), ostrm.str(), expected); + return ostrm.good() && ostrm.str() == expected; + } + + /////////////////////////////////////////////////////////////////////////// + template <typename Char, typename Generator, typename Delimiter + , BOOST_PP_ENUM_PARAMS(N, typename A)> + inline bool test_predelimited(Char const *expected, Generator const& g + , Delimiter const& d + , BOOST_SCOPED_ENUM(boost::spirit::karma::delimit_flag) pre_delimit + , BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& attr)) + { + namespace karma = boost::spirit::karma; + + std::ostringstream ostrm; + ostrm << karma::format_delimited(g, d, pre_delimit + , BOOST_PP_ENUM_PARAMS(N, attr)); + + print_if_failed("test_predelimited", ostrm.good(), ostrm.str(), expected); + return ostrm.good() && ostrm.str() == expected; + } + +} // namespace spirit_test + +#undef N + +#endif diff --git a/src/boost/libs/spirit/test/karma/tricky_alignment.cpp b/src/boost/libs/spirit/test/karma/tricky_alignment.cpp new file mode 100644 index 00000000..f851f9d6 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/tricky_alignment.cpp @@ -0,0 +1,130 @@ +// Copyright (c) 2001-2011 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) + +#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_directive.hpp> + +#include "test.hpp" + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace spirit_test; + using namespace boost::spirit; + using namespace boost::spirit::ascii; + + { + BOOST_TEST(test("x *****", left_align(15, '*')[left_align[char_('x')]])); + BOOST_TEST(test(" x *****", left_align(15, '*')[center[char_('x')]])); + BOOST_TEST(test(" x*****", left_align(15, '*')[right_align[char_('x')]])); + + BOOST_TEST(test("*****x ", right_align(15, '*')[left_align[char_('x')]])); + BOOST_TEST(test("***** x ", right_align(15, '*')[center[char_('x')]])); + BOOST_TEST(test("***** x", right_align(15, '*')[right_align[char_('x')]])); + + BOOST_TEST(test("***x **", center(15, '*')[left_align[char_('x')]])); + BOOST_TEST(test("*** x **", center(15, '*')[center[char_('x')]])); + BOOST_TEST(test("*** x**", center(15, '*')[right_align[char_('x')]])); + + BOOST_TEST(test("ab *****", left_align(15, '*')[left_align[lit("ab")]])); + BOOST_TEST(test(" ab *****", left_align(15, '*')[center[lit("ab")]])); + BOOST_TEST(test(" ab*****", left_align(15, '*')[right_align[lit("ab")]])); + + BOOST_TEST(test("*****ab ", right_align(15, '*')[left_align[lit("ab")]])); + BOOST_TEST(test("***** ab ", right_align(15, '*')[center[lit("ab")]])); + BOOST_TEST(test("***** ab", right_align(15, '*')[right_align[lit("ab")]])); + + BOOST_TEST(test("***ab **", center(15, '*')[left_align[lit("ab")]])); + BOOST_TEST(test("*** ab **", center(15, '*')[center[lit("ab")]])); + BOOST_TEST(test("*** ab**", center(15, '*')[right_align[lit("ab")]])); + } + + { + BOOST_TEST(test("x ******", left_align(16, '*')[left_align[char_('x')]])); + BOOST_TEST(test(" x ******", left_align(16, '*')[center[char_('x')]])); + BOOST_TEST(test(" x******", left_align(16, '*')[right_align[char_('x')]])); + + BOOST_TEST(test("******x ", right_align(16, '*')[left_align[char_('x')]])); + BOOST_TEST(test("****** x ", right_align(16, '*')[center[char_('x')]])); + BOOST_TEST(test("****** x", right_align(16, '*')[right_align[char_('x')]])); + + BOOST_TEST(test("***x ***", center(16, '*')[left_align[char_('x')]])); + BOOST_TEST(test("*** x ***", center(16, '*')[center[char_('x')]])); + BOOST_TEST(test("*** x***", center(16, '*')[right_align[char_('x')]])); + + BOOST_TEST(test("ab ******", left_align(16, '*')[left_align[lit("ab")]])); + BOOST_TEST(test(" ab ******", left_align(16, '*')[center[lit("ab")]])); + BOOST_TEST(test(" ab******", left_align(16, '*')[right_align[lit("ab")]])); + + BOOST_TEST(test("******ab ", right_align(16, '*')[left_align[lit("ab")]])); + BOOST_TEST(test("****** ab ", right_align(16, '*')[center[lit("ab")]])); + BOOST_TEST(test("****** ab", right_align(16, '*')[right_align[lit("ab")]])); + + BOOST_TEST(test("***ab ***", center(16, '*')[left_align[lit("ab")]])); + BOOST_TEST(test("*** ab ***", center(16, '*')[center[lit("ab")]])); + BOOST_TEST(test("*** ab***", center(16, '*')[right_align[lit("ab")]])); + } + + { + BOOST_TEST(test("x ****", left_align(15, '*')[left_align(11)[char_('x')]])); + BOOST_TEST(test(" x ****", left_align(15, '*')[center(11)[char_('x')]])); + BOOST_TEST(test(" x****", left_align(15, '*')[right_align(11)[char_('x')]])); + + BOOST_TEST(test("****x ", right_align(15, '*')[left_align(11)[char_('x')]])); + BOOST_TEST(test("**** x ", right_align(15, '*')[center(11)[char_('x')]])); + BOOST_TEST(test("**** x", right_align(15, '*')[right_align(11)[char_('x')]])); + + BOOST_TEST(test("**x **", center(15, '*')[left_align(11)[char_('x')]])); + BOOST_TEST(test("** x **", center(15, '*')[center(11)[char_('x')]])); + BOOST_TEST(test("** x**", center(15, '*')[right_align(11)[char_('x')]])); + + BOOST_TEST(test("ab ****", left_align(15, '*')[left_align(11)[lit("ab")]])); + BOOST_TEST(test(" ab ****", left_align(15, '*')[center(11)[lit("ab")]])); + BOOST_TEST(test(" ab****", left_align(15, '*')[right_align(11)[lit("ab")]])); + + BOOST_TEST(test("****ab ", right_align(15, '*')[left_align(11)[lit("ab")]])); + BOOST_TEST(test("**** ab ", right_align(15, '*')[center(11)[lit("ab")]])); + BOOST_TEST(test("**** ab", right_align(15, '*')[right_align(11)[lit("ab")]])); + + BOOST_TEST(test("**ab **", center(15, '*')[left_align(11)[lit("ab")]])); + BOOST_TEST(test("** ab **", center(15, '*')[center(11)[lit("ab")]])); + BOOST_TEST(test("** ab**", center(15, '*')[right_align(11)[lit("ab")]])); + } + + { + BOOST_TEST(test("x *****", left_align(16, '*')[left_align(11)[char_('x')]])); + BOOST_TEST(test(" x *****", left_align(16, '*')[center(11)[char_('x')]])); + BOOST_TEST(test(" x*****", left_align(16, '*')[right_align(11)[char_('x')]])); + + BOOST_TEST(test("*****x ", right_align(16, '*')[left_align(11)[char_('x')]])); + BOOST_TEST(test("***** x ", right_align(16, '*')[center(11)[char_('x')]])); + BOOST_TEST(test("***** x", right_align(16, '*')[right_align(11)[char_('x')]])); + + BOOST_TEST(test("***x **", center(16, '*')[left_align(11)[char_('x')]])); + BOOST_TEST(test("*** x **", center(16, '*')[center(11)[char_('x')]])); + BOOST_TEST(test("*** x**", center(16, '*')[right_align(11)[char_('x')]])); + + BOOST_TEST(test("ab *****", left_align(16, '*')[left_align(11)[lit("ab")]])); + BOOST_TEST(test(" ab *****", left_align(16, '*')[center(11)[lit("ab")]])); + BOOST_TEST(test(" ab*****", left_align(16, '*')[right_align(11)[lit("ab")]])); + + BOOST_TEST(test("*****ab ", right_align(16, '*')[left_align(11)[lit("ab")]])); + BOOST_TEST(test("***** ab ", right_align(16, '*')[center(11)[lit("ab")]])); + BOOST_TEST(test("***** ab", right_align(16, '*')[right_align(11)[lit("ab")]])); + + BOOST_TEST(test("***ab **", center(16, '*')[left_align(11)[lit("ab")]])); + BOOST_TEST(test("*** ab **", center(16, '*')[center(11)[lit("ab")]])); + BOOST_TEST(test("*** ab**", center(16, '*')[right_align(11)[lit("ab")]])); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/uint_radix.cpp b/src/boost/libs/spirit/test/karma/uint_radix.cpp new file mode 100644 index 00000000..a39838fb --- /dev/null +++ b/src/boost/libs/spirit/test/karma/uint_radix.cpp @@ -0,0 +1,507 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2011 Jan Frederick Eick +// +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/spirit/include/karma_numeric.hpp> + +#include <boost/cstdint.hpp> + +#include "test.hpp" + +/////////////////////////////////////////////////////////////////////////////// +// +// *** BEWARE PLATFORM DEPENDENT!!! *** +// *** The following assumes 32 bit boost::uint32_tegers. +// *** Modify these constants when appropriate. +// +/////////////////////////////////////////////////////////////////////////////// + +char const* max_unsigned_base2 = "11111111111111111111111111111111"; +char const* max_unsigned_base3 = "102002022201221111210"; +char const* max_unsigned_base4 = "3333333333333333"; +char const* max_unsigned_base5 = "32244002423140"; +char const* max_unsigned_base6 = "1550104015503"; +char const* max_unsigned_base7 = "211301422353"; +char const* max_unsigned_base8 = "37777777777"; +char const* max_unsigned_base9 = "12068657453"; +char const* max_unsigned_base11 = "1904440553"; +char const* max_unsigned_base12 = "9ba461593"; +char const* max_unsigned_base13 = "535a79888"; +char const* max_unsigned_base14 = "2ca5b7463"; +char const* max_unsigned_base15 = "1a20dcd80"; +char const* max_unsigned_base16 = "ffffffff"; +char const* max_unsigned_base17 = "a7ffda90"; +char const* max_unsigned_base18 = "704he7g3"; +char const* max_unsigned_base19 = "4f5aff65"; +char const* max_unsigned_base20 = "3723ai4f"; +char const* max_unsigned_base21 = "281d55i3"; +char const* max_unsigned_base22 = "1fj8b183"; +char const* max_unsigned_base23 = "1606k7ib"; +char const* max_unsigned_base24 = "mb994af"; +char const* max_unsigned_base25 = "hek2mgk"; +char const* max_unsigned_base26 = "dnchbnl"; +char const* max_unsigned_base27 = "b28jpdl"; +char const* max_unsigned_base28 = "8pfgih3"; +char const* max_unsigned_base29 = "76beigf"; +char const* max_unsigned_base30 = "5qmcpqf"; +char const* max_unsigned_base31 = "4q0jto3"; +char const* max_unsigned_base32 = "3vvvvvv"; +char const* max_unsigned_base33 = "3aokq93"; +char const* max_unsigned_base34 = "2qhxjlh"; +char const* max_unsigned_base35 = "2br45qa"; +char const* max_unsigned_base36 = "1z141z3"; + +int +main() +{ + using spirit_test::test; + using boost::spirit::karma::uint_generator; + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 2) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 2> base2_generator; + + BOOST_TEST(test("1100111100100110010", base2_generator(424242))); + BOOST_TEST(test("1100111100100110010", base2_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base2, base2_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base2, base2_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 3) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 3> base3_generator; + + BOOST_TEST(test("210112221200", base3_generator(424242))); + BOOST_TEST(test("210112221200", base3_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base3, base3_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base3, base3_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 4) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 4> base4_generator; + + BOOST_TEST(test("1213210302", base4_generator(424242))); + BOOST_TEST(test("1213210302", base4_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base4, base4_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base4, base4_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 5) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 5> base5_generator; + + BOOST_TEST(test("102033432", base5_generator(424242))); + BOOST_TEST(test("102033432", base5_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base5, base5_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base5, base5_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 6) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 6> base6_generator; + + BOOST_TEST(test("13032030", base6_generator(424242))); + BOOST_TEST(test("13032030", base6_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base6, base6_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base6, base6_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 7) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 7> base7_generator; + + BOOST_TEST(test("3414600", base7_generator(424242))); + BOOST_TEST(test("3414600", base7_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base7, base7_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base7, base7_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 8) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 8> base8_generator; + + BOOST_TEST(test("1474462", base8_generator(424242))); + BOOST_TEST(test("1474462", base8_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base8, base8_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base8, base8_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 9) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 9> base9_generator; + + BOOST_TEST(test("715850", base9_generator(424242))); + BOOST_TEST(test("715850", base9_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base9, base9_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base9, base9_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 11) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 11> base11_generator; + + BOOST_TEST(test("26a815", base11_generator(424242))); + BOOST_TEST(test("26a815", base11_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base11, base11_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base11, base11_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 12) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 12> base12_generator; + + BOOST_TEST(test("185616", base12_generator(424242))); + BOOST_TEST(test("185616", base12_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base12, base12_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base12, base12_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 13) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 13> base13_generator; + + BOOST_TEST(test("11b140", base13_generator(424242))); + BOOST_TEST(test("11b140", base13_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base13, base13_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base13, base13_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 14) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 14> base14_generator; + + BOOST_TEST(test("b0870", base14_generator(424242))); + BOOST_TEST(test("b0870", base14_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base14, base14_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base14, base14_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 15) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 15> base15_generator; + + BOOST_TEST(test("85a7c", base15_generator(424242))); + BOOST_TEST(test("85a7c", base15_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base15, base15_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base15, base15_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 16) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 16> base16_generator; + + BOOST_TEST(test("67932", base16_generator(424242))); + BOOST_TEST(test("67932", base16_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base16, base16_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base16, base16_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 17) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 17> base17_generator; + + BOOST_TEST(test("515g7", base17_generator(424242))); + BOOST_TEST(test("515g7", base17_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base17, base17_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base17, base17_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 18) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 18> base18_generator; + + BOOST_TEST(test("40d70", base18_generator(424242))); + BOOST_TEST(test("40d70", base18_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base18, base18_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base18, base18_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 19) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 19> base19_generator; + + BOOST_TEST(test("34g3a", base19_generator(424242))); + BOOST_TEST(test("34g3a", base19_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base19, base19_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base19, base19_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 20) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 20> base20_generator; + + BOOST_TEST(test("2d0c2", base20_generator(424242))); + BOOST_TEST(test("2d0c2", base20_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base20, base20_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base20, base20_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 21) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 21> base21_generator; + + BOOST_TEST(test("23h00", base21_generator(424242))); + BOOST_TEST(test("23h00", base21_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base21, base21_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base21, base21_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 22) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 22> base22_generator; + + BOOST_TEST(test("1hibg", base22_generator(424242))); + BOOST_TEST(test("1hibg", base22_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base22, base22_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base22, base22_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 23) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 23> base23_generator; + + BOOST_TEST(test("1bjm7", base23_generator(424242))); + BOOST_TEST(test("1bjm7", base23_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base23, base23_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base23, base23_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 24) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 24> base24_generator; + + BOOST_TEST(test("16gci", base24_generator(424242))); + BOOST_TEST(test("16gci", base24_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base24, base24_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base24, base24_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 25) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 25> base25_generator; + + BOOST_TEST(test("123jh", base25_generator(424242))); + BOOST_TEST(test("123jh", base25_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base25, base25_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base25, base25_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 26) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 26> base26_generator; + + BOOST_TEST(test("o3f0", base26_generator(424242))); + BOOST_TEST(test("o3f0", base26_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base26, base26_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base26, base26_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 27) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 27> base27_generator; + + BOOST_TEST(test("lepi", base27_generator(424242))); + BOOST_TEST(test("lepi", base27_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base27, base27_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base27, base27_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 28) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 28> base28_generator; + + BOOST_TEST(test("j93e", base28_generator(424242))); + BOOST_TEST(test("j93e", base28_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base28, base28_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base28, base28_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 29) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 29> base29_generator; + + BOOST_TEST(test("hbd1", base29_generator(424242))); + BOOST_TEST(test("hbd1", base29_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base29, base29_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base29, base29_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 30) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 30> base30_generator; + + BOOST_TEST(test("flbc", base30_generator(424242))); + BOOST_TEST(test("flbc", base30_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base30, base30_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base30, base30_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 31) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 31> base31_generator; + + BOOST_TEST(test("e7e7", base31_generator(424242))); + BOOST_TEST(test("e7e7", base31_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base31, base31_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base31, base31_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 32) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 32> base32_generator; + + BOOST_TEST(test("cu9i", base32_generator(424242))); + BOOST_TEST(test("cu9i", base32_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base32, base32_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base32, base32_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 33) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 33> base33_generator; + + BOOST_TEST(test("bqir", base33_generator(424242))); + BOOST_TEST(test("bqir", base33_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base33, base33_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base33, base33_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 34) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 34> base34_generator; + + BOOST_TEST(test("aqxo", base34_generator(424242))); + BOOST_TEST(test("aqxo", base34_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base34, base34_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base34, base34_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 35) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 35> base35_generator; + + BOOST_TEST(test("9vb7", base35_generator(424242))); + BOOST_TEST(test("9vb7", base35_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base35, base35_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base35, base35_generator, 0xffffffffu)); + } + + /////////////////////////////////////////////////////////////////////////// + // arbitrary radix test (base 36) + /////////////////////////////////////////////////////////////////////////// + { + uint_generator<boost::uint32_t, 36> base36_generator; + + BOOST_TEST(test("93ci", base36_generator(424242))); + BOOST_TEST(test("93ci", base36_generator, 424242)); + + BOOST_TEST(test(max_unsigned_base36, base36_generator(0xffffffffu))); + BOOST_TEST(test(max_unsigned_base36, base36_generator, 0xffffffffu)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/utree1.cpp b/src/boost/libs/spirit/test/karma/utree1.cpp new file mode 100644 index 00000000..5728b103 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/utree1.cpp @@ -0,0 +1,128 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2001-2011 Joel de Guzman +// Copyright (c) 2010 Bryce Lelbach +// +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/mpl/print.hpp> + +#include <boost/spirit/include/karma.hpp> +#include <boost/spirit/include/support_utree.hpp> + +#include <sstream> + +#include "test.hpp" + +int main() +{ + using spirit_test::test; + using spirit_test::test_delimited; + using boost::spirit::utree; + using boost::spirit::utree_type; + using boost::spirit::utf8_string_range_type; + using boost::spirit::utf8_string_type; + using boost::spirit::utf8_symbol_type; + + using boost::spirit::karma::char_; + using boost::spirit::karma::bool_; + using boost::spirit::karma::int_; + using boost::spirit::karma::double_; + using boost::spirit::karma::string; + using boost::spirit::karma::space; + using boost::spirit::karma::rule; + + typedef spirit_test::output_iterator<char>::type output_iterator; + + // primitive data types + { + utree ut('x'); + BOOST_TEST(test("x", char_, ut)); + + ut = false; + BOOST_TEST(test("false", bool_, ut)); + + ut = 123; + BOOST_TEST(test("123", int_, ut)); + + ut = 123.45; + BOOST_TEST(test("123.45", double_, ut)); + + ut = "abc"; + BOOST_TEST(test("abc", string, ut)); + + ut = utf8_symbol_type("xyz"); + BOOST_TEST(test("xyz", string, ut)); + } + + // sequences + { + using boost::spirit::karma::digit; + using boost::spirit::karma::repeat; + + utree ut; + ut.push_back('x'); + ut.push_back('y'); + BOOST_TEST(test("xy", char_ << char_, ut)); + + ut.clear(); + ut.push_back(123); + ut.push_back(456); + BOOST_TEST(test_delimited("123 456 ", int_ << int_, ut, space)); + + ut.clear(); + ut.push_back(1.23); + ut.push_back(4.56); + BOOST_TEST(test_delimited("1.23 4.56 ", double_ << double_, ut, space)); + + ut.clear(); + ut.push_back(1.23); + ut.push_back("ab"); + BOOST_TEST(test("1.23ab", double_ << string, ut)); + + ut.clear(); + + rule<output_iterator, double()> r1 = double_; + rule<output_iterator, utree()> r2 = double_; + + // ( 1.23 "a" "b" ) + ut.push_back(1.23); + ut.push_back('a'); + ut.push_back('b'); + BOOST_TEST(test("1.23ab", double_ << *char_, ut)); + BOOST_TEST(test("1.23ab", r1 << *char_, ut)); + BOOST_TEST(test("1.23ab", r2 << *char_, ut)); + + // ( ( 1.23 ) "a" "b" ) + ut.clear(); + utree ut1; + ut1.push_back(1.23); + ut.push_back(ut1); + ut.push_back('a'); + ut.push_back('b'); + BOOST_TEST(test("1.23ab", r1 << *char_, ut)); + BOOST_TEST(test("1.23ab", r2 << *char_, ut)); + + // ( "a" "b" 1.23 ) + ut.clear(); + ut.push_back('a'); + ut.push_back('b'); + ut.push_back(1.23); + BOOST_TEST(test("ab1.23", repeat(2)[~digit] << double_, ut)); + BOOST_TEST(test("ab1.23", repeat(2)[~digit] << r1, ut)); + BOOST_TEST(test("ab1.23", repeat(2)[~digit] << r2, ut)); + + // ( "a" "b" ( 1.23 ) ) + ut.clear(); + ut.push_back('a'); + ut.push_back('b'); + ut.push_back(ut1); + BOOST_TEST(test("ab1.23", repeat(2)[~digit] << r1, ut)); + BOOST_TEST(test("ab1.23", repeat(2)[~digit] << r2, ut)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/utree2.cpp b/src/boost/libs/spirit/test/karma/utree2.cpp new file mode 100644 index 00000000..429ddda1 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/utree2.cpp @@ -0,0 +1,155 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2001-2011 Joel de Guzman +// Copyright (c) 2010 Bryce Lelbach +// +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/mpl/print.hpp> + +#include <boost/spirit/include/karma.hpp> +#include <boost/spirit/include/support_utree.hpp> + +#include <sstream> + +#include "test.hpp" + +int main() +{ + using spirit_test::test; + using spirit_test::test_delimited; + using boost::spirit::utree; + using boost::spirit::utree_type; + using boost::spirit::utf8_string_range_type; + using boost::spirit::utf8_string_type; + using boost::spirit::utf8_symbol_type; + + using boost::spirit::karma::char_; + using boost::spirit::karma::bool_; + using boost::spirit::karma::int_; + using boost::spirit::karma::double_; + using boost::spirit::karma::string; + using boost::spirit::karma::space; + using boost::spirit::karma::rule; + + typedef spirit_test::output_iterator<char>::type output_iterator; + + // kleene star + { + utree ut; + ut.push_back('a'); + ut.push_back('b'); + BOOST_TEST(test("ab", *char_, ut)); + + ut.clear(); + ut.push_back(123); + ut.push_back(456); + BOOST_TEST(test_delimited("123 456 ", *int_, ut, space)); + + ut.clear(); + ut.push_back(1.23); + ut.push_back(4.56); + BOOST_TEST(test_delimited("1.23 4.56 ", *double_, ut, space)); + } + + // lists + { + rule<output_iterator, utree()> r1, r1ref; + rule<output_iterator, utf8_string_range_type()> r1str; + rule<output_iterator, utree::const_range()> r1list; + + r1 = double_ | int_ | r1str | r1list | r1ref; + + r1ref = r1.alias(); + + r1str = string; + + r1list = '(' << -(r1 % ',') << ')'; + + // ( "abc" "def" ) + utree ut; + ut.push_back("abc"); + ut.push_back("def"); + BOOST_TEST(test("abc,def", string % ',', ut)); + BOOST_TEST(test("(abc,def)", r1, ut)); + + // ( ( "abc" "def" ) ) + utree ut1; + ut1.push_back(ut); + BOOST_TEST(test("((abc,def))", r1, ut1)); + +// rule<output_iterator, std::vector<char>()> r2 = char_ % ','; +// BOOST_TEST(test("abc,def", r2, ut)); +// BOOST_TEST(test("abc,def", r2, ut1)); + + // ( ( "abc" "def" ) ( "abc" "def" ) ) + ut1.push_back(ut); + BOOST_TEST(test("(abc,def) (abc,def)", r1 << ' ' << r1, ut1)); + + // ( 123 456 ) + ut.clear(); + ut.push_back(123); + ut.push_back(456); + BOOST_TEST(test("123,456", int_ % ',', ut)); + BOOST_TEST(test("(123,456)", r1, ut)); + + // ( ( 123 456 ) ) + ut1.clear(); + ut1.push_back(ut); + BOOST_TEST(test("((123,456))", r1, ut1)); + +// rule<output_iterator, std::vector<int>()> r4 = int_ % ','; +// BOOST_TEST(test("123,456", r4, ut)); +// BOOST_TEST(test("123,456", r4, ut1)); + + // ( ( 123 456 ) ( 123 456 ) ) + ut1.push_back(ut); + BOOST_TEST(test("(123,456) (123,456)", r1 << ' ' << r1, ut1)); + + // ( 1.23 4.56 ) + ut.clear(); + ut.push_back(1.23); + ut.push_back(4.56); + BOOST_TEST(test("1.23,4.56", double_ % ',', ut)); + BOOST_TEST(test("(1.23,4.56)", r1, ut)); + + // ( ( 1.23 4.56 ) ) + ut1.clear(); + ut1.push_back(ut); + BOOST_TEST(test("((1.23,4.56))", r1, ut1)); + +// rule<output_iterator, std::vector<double>()> r6 = double_ % ','; +// BOOST_TEST(test("1.23,4.56", r6, ut)); +// BOOST_TEST(test("1.23,4.56", r6, ut1)); + + // ( ( 1.23 4.56 ) ( 1.23 4.56 ) ) + ut1.push_back(ut); + BOOST_TEST(test("(1.23,4.56) (1.23,4.56)", r1 <<' ' << r1, ut1)); + } + + // alternatives + { + rule<output_iterator, utree()> r1 = int_ | double_; + utree ut(10); + BOOST_TEST(test("10", int_ | double_, ut)); + BOOST_TEST(test("10", r1, ut)); + + ut = 10.2; + BOOST_TEST(test("10.2", int_ | double_, ut)); + BOOST_TEST(test("10.2", r1, ut)); + } + + // optionals + { + utree ut('x'); + BOOST_TEST(test("x", -char_, ut)); + + ut.clear(); + BOOST_TEST(test("", -char_, ut)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/utree3.cpp b/src/boost/libs/spirit/test/karma/utree3.cpp new file mode 100644 index 00000000..96f84e31 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/utree3.cpp @@ -0,0 +1,134 @@ +// Copyright (c) 2001-2011 Hartmut Kaiser +// Copyright (c) 2001-2011 Joel de Guzman +// Copyright (c) 2010 Bryce Lelbach +// +// 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) + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> + +#include <boost/mpl/print.hpp> + +#include <boost/spirit/include/karma.hpp> +#include <boost/spirit/include/support_utree.hpp> + +#include <sstream> + +#include "test.hpp" + +int main() +{ + using spirit_test::test; + using spirit_test::test_delimited; + using boost::spirit::utree; + using boost::spirit::utree_type; + using boost::spirit::utf8_string_range_type; + using boost::spirit::utf8_string_type; + using boost::spirit::utf8_symbol_type; + + using boost::spirit::karma::char_; + using boost::spirit::karma::bool_; + using boost::spirit::karma::int_; + using boost::spirit::karma::double_; + using boost::spirit::karma::string; + using boost::spirit::karma::space; + using boost::spirit::karma::rule; + + typedef spirit_test::output_iterator<char>::type output_iterator; + + // as_string + { + using boost::spirit::karma::digit; + using boost::spirit::karma::as_string; + + utree ut("xy"); + BOOST_TEST(test("xy", string, ut)); + BOOST_TEST(test("xy", as_string[*char_], ut)); + BOOST_TEST(test("x,y", as_string[char_ << ',' << char_], ut)); + + ut.clear(); + ut.push_back("ab"); + ut.push_back(1.2); + BOOST_TEST(test("ab1.2", as_string[*~digit] << double_, ut)); + BOOST_TEST(test("a,b1.2", as_string[~digit % ','] << double_, ut)); + } + + // as + { + using boost::spirit::karma::digit; + using boost::spirit::karma::as; + + typedef as<std::string> as_string_type; + as_string_type const as_string = as_string_type(); + + typedef as<utf8_symbol_type> as_symbol_type; + as_symbol_type const as_symbol = as_symbol_type(); + + utree ut("xy"); + BOOST_TEST(test("xy", string, ut)); + BOOST_TEST(test("xy", as_string[*char_], ut)); + BOOST_TEST(test("x,y", as_string[char_ << ',' << char_], ut)); + + ut.clear(); + ut.push_back("ab"); + ut.push_back(1.2); + BOOST_TEST(test("ab1.2", as_string[*~digit] << double_, ut)); + BOOST_TEST(test("a,b1.2", as_string[~digit % ','] << double_, ut)); + + ut = utf8_symbol_type("xy"); + BOOST_TEST(test("xy", string, ut)); + BOOST_TEST(test("xy", as_symbol[*char_], ut)); + BOOST_TEST(test("x,y", as_symbol[char_ << ',' << char_], ut)); + + ut.clear(); + ut.push_back(utf8_symbol_type("ab")); + ut.push_back(1.2); + BOOST_TEST(test("ab1.2", as_symbol[*~digit] << double_, ut)); + BOOST_TEST(test("a,b1.2", as_symbol[~digit % ','] << double_, ut)); + } + + // typed basic_string rules + { + utree ut("buzz"); + + rule<output_iterator, utf8_string_type()> r1 = string; + rule<output_iterator, utf8_symbol_type()> r2 = string; + + BOOST_TEST(test("buzz", r1, ut)); + + ut = utf8_symbol_type("bar"); + BOOST_TEST(test("bar", r2, ut)); + } + + // parameterized karma::string + { + utree ut("foo"); + + rule<output_iterator, utf8_string_type()> r1 = string("foo"); + BOOST_TEST(test("foo", string("foo"), ut)); + BOOST_TEST(test("foo", r1, ut)); + } + + { + using boost::spirit::karma::verbatim; + using boost::spirit::karma::repeat; + using boost::spirit::karma::space; + using boost::spirit::karma::digit; + + utree ut; + ut.push_back('x'); + ut.push_back('y'); + ut.push_back('c'); + BOOST_TEST(test_delimited("xy c ", verbatim[repeat(2)[char_]] << char_, ut, space)); + BOOST_TEST(test_delimited("x yc ", char_ << verbatim[*char_], ut, space)); + + ut.clear(); + ut.push_back('a'); + ut.push_back('b'); + ut.push_back(1.2); + BOOST_TEST(test_delimited("ab 1.2 ", verbatim[repeat(2)[~digit]] << double_, ut, space)); + } + + return boost::report_errors(); +} diff --git a/src/boost/libs/spirit/test/karma/wstream.cpp b/src/boost/libs/spirit/test/karma/wstream.cpp new file mode 100644 index 00000000..1f4ba199 --- /dev/null +++ b/src/boost/libs/spirit/test/karma/wstream.cpp @@ -0,0 +1,115 @@ +// Copyright (c) 2001-2011 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) + +#include <cwchar> +#include <streambuf> +#include <iostream> + +#include <boost/config/warning_disable.hpp> +#include <boost/detail/lightweight_test.hpp> +#include <boost/cstdint.hpp> + +#include <boost/spirit/include/karma_char.hpp> +#include <boost/spirit/include/karma_string.hpp> +#include <boost/spirit/include/karma_stream.hpp> +#include <boost/spirit/include/karma_directive.hpp> +#include <boost/spirit/include/phoenix_core.hpp> +#include <boost/spirit/include/phoenix_operator.hpp> + +#include "test.hpp" + +using namespace spirit_test; + +// a simple complex number representation z = a + bi +struct complex +{ + complex (double a, double b) + : a(a), b(b) + {} + + double a; + double b; + + template <typename Char> + friend std::basic_ostream<Char>& + operator<< (std::basic_ostream<Char>& os, complex z) + { + os << "{" << z.a << "," << z.b << "}"; + return os; + } +}; + +/////////////////////////////////////////////////////////////////////////////// +int +main() +{ + using namespace boost::spirit; + + { + BOOST_TEST(test(L"x", wstream, L'x')); + BOOST_TEST(test(L"xyz", wstream, L"xyz")); + BOOST_TEST(test(L"xyz", wstream, std::basic_string<wchar_t>(L"xyz"))); + BOOST_TEST(test(L"1", wstream, 1)); + BOOST_TEST(test(L"1.1", wstream, 1.1)); + BOOST_TEST(test(L"{1.2,2.4}", wstream, complex(1.2, 2.4))); + } + + { + BOOST_TEST(test(L"x", wstream(L'x'))); + BOOST_TEST(test(L"xyz", wstream(L"xyz"))); + BOOST_TEST(test(L"xyz", wstream(std::basic_string<wchar_t>(L"xyz")))); + BOOST_TEST(test(L"1", wstream(1))); + BOOST_TEST(test(L"1.1", wstream(1.1))); + BOOST_TEST(test(L"{1.2,2.4}", wstream(complex(1.2, 2.4)))); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test(L"x", lower[wstream], L'X')); + BOOST_TEST(test(L"xyz", lower[wstream], L"XYZ")); + BOOST_TEST(test(L"xyz", lower[wstream], std::basic_string<wchar_t>(L"XYZ"))); + BOOST_TEST(test(L"X", upper[wstream], L'x')); + BOOST_TEST(test(L"XYZ", upper[wstream], L"xyz")); + BOOST_TEST(test(L"XYZ", upper[wstream], std::basic_string<wchar_t>(L"xyz"))); + } + + { + BOOST_TEST(test_delimited(L"x ", wstream, L'x', L' ')); + BOOST_TEST(test_delimited(L"xyz ", wstream, L"xyz", L' ')); + BOOST_TEST(test_delimited(L"xyz ", wstream, std::basic_string<wchar_t>(L"xyz"), L' ')); + BOOST_TEST(test_delimited(L"1 ", wstream, 1, ' ')); + BOOST_TEST(test_delimited(L"1.1 ", wstream, 1.1, ' ')); + BOOST_TEST(test_delimited(L"{1.2,2.4} ", wstream, complex(1.2, 2.4), ' ')); + } + + { + using namespace boost::spirit::ascii; + + BOOST_TEST(test_delimited(L"x ", lower[wstream], L'X', L' ')); + BOOST_TEST(test_delimited(L"xyz ", lower[wstream], L"XYZ", L' ')); + BOOST_TEST(test_delimited(L"xyz ", lower[wstream], std::basic_string<wchar_t>(L"XYZ"), L' ')); + BOOST_TEST(test_delimited(L"X ", upper[wstream], L'x', L' ')); + BOOST_TEST(test_delimited(L"XYZ ", upper[wstream], L"xyz", ' ')); + BOOST_TEST(test_delimited(L"XYZ ", upper[wstream], std::basic_string<wchar_t>(L"xyz"), L' ')); + } + + { // lazy streams + namespace phx = boost::phoenix; + + std::basic_string<wchar_t> ws(L"abc"); + BOOST_TEST((test(L"abc", wstream(phx::val(ws))))); + BOOST_TEST((test(L"abc", wstream(phx::ref(ws))))); + } + + { + boost::optional<wchar_t> c; + BOOST_TEST(!test(L"", wstream, c)); + c = L'x'; + BOOST_TEST(test(L"x", wstream, c)); + } + + return boost::report_errors(); +} |