| /*============================================================================= |
| Copyright (c) 2001-2010 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/config/warning_disable.hpp> |
| |
| #include <utree/utree.hpp> |
| #include <utree/operators.hpp> |
| #include <utree/io.hpp> |
| #include <iostream> |
| #include <sstream> |
| #include <cstdlib> |
| |
| inline void check(scheme::utree const& val, std::string expected) |
| { |
| std::stringstream s; |
| s << val; |
| BOOST_ASSERT(s.str() == expected + " "); |
| } |
| |
| struct one_two_three |
| { |
| scheme::utree operator()(scheme::scope) const |
| { |
| return scheme::utree(123); |
| } |
| }; |
| |
| int main() |
| { |
| using scheme::utree; |
| |
| { |
| // test the size |
| std::cout << "size of utree is: " |
| << sizeof(scheme::utree) << " bytes" << std::endl; |
| } |
| |
| { |
| utree val; |
| check(val, "<nil>"); |
| } |
| |
| { |
| utree val(true); |
| check(val, "true"); |
| } |
| |
| { |
| utree val(123); |
| check(val, "123"); |
| } |
| |
| { |
| // single element string |
| utree val('x'); |
| check(val, "\"x\""); |
| } |
| |
| { |
| utree val(123.456); |
| check(val, "123.456"); |
| } |
| |
| { |
| utree val("Hello, World"); |
| check(val, "\"Hello, World\""); |
| utree val2; |
| val2 = val; |
| check(val2, "\"Hello, World\""); |
| utree val3("Hello, World. Chuckie is back!!!"); |
| val = val3; |
| check(val, "\"Hello, World. Chuckie is back!!!\""); |
| |
| utree val4("Apple"); |
| utree val5("Apple"); |
| BOOST_TEST(val4 == val5); |
| |
| utree val6("ApplePie"); |
| BOOST_TEST(val4 < val6); |
| } |
| |
| { |
| utree val; |
| val.push_back(123); |
| val.push_back("Chuckie"); |
| BOOST_TEST(val.size() == 2); |
| utree val2; |
| val2.push_back(123.456); |
| val2.push_back("Mah Doggie"); |
| val.push_back(val2); |
| BOOST_TEST(val.size() == 3); |
| check(val, "( 123 \"Chuckie\" ( 123.456 \"Mah Doggie\" ) )"); |
| check(val.front(), "123"); |
| |
| utree val3; |
| val3.swap(val); |
| BOOST_TEST(val3.size() == 3); |
| check(val, "<nil>"); |
| val3.swap(val); |
| check(val, "( 123 \"Chuckie\" ( 123.456 \"Mah Doggie\" ) )"); |
| val.push_back("another string"); |
| BOOST_TEST(val.size() == 4); |
| check(val, "( 123 \"Chuckie\" ( 123.456 \"Mah Doggie\" ) \"another string\" )"); |
| val.pop_front(); |
| check(val, "( \"Chuckie\" ( 123.456 \"Mah Doggie\" ) \"another string\" )"); |
| utree::iterator i = val.begin(); |
| ++++i; |
| val.insert(i, "Right in the middle"); |
| BOOST_TEST(val.size() == 4); |
| check(val, "( \"Chuckie\" ( 123.456 \"Mah Doggie\" ) \"Right in the middle\" \"another string\" )"); |
| val.pop_back(); |
| check(val, "( \"Chuckie\" ( 123.456 \"Mah Doggie\" ) \"Right in the middle\" )"); |
| BOOST_TEST(val.size() == 3); |
| utree::iterator it = val.end(); --it; |
| val.erase(it); |
| check(val, "( \"Chuckie\" ( 123.456 \"Mah Doggie\" ) )"); |
| BOOST_TEST(val.size() == 2); |
| |
| val.insert(val.begin(), val2.begin(), val2.end()); |
| check(val, "( 123.456 \"Mah Doggie\" \"Chuckie\" ( 123.456 \"Mah Doggie\" ) )"); |
| BOOST_TEST(val.size() == 4); |
| } |
| |
| { |
| 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"); |
| check(val, "( 123 \"Mia\" \"Chuckie\" \"Poly\" \"Mochi\" )"); |
| } |
| |
| { |
| utree a, b; |
| BOOST_TEST(a == b); |
| a = 123; |
| BOOST_TEST(a != b); |
| b = 123; |
| BOOST_TEST(a == b); |
| a = 100.00; |
| BOOST_TEST(a < b); |
| |
| b = a = utree(); |
| BOOST_TEST(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(a == b); |
| b.push_back(4); |
| BOOST_TEST(a != b); |
| BOOST_TEST(a < b); |
| } |
| |
| { |
| utree a; |
| a.push_back(1); |
| a.push_back(2); |
| a.push_back(3); |
| a.push_back(4); |
| a.push_back(5); |
| a.push_back(6); |
| a.push_back(7); |
| a.push_back(8); |
| a.push_back(9); |
| a.push_back(10); |
| a.push_back(11); |
| a.push_back(12); |
| |
| BOOST_TEST(a[0] == utree(1)); |
| BOOST_TEST(a[1] == utree(2)); |
| BOOST_TEST(a[2] == utree(3)); |
| BOOST_TEST(a[3] == utree(4)); |
| BOOST_TEST(a[4] == utree(5)); |
| BOOST_TEST(a[5] == utree(6)); |
| BOOST_TEST(a[6] == utree(7)); |
| BOOST_TEST(a[7] == utree(8)); |
| BOOST_TEST(a[8] == utree(9)); |
| BOOST_TEST(a[9] == utree(10)); |
| BOOST_TEST(a[10] == utree(11)); |
| BOOST_TEST(a[11] == utree(12)); |
| } |
| |
| { |
| // test empty list |
| utree a; |
| a.push_back(1); |
| a.pop_front(); |
| check(a, "( )"); |
| |
| // the other way around |
| utree b; |
| b.push_front(1); |
| b.pop_back(); |
| check(b, "( )"); |
| } |
| |
| { // test references |
| utree val(123); |
| utree ref(boost::ref(val)); |
| check(ref, "123"); |
| BOOST_TEST(ref == utree(123)); |
| |
| val.clear(); |
| val.push_back(1); |
| val.push_back(2); |
| val.push_back(3); |
| val.push_back(4); |
| check(ref, "( 1 2 3 4 )"); |
| BOOST_TEST(ref[0] == utree(1)); |
| BOOST_TEST(ref[1] == utree(2)); |
| BOOST_TEST(ref[2] == utree(3)); |
| BOOST_TEST(ref[3] == utree(4)); |
| } |
| |
| { // put it in an array |
| |
| utree vals[] = { |
| utree(123), |
| utree("Hello, World"), |
| utree(123.456) |
| }; |
| |
| check(vals[0], "123"); |
| check(vals[1], "\"Hello, World\""); |
| check(vals[2], "123.456"); |
| } |
| |
| { // operators |
| |
| BOOST_TEST((utree(true) && utree(true)) == utree(true)); |
| BOOST_TEST((utree(true) || utree(false)) == utree(true)); |
| BOOST_TEST(!utree(true) == utree(false)); |
| |
| 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); |
| 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(ref[0] == utree(1)); |
| BOOST_TEST(ref[1] == utree(2)); |
| BOOST_TEST(ref[2] == utree(3)); |
| BOOST_TEST(ref[3] == utree(4)); |
| check(ref, "( 1 2 3 4 )"); |
| } |
| |
| { |
| // check the tag |
| utree x; |
| x.tag(123); |
| BOOST_TEST(x.tag() == 123); |
| } |
| |
| { |
| // test functions |
| utree f = scheme::stored_function<one_two_three>(); |
| f.eval(scheme::scope()); |
| } |
| |
| { |
| // shallow ranges |
| 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()), scheme::shallow); |
| |
| check(alias, "( 2 3 4 )"); |
| BOOST_TEST(alias.size() == 3); |
| BOOST_TEST(alias.front() == 2); |
| BOOST_TEST(alias.back() == 4); |
| BOOST_TEST(!alias.empty()); |
| BOOST_TEST(alias[1] == 3); |
| } |
| |
| { |
| // shallow string ranges |
| |
| using scheme::utf8_string_range; |
| using scheme::shallow; |
| |
| char const* s = "Hello, World"; |
| utree val(utf8_string_range(s, s + strlen(s)), shallow); |
| check(val, "\"Hello, World\""); |
| |
| utf8_string_range r = val.get<utf8_string_range>(); |
| utf8_string_range pf(r.begin()+1, r.end()-1); |
| val = utree(pf, shallow); |
| check(val, "\"ello, Worl\""); |
| } |
| |
| { |
| // any pointer |
| |
| using scheme::any_ptr; |
| |
| int n = 123; |
| utree up = any_ptr(&n); |
| BOOST_TEST(*up.get<int*>() == 123); |
| } |
| |
| return boost::report_errors(); |
| } |