Subject: [Boost-commit] svn:boost r70871 - in branches/quickbook-dev/tools/quickbook: src test/unit
From: dnljms_at_[hidden]
Date: 2011-04-02 13:45:11
Author: danieljames
Date: 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
New Revision: 70871
URL: http://svn.boost.org/trac/boost/changeset/70871
Log:
Quickbook: Alternative tst that's cheaper to copy.
Added:
branches/quickbook-dev/tools/quickbook/src/symbols.hpp (contents, props changed)
branches/quickbook-dev/tools/quickbook/test/unit/symbols_add_null.cpp (contents, props changed)
branches/quickbook-dev/tools/quickbook/test/unit/symbols_find_null.cpp (contents, props changed)
branches/quickbook-dev/tools/quickbook/test/unit/symbols_tests.cpp (contents, props changed)
Text files modified:
branches/quickbook-dev/tools/quickbook/src/actions.cpp | 7 ++++---
branches/quickbook-dev/tools/quickbook/src/actions.hpp | 3 +--
branches/quickbook-dev/tools/quickbook/src/actions_class.cpp | 25 ++-----------------------
branches/quickbook-dev/tools/quickbook/src/actions_class.hpp | 6 +-----
branches/quickbook-dev/tools/quickbook/test/unit/Jamfile.v2 | 5 +++++
5 files changed, 13 insertions(+), 33 deletions(-)
Modified: branches/quickbook-dev/tools/quickbook/src/actions.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/actions.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/actions.cpp 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
@@ -899,7 +899,6 @@
std::string phrase = values.consume().get_boostbook();
values.finish();
- actions.copy_macros_for_write();
actions.macro.add(
macro_id.begin()
, macro_id.end()
@@ -1805,7 +1804,6 @@
// scope the macros
string_symbols macro = actions.macro;
- std::size_t macro_change_depth = actions.macro_change_depth;
// scope the templates
//~ template_symbols templates = actions.templates; $$$ fixme $$$
@@ -1837,9 +1835,12 @@
// restore the macros
actions.macro = macro;
- actions.macro_change_depth = macro_change_depth;
// restore the templates
//~ actions.templates = templates; $$$ fixme $$$
+
+ // restore the __FILENAME__ macro
+ *boost::spirit::classic::find(actions.macro, "__FILENAME__")
+ = detail::path_to_generic(actions.filename_relative);
}
void phrase_to_docinfo_action_impl::operator()(iterator first, iterator last,
Modified: branches/quickbook-dev/tools/quickbook/src/actions.hpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/actions.hpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/actions.hpp 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
@@ -19,6 +19,7 @@
#include "utils.hpp"
#include "values.hpp"
#include "scoped.hpp"
+#include "symbols.hpp"
namespace quickbook
{
@@ -51,8 +52,6 @@
return quickbook_range(0, max_);
}
- typedef cl::symbols<std::string> string_symbols;
-
int load_snippets(std::string const& file, std::vector<template_symbol>& storage,
std::string const& extension);
std::string syntax_highlight(
Modified: branches/quickbook-dev/tools/quickbook/src/actions_class.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/actions_class.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/actions_class.cpp 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
@@ -47,7 +47,6 @@
, filename(filein_)
, filename_relative(filein_.filename())
, xinclude_base(xinclude_base_)
- , macro_change_depth(0)
, macro()
, section_level(0)
, min_section_level(0)
@@ -101,7 +100,7 @@
boost::make_tuple(
filename
, xinclude_base
- , macro_change_depth
+ , macro
, section_level
, min_section_level
, section_id
@@ -116,32 +115,12 @@
values.builder.save();
}
- // Pushing and popping the macro symbol table is pretty expensive, so
- // instead implement a sort of 'stack on write'. Call this whenever a
- // change is made to the macro table, and it'll stack the current macros
- // if necessary. Would probably be better to implement macros in a less
- // expensive manner.
- void actions::copy_macros_for_write()
- {
- if(macro_change_depth != state_stack.size())
- {
- macro_stack.push(macro);
- macro_change_depth = state_stack.size();
- }
- }
-
void actions::pop()
{
- if(macro_change_depth == state_stack.size())
- {
- macro = macro_stack.top();
- macro_stack.pop();
- }
-
boost::tie(
filename
, xinclude_base
- , macro_change_depth
+ , macro
, section_level
, min_section_level
, section_id
Modified: branches/quickbook-dev/tools/quickbook/src/actions_class.hpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/actions_class.hpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/actions_class.hpp 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
@@ -71,7 +71,6 @@
// (relative to the original file
// or include path).
fs::path xinclude_base;
- std::size_t macro_change_depth;
string_symbols macro;
int section_level;
int min_section_level;
@@ -82,7 +81,7 @@
typedef boost::tuple<
fs::path
, fs::path
- , std::size_t
+ , string_symbols
, int
, int
, std::string
@@ -91,8 +90,6 @@
state_tuple;
std::stack<state_tuple> state_stack;
- // Stack macros separately as copying macros is expensive.
- std::stack<string_symbols> macro_stack;
// temporary or global state
int template_depth;
@@ -105,7 +102,6 @@
int context;
// push/pop the states and the streams
- void copy_macros_for_write();
void push();
void pop();
quickbook_grammar& grammar() const;
Added: branches/quickbook-dev/tools/quickbook/src/symbols.hpp
==============================================================================
--- (empty file)
+++ branches/quickbook-dev/tools/quickbook/src/symbols.hpp 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
@@ -0,0 +1,279 @@
+/*=============================================================================
+ Copyright (c) 2001-2003 Joel de Guzman
+ Copyright (c) 2011 Daniel James
+ http://spirit.sourceforge.net/
+
+ 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)
+=============================================================================*/
+#ifndef QUICKBOOK_SYMBOLS_IPP
+#define QUICKBOOK_SYMBOLS_IPP
+
+///////////////////////////////////////////////////////////////////////////////
+
+#include <boost/spirit/home/classic/symbols.hpp>
+#include <boost/spirit/home/classic/core/assert.hpp>
+#include <boost/intrusive_ptr.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+namespace quickbook
+{
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// tst class
+//
+// This it the Ternary Search Tree from
+// <boost/spirit/home/classic/symbols/impl/tst.ipp> adapted to be cheap
+// to copy.
+//
+// Ternary Search Tree implementation. The data structure is faster than
+// hashing for many typical search problems especially when the search
+// interface is iterator based. Searching for a string of length k in a
+// ternary search tree with n strings will require at most O(log n+k)
+// character comparisons. TSTs are many times faster than hash tables
+// for unsuccessful searches since mismatches are discovered earlier
+// after examining only a few characters. Hash tables always examine an
+// entire key when searching.
+//
+// For details see http://www.cs.princeton.edu/~rs/strings/.
+//
+// *** This is a low level class and is
+// not meant for public consumption ***
+//
+///////////////////////////////////////////////////////////////////////////////
+
+ template <typename T, typename CharT>
+ struct tst_node
+ {
+ tst_node(CharT value_)
+ : reference_count(0)
+ , value(value_)
+ , data(0)
+ {
+ }
+
+ tst_node(tst_node const& other)
+ : reference_count(0)
+ , value(other.value)
+ , left(other.left)
+ , middle(other.middle)
+ , right(other.right)
+ , data(0)
+ {
+ if (other.data)
+ data = new T(*other.data);
+ }
+
+ tst_node& operator=(tst_node other)
+ {
+ swap(other);
+ return *this;
+ }
+
+ ~tst_node()
+ {
+ delete data;
+ }
+
+ void swap(tst_node& x, tst_node& y)
+ {
+ boost::swap(x.reference_count, y.reference_count);
+ boost::swap(x.value, y.value);
+ boost::swap(x.left, y.left);
+ boost::swap(x.middle, y.middle);
+ boost::swap(x.right, y.right);
+ boost::swap(x.data, y.data);
+ }
+
+ short reference_count;
+ CharT value;
+ boost::intrusive_ptr<tst_node> left;
+ boost::intrusive_ptr<tst_node> middle;
+ boost::intrusive_ptr<tst_node> right;
+ T* data;
+ };
+
+ template <typename T, typename CharT>
+ void intrusive_ptr_add_ref(tst_node<T, CharT>* ptr)
+ { ++ptr->reference_count; }
+
+ template <typename T, typename CharT>
+ void intrusive_ptr_release(tst_node<T, CharT>* ptr)
+ { if(--ptr->reference_count == 0) delete ptr; }
+
+
+ ///////////////////////////////////////////////////////////////////////////
+ template <typename T, typename CharT>
+ class tst
+ {
+ public:
+
+ struct search_info
+ {
+ T* data;
+ std::size_t length;
+ };
+
+ void swap(tst& other)
+ {
+ root.swap(other.root);
+ }
+
+ // TODO: Make sure you check for readdition.
+ template <typename IteratorT>
+ T* add(IteratorT first, IteratorT const& last, T const& data)
+ {
+ if (first == last)
+ return 0;
+
+ node_ptr* np = &root;
+ CharT ch = *first;
+
+ BOOST_SPIRIT_ASSERT((first == last || ch != 0)
+ && "Won't add string containing null character");
+
+ for (;;)
+ {
+ if (!*np || ch == 0)
+ {
+ node_ptr right = *np;
+ *np = new node_t(ch);
+ if (right)
+ (*np)->right = right;
+ }
+ else if ((*np)->reference_count > 1)
+ {
+ *np = new node_t(**np);
+ }
+
+ if (ch < (*np)->value)
+ {
+ np = &(*np)->left;
+ }
+ else
+ {
+ if (ch == (*np)->value)
+ {
+ if (ch == 0)
+ {
+ if ((*np)->data == 0)
+ {
+ (*np)->data = new T(data);
+ return (*np)->data;
+ }
+ else
+ {
+ // re-addition is disallowed
+ return 0;
+ }
+ }
+ ++first;
+ ch = (first == last) ? CharT(0) : *first;
+ BOOST_SPIRIT_ASSERT((first == last || ch != 0)
+ && "Won't add string containing null character");
+ np = &(*np)->middle;
+ }
+ else
+ {
+ np = &(*np)->right;
+ }
+ }
+ }
+ }
+
+ template <typename ScannerT>
+ search_info find(ScannerT const& scan) const
+ {
+ search_info result = { 0, 0 };
+ if (scan.at_end()) {
+ return result;
+ }
+
+ typedef typename ScannerT::iterator_t iterator_t;
+ node_ptr np = root;
+ CharT ch = *scan;
+ iterator_t save = scan.first;
+ iterator_t latest = scan.first;
+ std::size_t latest_len = 0;
+
+ while (np)
+ {
+
+ if (ch < np->value) // => go left!
+ {
+ if (np->value == 0)
+ {
+ result.data = np->data;
+ if (result.data)
+ {
+ latest = scan.first;
+ latest_len = result.length;
+ }
+ }
+
+ np = np->left;
+ }
+ else if (ch == np->value) // => go middle!
+ {
+ // Matching the null character is not allowed.
+ if (np->value == 0)
+ {
+ result.data = np->data;
+ if (result.data)
+ {
+ latest = scan.first;
+ latest_len = result.length;
+ }
+ break;
+ }
+
+ ++scan;
+ ch = scan.at_end() ? CharT(0) : *scan;
+ np = np->middle;
+ ++result.length;
+ }
+ else // (ch > np->value) => go right!
+ {
+ if (np->value == 0)
+ {
+ result.data = np->data;
+ if (result.data)
+ {
+ latest = scan.first;
+ latest_len = result.length;
+ }
+ }
+
+ np = np->right;
+ }
+ }
+
+ if (result.data == 0)
+ {
+ scan.first = save;
+ }
+ else
+ {
+ scan.first = latest;
+ result.length = latest_len;
+ }
+ return result;
+ }
+
+ private:
+
+ typedef tst_node<T, CharT> node_t;
+ typedef boost::intrusive_ptr<node_t> node_ptr;
+ node_ptr root;
+ };
+
+ typedef boost::spirit::classic::symbols<
+ std::string,
+ char,
+ quickbook::tst<std::string, char>
+ > string_symbols;
+} // namespace quickbook
+
+#endif
Modified: branches/quickbook-dev/tools/quickbook/test/unit/Jamfile.v2
==============================================================================
--- branches/quickbook-dev/tools/quickbook/test/unit/Jamfile.v2 (original)
+++ branches/quickbook-dev/tools/quickbook/test/unit/Jamfile.v2 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
@@ -7,3 +7,8 @@
run values_test.cpp ../../src/values.cpp ;
run post_process_test.cpp ../../src/post_process.cpp ;
run iterator_tests.cpp ../../src/values.cpp ;
+
+# Copied from spirit
+run symbols_tests.cpp ;
+run symbols_add_null.cpp ;
+run symbols_find_null.cpp ;
\ No newline at end of file
Added: branches/quickbook-dev/tools/quickbook/test/unit/symbols_add_null.cpp
==============================================================================
--- (empty file)
+++ branches/quickbook-dev/tools/quickbook/test/unit/symbols_add_null.cpp 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
@@ -0,0 +1,79 @@
+/*=============================================================================
+ Copyright (c) 2004 Joao Abecasis
+ http://spirit.sourceforge.net/
+
+ 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)
+=============================================================================*/
+
+// This test requires NDEBUG to be undefined, because it depends on
+// BOOST_SPIRIT_ASSERT throwing an exception.
+#ifdef NDEBUG
+# undef NDEBUG
+#endif
+
+#include <stdexcept>
+
+#define BOOST_SPIRIT_ASSERT_EXCEPTION ::spirit_exception
+
+struct spirit_exception : std::exception
+{
+ spirit_exception(char const * msg)
+ : message(msg)
+ {
+ }
+ ~spirit_exception() throw() {}
+
+ char const* what() const throw() { return message; }
+
+ char const * message;
+};
+
+#include <boost/spirit/include/classic_scanner.hpp>
+#include <boost/utility/addressof.hpp>
+#include "symbols.hpp"
+
+#include <boost/detail/lightweight_test.hpp>
+
+typedef char char_type;
+typedef char const * iterator;
+
+char_type data_[] = "whatever";
+
+iterator begin = data_;
+iterator end = data_
+ + sizeof(data_)/sizeof(char_type); // Yes, this is an intentional bug ;)
+
+char_type data2_[] = "\0something";
+iterator begin2 = data2_;
+iterator end2 = data2_ + sizeof(data2_)/sizeof(char_type) - 1;
+
+int main()
+{
+ typedef BOOST_SPIRIT_CLASSIC_NS::scanner<> scanner;
+ typedef quickbook::tst<void *, char_type> symbols;
+
+ symbols symbols_;
+
+ try
+ {
+ // It is not ok to add strings containing the null character.
+ symbols_.add(begin, end, (void*) boost::addressof(symbols_));
+ BOOST_TEST(0);
+ }
+ catch (spirit_exception &/*e*/)
+ {
+ }
+
+ try
+ {
+ // It is not ok to add strings containing the null character.
+ symbols_.add(begin2, end2, (void*) boost::addressof(symbols_));
+ BOOST_TEST(0);
+ }
+ catch (spirit_exception &/*e*/)
+ {
+ }
+ return boost::report_errors();
+}
Added: branches/quickbook-dev/tools/quickbook/test/unit/symbols_find_null.cpp
==============================================================================
--- (empty file)
+++ branches/quickbook-dev/tools/quickbook/test/unit/symbols_find_null.cpp 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
@@ -0,0 +1,35 @@
+/*=============================================================================
+ Copyright (c) 2004 Joao Abecasis
+ http://spirit.sourceforge.net/
+
+ 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)
+=============================================================================*/
+
+#include <boost/spirit/include/classic_scanner.hpp>
+#include <boost/utility/addressof.hpp>
+#include "symbols.hpp"
+
+typedef char char_type;
+typedef char const * iterator;
+
+char_type data_[] = "whatever";
+
+iterator begin = data_;
+iterator end = data_
+ + sizeof(data_)/sizeof(char_type); // Yes, this is an intentional bug ;)
+
+int main()
+{
+ typedef BOOST_SPIRIT_CLASSIC_NS::scanner<> scanner;
+ typedef quickbook::tst<void *, char_type> symbols;
+
+ symbols symbols_;
+
+ symbols_.add(begin, end - 1, (void*) boost::addressof(symbols_));
+
+ // The symbol table parser should not choke on input containing the null
+ // character.
+ symbols_.find(scanner(begin, end));
+}
Added: branches/quickbook-dev/tools/quickbook/test/unit/symbols_tests.cpp
==============================================================================
--- (empty file)
+++ branches/quickbook-dev/tools/quickbook/test/unit/symbols_tests.cpp 2011-04-02 13:45:09 EDT (Sat, 02 Apr 2011)
@@ -0,0 +1,356 @@
+/*=============================================================================
+ Copyright (c) 1998-2003 Joel de Guzman
+ Copyright (c) 2003 Martin Wille
+ http://spirit.sourceforge.net/
+
+ 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)
+=============================================================================*/
+#include <iostream>
+#include <string>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/spirit/include/classic_core.hpp>
+#include <boost/spirit/include/classic_symbols.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/swap.hpp>
+#include "symbols.hpp"
+
+///////////////////////////////////////////////////////////////////////////////
+using namespace std;
+using namespace BOOST_SPIRIT_CLASSIC_NS;
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename IteratorT>
+bool
+equal(IteratorT p, IteratorT q)
+{
+ while (*p && *p == *q)
+ {
+ ++p;
+ ++q;
+ }
+ return *p == *q;
+}
+
+template <class SymbolsT, typename CharT>
+void
+docheck
+(
+ SymbolsT const &sym,
+ CharT const *candidate,
+ bool hit,
+ CharT const *result,
+ int length
+)
+{
+ parse_info<CharT const*> info = parse(candidate, sym);
+
+#define correctly_matched hit == info.hit
+#define correct_match_length unsigned(length) == info.length
+#define correct_tail equal(candidate + (hit?1:0)*length, result)
+
+ BOOST_TEST(correctly_matched);
+
+ if (hit)
+ {
+ BOOST_TEST(correct_match_length);
+ BOOST_TEST(correct_tail);
+ }
+ else
+ {
+ BOOST_TEST(correct_tail);
+ }
+}
+
+template <typename T>
+struct store_action
+{
+ store_action(T const &v) : value(v) {}
+ void operator()(T &v) const { v = value; }
+private:
+ T const value;
+};
+
+template <typename T>
+store_action<T>
+store(T const &v)
+{
+ return v;
+}
+
+template <typename T>
+struct check_action
+{
+ check_action(T const &v) : value(v) {}
+
+#define correct_value_stored (v==value)
+ void operator()(T const &v) const { BOOST_TEST(correct_value_stored); }
+private:
+ T const value;
+};
+
+template <typename T>
+check_action<T>
+docheck(T const &v)
+{
+ return v;
+}
+
+static void
+default_constructible()
+{ // this actually a compile time test
+ symbols<int, char, quickbook::tst<int, char> > ns1;
+ symbols<int, wchar_t, quickbook::tst<int, wchar_t> > ws1;
+ symbols<std::string, char, quickbook::tst<std::string, char> > ns2;
+ symbols<std::string, wchar_t, quickbook::tst<std::string, wchar_t> > ws2;
+
+ (void)ns1; (void)ws1; (void)ns2; (void)ws2;
+}
+
+typedef symbols<int, char, quickbook::tst<int, char> > nsymbols;
+typedef symbols<int, wchar_t, quickbook::tst<int, wchar_t> > wsymbols;
+
+static void
+narrow_match_tests()
+{
+ nsymbols sym;
+ sym = "pineapple", "orange", "banana", "applepie", "apple";
+
+ docheck(sym, "pineapple", true, "", 9);
+ docheck(sym, "orange", true, "", 6);
+ docheck(sym, "banana", true, "", 6);
+ docheck(sym, "apple", true, "", 5);
+ docheck(sym, "pizza", false, "pizza", -1);
+ docheck(sym, "steak", false, "steak", -1);
+ docheck(sym, "applepie", true, "", 8);
+ docheck(sym, "bananarama", true, "rama", 6);
+ docheck(sym, "applet", true, "t", 5);
+ docheck(sym, "applepi", true, "pi", 5);
+ docheck(sym, "appl", false, "appl", -1);
+
+ docheck(sym, "pineapplez", true, "z", 9);
+ docheck(sym, "orangez", true, "z", 6);
+ docheck(sym, "bananaz", true, "z", 6);
+ docheck(sym, "applez", true, "z", 5);
+ docheck(sym, "pizzaz", false, "pizzaz", -1);
+ docheck(sym, "steakz", false, "steakz", -1);
+ docheck(sym, "applepiez", true, "z", 8);
+ docheck(sym, "bananaramaz", true, "ramaz", 6);
+ docheck(sym, "appletz", true, "tz", 5);
+ docheck(sym, "applepix", true, "pix", 5);
+}
+
+static void
+narrow_copy_ctor_tests()
+{
+ nsymbols sym;
+ sym = "pineapple", "orange", "banana", "applepie", "apple";
+
+ nsymbols sym2(sym);
+ docheck(sym2, "pineapple", true, "", 9);
+ docheck(sym2, "pizza", false, "pizza", -1);
+ docheck(sym2, "bananarama", true, "rama", 6);
+}
+
+static void
+narrow_assigment_operator_tests()
+{
+ nsymbols sym;
+ sym = "pineapple", "orange", "banana", "applepie", "apple";
+
+ nsymbols sym2;
+ sym2 = sym;
+
+ docheck(sym2, "pineapple", true, "", 9);
+ docheck(sym2, "pizza", false, "pizza", -1);
+ docheck(sym2, "bananarama", true, "rama", 6);
+}
+
+static void
+narrow_swap_tests()
+{
+ nsymbols sym, sym2;
+ sym = "pineapple", "orange", "banana", "applepie", "apple";
+ sym2 = "potato", "cucumber", "cauliflower", "carrot";
+
+ boost::swap(sym, sym2);
+
+ docheck(sym2, "pineapple", true, "", 9);
+ docheck(sym2, "pizza", false, "pizza", -1);
+ docheck(sym2, "bananarama", true, "rama", 6);
+ docheck(sym, "potatoe", true, "e", 6);
+ docheck(sym, "cauliflour", false, "cauliflour", -1);
+}
+
+static void
+narrow_value_tests()
+{ // also tests the add member functions
+ nsymbols sym;
+
+ sym = "orange", "banana";
+ sym.add("pineapple",1234);
+ sym.add("lemon");
+
+ parse("orange", sym[store(12345)]);
+ parse("orange", sym[docheck(12345)]);
+ parse("pineapple", sym[docheck(1234)]);
+ parse("banana", sym[docheck(int())]);
+ parse("lemon", sym[docheck(int())]);
+}
+
+static void
+narrow_free_functions_tests()
+{
+ nsymbols sym;
+
+#define add_returned_non_null_value (res!=0)
+#define add_returned_null (res==0)
+#define find_returned_non_null_value (res!=0)
+#define find_returned_null (res==0)
+
+ int *res = add(sym,"pineapple");
+ BOOST_TEST(add_returned_non_null_value);
+ res = add(sym,"pineapple");
+ BOOST_TEST(add_returned_null);
+
+ res = find(sym, "pineapple");
+ BOOST_TEST(find_returned_non_null_value);
+ res = find(sym, "banana");
+ BOOST_TEST(find_returned_null);
+}
+
+static void
+wide_match_tests()
+{
+ wsymbols sym;
+ sym = L"pineapple", L"orange", L"banana", L"applepie", L"apple";
+
+ docheck(sym, L"pineapple", true, L"", 9);
+ docheck(sym, L"orange", true, L"", 6);
+ docheck(sym, L"banana", true, L"", 6);
+ docheck(sym, L"apple", true, L"", 5);
+ docheck(sym, L"pizza", false, L"pizza", -1);
+ docheck(sym, L"steak", false, L"steak", -1);
+ docheck(sym, L"applepie", true, L"", 8);
+ docheck(sym, L"bananarama", true, L"rama", 6);
+ docheck(sym, L"applet", true, L"t", 5);
+ docheck(sym, L"applepi", true, L"pi", 5);
+ docheck(sym, L"appl", false, L"appl", -1);
+
+ docheck(sym, L"pineapplez", true, L"z", 9);
+ docheck(sym, L"orangez", true, L"z", 6);
+ docheck(sym, L"bananaz", true, L"z", 6);
+ docheck(sym, L"applez", true, L"z", 5);
+ docheck(sym, L"pizzaz", false, L"pizzaz", -1);
+ docheck(sym, L"steakz", false, L"steakz", -1);
+ docheck(sym, L"applepiez", true, L"z", 8);
+ docheck(sym, L"bananaramaz", true, L"ramaz", 6);
+ docheck(sym, L"appletz", true, L"tz", 5);
+ docheck(sym, L"applepix", true, L"pix", 5);
+}
+
+static void
+wide_copy_ctor_tests()
+{
+ wsymbols sym;
+ sym = L"pineapple", L"orange", L"banana", L"applepie", L"apple";
+
+ wsymbols sym2(sym);
+ docheck(sym2, L"pineapple", true, L"", 9);
+ docheck(sym2, L"pizza", false, L"pizza", -1);
+ docheck(sym2, L"bananarama", true, L"rama", 6);
+}
+
+static void
+wide_assigment_operator_tests()
+{
+ wsymbols sym;
+ sym = L"pineapple", L"orange", L"banana", L"applepie", L"apple";
+
+ wsymbols sym2;
+ sym2 = sym;
+
+ docheck(sym2, L"pineapple", true, L"", 9);
+ docheck(sym2, L"pizza", false, L"pizza", -1);
+ docheck(sym2, L"bananarama", true, L"rama", 6);
+}
+
+static void
+wide_swap_tests()
+{
+ wsymbols sym, sym2;
+ sym = L"pineapple", L"orange", L"banana", L"applepie", L"apple";
+ sym2 = L"potato", L"cucumber", L"cauliflower", L"carrot";
+
+ boost::swap(sym, sym2);
+
+ docheck(sym2, L"pineapple", true, L"", 9);
+ docheck(sym2, L"pizza", false, L"pizza", -1);
+ docheck(sym2, L"bananarama", true, L"rama", 6);
+ docheck(sym, L"potatoe", true, L"e", 6);
+ docheck(sym, L"cauliflour", false, L"cauliflour", -1);
+}
+
+static void
+wide_value_tests()
+{ // also tests the add member functions
+ wsymbols sym;
+
+ sym = L"orange", L"banana";
+ sym.add(L"pineapple",1234);
+ sym.add(L"lemon");
+
+ parse(L"orange", sym[store(12345)]);
+ parse(L"orange", sym[docheck(12345)]);
+ parse(L"pineapple", sym[docheck(1234)]);
+ parse(L"banana", sym[docheck(int())]);
+ parse(L"lemon", sym[docheck(int())]);
+}
+
+static void
+wide_free_functions_tests()
+{
+ wsymbols sym;
+
+ int *res = add(sym,L"pineapple");
+ BOOST_TEST(add_returned_non_null_value);
+ res = add(sym,L"pineapple");
+ BOOST_TEST(add_returned_null);
+
+ res = find(sym, L"pineapple");
+ BOOST_TEST(find_returned_non_null_value);
+ res = find(sym, L"banana");
+ BOOST_TEST(find_returned_null);
+}
+
+static
+void free_add_find_functions_tests()
+{
+ nsymbols sym;
+ BOOST_TEST(*add(sym, "a", 0) == 0);
+ BOOST_TEST(*add(sym, "a2", 1) == 1);
+ BOOST_TEST(find(sym, "a2"));
+ BOOST_TEST(find(sym, "a"));
+}
+
+int
+main()
+{
+ default_constructible();
+ narrow_match_tests();
+ narrow_copy_ctor_tests();
+ narrow_assigment_operator_tests();
+ narrow_swap_tests();
+ narrow_value_tests();
+ narrow_free_functions_tests();
+ wide_match_tests();
+ wide_copy_ctor_tests();
+ wide_assigment_operator_tests();
+ wide_swap_tests();
+ wide_value_tests();
+ wide_free_functions_tests();
+ free_add_find_functions_tests();
+ return boost::report_errors();
+}