| /*============================================================================= |
| Copyright (c) 2010-2011 Daniel James |
| |
| 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) |
| =============================================================================*/ |
| |
| // Some very light testing for quickbook::value and friends. |
| // Just for a few issues that came up during development. |
| |
| #include <boost/detail/lightweight_test.hpp> |
| #include <boost/range/algorithm/equal.hpp> |
| #include <vector> |
| #include "values.hpp" |
| |
| void empty_tests() |
| { |
| quickbook::value q; |
| BOOST_TEST(q.empty()); |
| BOOST_TEST(!q.is_list()); |
| BOOST_TEST(!q.is_string()); |
| } |
| |
| void qbk_tests() |
| { |
| std::string src = "Source"; |
| quickbook::value q = quickbook::qbk_value( |
| quickbook::iterator(src.begin()), |
| quickbook::iterator(src.end())); |
| BOOST_TEST_EQ(q.get_quickbook(), src); |
| } |
| |
| void sort_test() |
| { |
| quickbook::value_builder b; |
| b.insert(quickbook::bbk_value("a", 10)); |
| b.insert(quickbook::bbk_value("b", 2)); |
| b.insert(quickbook::bbk_value("c", 5)); |
| b.insert(quickbook::bbk_value("d", 8)); |
| b.sort_list(); |
| |
| quickbook::value_consumer c = b.release(); |
| BOOST_TEST(c.check(2)); BOOST_TEST_EQ(c.consume(2).get_boostbook(), "b"); |
| BOOST_TEST(c.check(5)); c.consume(5); |
| BOOST_TEST(c.check(8)); c.consume(8); |
| BOOST_TEST(c.check(10)); c.consume(10); |
| BOOST_TEST(!c.check()); |
| } |
| |
| void multiple_list_test() |
| { |
| quickbook::value_builder list1; |
| quickbook::value_builder list2; |
| |
| list1.insert(quickbook::bbk_value("b", 10)); |
| |
| { |
| quickbook::value p1 = quickbook::bbk_value("a", 5); |
| list1.insert(p1); |
| list2.insert(p1); |
| } |
| |
| list2.insert(quickbook::bbk_value("c", 3)); |
| |
| quickbook::value_consumer l1 = list1.release(); |
| quickbook::value_consumer l2 = list2.release(); |
| |
| BOOST_TEST(l1.check(10)); |
| BOOST_TEST_EQ(l1.consume(10).get_boostbook(), "b"); |
| BOOST_TEST(l1.check(5)); |
| BOOST_TEST_EQ(l1.consume(5).get_boostbook(), "a"); |
| BOOST_TEST(!l1.check()); |
| |
| BOOST_TEST(l2.check(5)); |
| BOOST_TEST_EQ(l2.consume(5).get_boostbook(), "a"); |
| BOOST_TEST(l2.check(3)); |
| BOOST_TEST_EQ(l2.consume(3).get_boostbook(), "c"); |
| BOOST_TEST(!l2.check()); |
| } |
| |
| void store_test1() |
| { |
| quickbook::stored_value q; |
| |
| { |
| std::string src = "Hello"; |
| quickbook::value q1 = quickbook::qbk_value( |
| quickbook::iterator(src.begin()), |
| quickbook::iterator(src.end()), |
| 5); |
| |
| BOOST_TEST_EQ(q1.get_quickbook(), "Hello"); |
| q = q1; |
| BOOST_TEST_EQ(q.get_quickbook(), "Hello"); |
| BOOST_TEST_EQ(q1.get_quickbook(), "Hello"); |
| } |
| |
| BOOST_TEST_EQ(q.get_quickbook(), "Hello"); |
| } |
| |
| void store_test2_check(quickbook::value const& q) |
| { |
| quickbook::value_consumer l1 = q; |
| BOOST_TEST(l1.check(5)); |
| BOOST_TEST_EQ(l1.consume(5).get_quickbook(), "Hello"); |
| BOOST_TEST(l1.check(10)); |
| BOOST_TEST_EQ(l1.consume(10).get_boostbook(), "World"); |
| BOOST_TEST(!l1.check()); |
| } |
| |
| void store_test2() |
| { |
| quickbook::stored_value q; |
| |
| { |
| quickbook::value_builder list1; |
| std::string src = "Hello"; |
| list1.insert(quickbook::qbk_value( |
| quickbook::iterator(src.begin()), |
| quickbook::iterator(src.end()), |
| 5)); |
| list1.insert(quickbook::bbk_value("World", 10)); |
| |
| quickbook::value q2 = list1.release(); |
| |
| store_test2_check(q2); |
| q = q2; |
| store_test2_check(q); |
| store_test2_check(q2); |
| } |
| store_test2_check(q); |
| } |
| |
| void equality_tests() |
| { |
| std::vector<quickbook::value> distinct_values; |
| |
| quickbook::value_builder builder; |
| quickbook::value nil; |
| |
| // 0: nil |
| distinct_values.push_back(nil); |
| |
| // 1: [] |
| distinct_values.push_back(builder.release()); |
| |
| // 2: [nil] |
| builder.insert(nil); |
| distinct_values.push_back(builder.release()); |
| |
| for(int i = 0; i < distinct_values.size(); ++i) |
| for(int j = 0; j < distinct_values.size(); ++j) |
| if ((i == j) != (distinct_values[i] == distinct_values[j])) |
| { |
| BOOST_ERROR("Value mismatch."); |
| BOOST_LIGHTWEIGHT_TEST_OSTREAM |
| << "\tat " << i << ", " << j << std::endl; |
| } |
| } |
| |
| int main() |
| { |
| empty_tests(); |
| qbk_tests(); |
| sort_test(); |
| multiple_list_test(); |
| store_test1(); |
| store_test2(); |
| equality_tests(); |
| |
| return boost::report_errors(); |
| } |