townforge/spirit
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
cc
spirit/test/support/utree.cpp
Nikita Kniazev 5e4ab36170 Tests: Include less headers
2018-10-01 02:16:04 +03:00

502 lines
15 KiB
C++
Raw Permalink Blame History

/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2001-2011 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)
=============================================================================*/
#include <boost/config/warning_disable.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <boost/functional/hash.hpp>
#include <boost/spirit/include/support_utree.hpp>
#include <iostream>
#include <sstream>
#include <cstdlib>
inline bool check(boost::spirit::utree const& val, std::string expected)
{
std::stringstream s;
s << val;
if (s.str() == expected + " ")
return true;
std::cerr << "got result: " << s.str()
<< ", expected: " << expected << std::endl;
return false;
}
struct one_two_three
{
boost::spirit::utree operator()(boost::spirit::utree) const
{
return boost::spirit::utree(123);
}
};
struct this_
{
boost::spirit::utree operator()(boost::spirit::utree) const
{
return boost::spirit::utree(static_cast<int>(boost::hash_value(this)));
}
};
int main()
{
using boost::spirit::utree;
using boost::spirit::get;
using boost::spirit::utf8_symbol_type;
using boost::spirit::binary_string_type;
{
// test the size
std::cout << "size of utree is: "
<< sizeof(utree) << " bytes" << std::endl;
BOOST_TEST_EQ(sizeof(utree), sizeof(void*[4]));
}
{
using boost::spirit::nil;
utree val(nil);
BOOST_TEST(check(val, "<nil>"));
}
{
using boost::spirit::empty_list;
utree val(empty_list);
BOOST_TEST(check(val, "( )"));
}
{
utree val(true);
BOOST_TEST(check(val, "true"));
}
{
utree val(123);
BOOST_TEST(check(val, "123"));
}
{
// single element string
utree val('x');
BOOST_TEST(check(val, "\"x\""));
// empty string
utree val1("");
BOOST_TEST(check(val1, "\"\""));
}
{
utree val(123.456);
BOOST_TEST(check(val, "123.456"));
}
{ // strings
utree val("Hello, World");
BOOST_TEST(check(val, "\"Hello, World\""));
utree val2;
val2 = val;
BOOST_TEST(check(val2, "\"Hello, World\""));
utree val3("Hello, World. Chuckie is back!!!");
val = val3;
BOOST_TEST(check(val, "\"Hello, World. Chuckie is back!!!\""));
utree val4("Apple");
utree val5("Apple");
BOOST_TEST_EQ(val4, val5);
utree val6("ApplePie");
BOOST_TEST(val4 < val6);
}
{ // symbols
utree val(utf8_symbol_type("Hello, World"));
BOOST_TEST(check(val, "Hello, World"));
utree val2;
val2 = val;
BOOST_TEST(check(val2, "Hello, World"));
utree val3(utf8_symbol_type("Hello, World. Chuckie is back!!!"));
val = val3;
BOOST_TEST(check(val, "Hello, World. Chuckie is back!!!"));
utree val4(utf8_symbol_type("Apple"));
utree val5(utf8_symbol_type("Apple"));
BOOST_TEST_EQ(val4, val5);
utree val6(utf8_symbol_type("ApplePie"));
BOOST_TEST(val4 < val6);
}
{ // binary_strings
utree val(binary_string_type("\xDE#\xAD"));
BOOST_TEST(check(val, "#de23ad#" /* FIXME?: "#\xDE#\xAD#" */));
utree val2;
val2 = val;
BOOST_TEST(check(val2, "#de23ad#" /* FIXME?: "#\xDE#\xAD#" */));
utree val3(binary_string_type("\xDE\xAD\xBE\xEF"));
val = val3;
BOOST_TEST(check(val, "#deadbeef#" /* FIXME?: "#\xDE\xAD\xBE\xEF#" */));
utree val4(binary_string_type("\x01"));
utree val5(binary_string_type("\x01"));
BOOST_TEST_EQ(val4, val5);
utree val6(binary_string_type("\x01\x02"));
BOOST_TEST(val4 < val6);
}
{
using boost::spirit::nil;
utree val;
val.push_back(123);
val.push_back("Chuckie");
BOOST_TEST_EQ(val.size(), 2U);
utree val2;
val2.push_back(123.456);
val2.push_back("Mah Doggie");
val.push_back(val2);
BOOST_TEST_EQ(val.size(), 3U);
BOOST_TEST(check(val, "( 123 \"Chuckie\" ( 123.456 \"Mah Doggie\" ) )"));
BOOST_TEST(check(val.front(), "123"));
utree val3(nil);
val3.swap(val);
BOOST_TEST_EQ(val3.size(), 3U);
BOOST_TEST(check(val, "<nil>"));
val3.swap(val);
BOOST_TEST(check(val, "( 123 \"Chuckie\" ( 123.456 \"Mah Doggie\" ) )"));
val.push_back("another string");
BOOST_TEST_EQ(val.size(), 4U);
BOOST_TEST(check(val, "( 123 \"Chuckie\" ( 123.456 \"Mah Doggie\" ) \"another string\" )"));
val.pop_front();
BOOST_TEST(check(val, "( \"Chuckie\" ( 123.456 \"Mah Doggie\" ) \"another string\" )"));
utree::iterator i = val.begin();
++++i;
val.insert(i, "Right in the middle");
BOOST_TEST_EQ(val.size(), 4U);
BOOST_TEST(check(val, "( \"Chuckie\" ( 123.456 \"Mah Doggie\" ) \"Right in the middle\" \"another string\" )"));
val.pop_back();
BOOST_TEST(check(val, "( \"Chuckie\" ( 123.456 \"Mah Doggie\" ) \"Right in the middle\" )"));
BOOST_TEST_EQ(val.size(), 3U);
utree::iterator it = val.end(); --it;
val.erase(it);
BOOST_TEST(check(val, "( \"Chuckie\" ( 123.456 \"Mah Doggie\" ) )"));
BOOST_TEST_EQ(val.size(), 2U);
val.insert(val.begin(), val2.begin(), val2.end());
BOOST_TEST(check(val, "( 123.456 \"Mah Doggie\" \"Chuckie\" ( 123.456 \"Mah Doggie\" ) )"));
BOOST_TEST_EQ(val.size(), 4U);
// Regeression Ticket #6714
it = val.insert(val.end(), 111);
BOOST_TEST(it != val.begin());
BOOST_TEST(it == --val.end());
BOOST_TEST(*it == 111);
val.clear();
it = val.insert(val.begin(), 222);
BOOST_TEST(it == val.begin());
BOOST_TEST(it == --val.end());
BOOST_TEST(*it == 222);
// Regeression Ticket #6714
}
{
utree val;
val.insert(val.end(), 123);
val.insert(val.end(), "Mia");
val.insert(val.end(), "Chuckie");
val.insert(val.end(), "Poly");
val.insert(val.end(), "Mochi");
BOOST_TEST(check(val, "( 123 \"Mia\" \"Chuckie\" \"Poly\" \"Mochi\" )"));
}
{
using boost::spirit::nil;
using boost::spirit::invalid;
utree a(nil), b(nil);
BOOST_TEST_EQ(a, b);
a = 123;
BOOST_TEST(a != b);
b = 123;
BOOST_TEST_EQ(a, b);
a = 100.00;
BOOST_TEST(a < b);
b = a = utree(invalid);
BOOST_TEST_EQ(a, b);
a.push_back(1);
a.push_back("two");
a.push_back(3.0);
b.push_back(1);
b.push_back("two");
b.push_back(3.0);
BOOST_TEST_EQ(a, b);
b.push_back(4);
BOOST_TEST(a != b);
BOOST_TEST(a < b);
}
{
using boost::spirit::empty_list;
utree a(empty_list);
a.push_back(0);
a.push_back(0);
a.push_back(0);
a.push_back(0);
a.push_back(0);
a.push_back(0);
a.push_back(0);
a.push_back(0);
a.push_back(0);
a.push_back(0);
a.push_back(0);
a.push_back(0);
for (utree::size_type i = 0; i < a.size(); ++i)
get(a, i) = int(i + 1);
BOOST_TEST_EQ(get(a, 0), utree(1));
BOOST_TEST_EQ(get(a, 1), utree(2));
BOOST_TEST_EQ(get(a, 2), utree(3));
BOOST_TEST_EQ(get(a, 3), utree(4));
BOOST_TEST_EQ(get(a, 4), utree(5));
BOOST_TEST_EQ(get(a, 5), utree(6));
BOOST_TEST_EQ(get(a, 6), utree(7));
BOOST_TEST_EQ(get(a, 7), utree(8));
BOOST_TEST_EQ(get(a, 8), utree(9));
BOOST_TEST_EQ(get(a, 9), utree(10));
BOOST_TEST_EQ(get(a, 10), utree(11));
BOOST_TEST_EQ(get(a, 11), utree(12));
}
{
// test empty list
utree a;
a.push_back(1);
a.pop_front();
BOOST_TEST(check(a, "( )"));
// the other way around
utree b;
b.push_front(1);
b.pop_back();
BOOST_TEST(check(b, "( )"));
}
{ // test references
utree val(123);
utree ref(boost::ref(val));
BOOST_TEST(check(ref, "123"));
BOOST_TEST_EQ(ref, utree(123));
val.clear();
val.push_back(1);
val.push_back(2);
val.push_back(3);
val.push_back(4);
BOOST_TEST(check(ref, "( 1 2 3 4 )"));
BOOST_TEST_EQ(get(ref, 0), utree(1));
BOOST_TEST_EQ(get(ref, 1), utree(2));
BOOST_TEST_EQ(get(ref, 2), utree(3));
BOOST_TEST_EQ(get(ref, 3), utree(4));
}
{ // put it in an array
utree vals[] = {
utree(123),
utree("Hello, World"),
utree(123.456)
};
BOOST_TEST(check(vals[0], "123"));
BOOST_TEST(check(vals[1], "\"Hello, World\""));
BOOST_TEST(check(vals[2], "123.456"));
}
{ // operators
BOOST_TEST((utree(false) && utree(false)) == utree(false));
BOOST_TEST((utree(false) && utree(true)) == utree(false));
BOOST_TEST((utree(true) && utree(false)) == utree(false));
BOOST_TEST((utree(true) && utree(true)) == utree(true));
BOOST_TEST((utree(0) && utree(0)) == utree(false));
BOOST_TEST((utree(0) && utree(1)) == utree(false));
BOOST_TEST((utree(1) && utree(0)) == utree(false));
BOOST_TEST((utree(1) && utree(1)) == utree(true));
BOOST_TEST((utree(false) || utree(false)) == utree(false));
BOOST_TEST((utree(false) || utree(true)) == utree(true));
BOOST_TEST((utree(true) || utree(false)) == utree(true));
BOOST_TEST((utree(true) || utree(true)) == utree(true));
BOOST_TEST((utree(0) || utree(0)) == utree(false));
BOOST_TEST((utree(0) || utree(1)) == utree(true));
BOOST_TEST((utree(1) || utree(0)) == utree(true));
BOOST_TEST((utree(1) || utree(1)) == utree(true));
BOOST_TEST((!utree(true)) == utree(false));
BOOST_TEST((!utree(false)) == utree(true));
BOOST_TEST((!utree(1)) == utree(false));
BOOST_TEST((!utree(0)) == utree(true));
BOOST_TEST((utree(456) + utree(123)) == utree(456 + 123));
BOOST_TEST((utree(456) + utree(123.456)) == utree(456 + 123.456));
BOOST_TEST((utree(456) - utree(123)) == utree(456 - 123));
BOOST_TEST((utree(456) - utree(123.456)) == utree(456 - 123.456));
BOOST_TEST((utree(456) * utree(123)) == utree(456 * 123));
BOOST_TEST((utree(456) * utree(123.456)) == utree(456 * 123.456));
BOOST_TEST((utree(456) / utree(123)) == utree(456 / 123));
BOOST_TEST((utree(456) / utree(123.456)) == utree(456 / 123.456));
BOOST_TEST((utree(456) % utree(123)) == utree(456 % 123));
BOOST_TEST(-utree(456) == utree(-456));
BOOST_TEST((utree(456) & utree(123)) == utree(456 & 123));
BOOST_TEST((utree(456) | utree(123)) == utree(456 | 123));
BOOST_TEST((utree(456) ^ utree(123)) == utree(456 ^ 123));
BOOST_TEST((utree(456) << utree(3)) == utree(456 << 3));
BOOST_TEST((utree(456) >> utree(2)) == utree(456 >> 2));
BOOST_TEST(~utree(456) == utree(~456));
}
{ // test reference iterator
utree val;
val.push_back(1);
val.push_back(2);
val.push_back(3);
val.push_back(4);
BOOST_TEST(check(val, "( 1 2 3 4 )"));
utree::ref_iterator b = val.ref_begin();
utree::ref_iterator e = val.ref_end();
utree ref(boost::make_iterator_range(b, e));
BOOST_TEST_EQ(get(ref, 0), utree(1));
BOOST_TEST_EQ(get(ref, 1), utree(2));
BOOST_TEST_EQ(get(ref, 2), utree(3));
BOOST_TEST_EQ(get(ref, 3), utree(4));
BOOST_TEST(check(ref, "( 1 2 3 4 )"));
}
{
// check the tag
// TODO: test tags on all utree types
utree x;
x.tag(123);
BOOST_TEST_EQ(x.tag(), 123);
x = "hello world! my name is bob the builder";
x.tag(123);
BOOST_TEST_EQ(x.tag(), 123);
x.tag(456);
BOOST_TEST_EQ(x.tag(), 456);
BOOST_TEST_EQ(x.size(), 39U);
BOOST_TEST(check(x, "\"hello world! my name is bob the builder\""));
x = "hello";
x.tag(456);
BOOST_TEST_EQ(x.tag(), 456);
x.tag(789);
BOOST_TEST_EQ(x.tag(), 789);
BOOST_TEST_EQ(x.size(), 5U);
BOOST_TEST(check(x, "\"hello\""));
}
{
// test functions
using boost::spirit::stored_function;
utree f = stored_function<one_two_three>();
f.eval(utree());
}
{
// test referenced functions
using boost::spirit::referenced_function;
one_two_three f;
utree ff = referenced_function<one_two_three>(f);
BOOST_TEST_EQ(ff.eval(utree()), f(utree()));
}
{
// shallow ranges
using boost::spirit::shallow;
utree val;
val.push_back(1);
val.push_back(2);
val.push_back(3);
val.push_back(4);
utree::iterator i = val.begin(); ++i;
utree alias(utree::range(i, val.end()), shallow);
BOOST_TEST(check(alias, "( 2 3 4 )"));
BOOST_TEST_EQ(alias.size(), 3U);
BOOST_TEST_EQ(alias.front(), 2);
BOOST_TEST_EQ(alias.back(), 4);
BOOST_TEST(!alias.empty());
BOOST_TEST_EQ(get(alias, 1), 3);
}
{
// shallow string ranges
using boost::spirit::utf8_string_range_type;
using boost::spirit::shallow;
char const* s = "Hello, World";
utree val(utf8_string_range_type(s, s + strlen(s)), shallow);
BOOST_TEST(check(val, "\"Hello, World\""));
utf8_string_range_type r = val.get<utf8_string_range_type>();
utf8_string_range_type pf(r.begin()+1, r.end()-1);
val = utree(pf, shallow);
BOOST_TEST(check(val, "\"ello, Worl\""));
}
{
// any pointer
using boost::spirit::any_ptr;
int n = 123;
utree up = any_ptr(&n);
BOOST_TEST(*up.get<int*>() == 123);
}
// tags
{
short min = (std::numeric_limits<short>::min)();
short max = (std::numeric_limits<short>::max)();
utree::list_type u;
utree u2;
bool ok = true;
for (int t = min ; ok && t <= max ; ++t) {
u.tag(t);
u2 = u;
BOOST_TEST_EQ(t, u.tag());
BOOST_TEST_EQ(t, u2.tag());
ok = t == u.tag() && t == u2.tag();
u2 = utree("12");
}
}
return boost::report_errors();
}
Reference in New Issue View Git Blame Copy Permalink