summaryrefslogtreecommitdiff
path: root/libs/algorithm/string/test
diff options
context:
space:
mode:
Diffstat (limited to 'libs/algorithm/string/test')
-rw-r--r--libs/algorithm/string/test/Jamfile.v274
-rw-r--r--libs/algorithm/string/test/conv_test.cpp94
-rw-r--r--libs/algorithm/string/test/find_format_test.cpp162
-rw-r--r--libs/algorithm/string/test/find_test.cpp273
-rw-r--r--libs/algorithm/string/test/join_test.cpp78
-rw-r--r--libs/algorithm/string/test/predicate_test.cpp160
-rw-r--r--libs/algorithm/string/test/regex_test.cpp158
-rw-r--r--libs/algorithm/string/test/replace_test.cpp321
-rw-r--r--libs/algorithm/string/test/split_test.cpp193
-rw-r--r--libs/algorithm/string/test/trim_test.cpp202
10 files changed, 1715 insertions, 0 deletions
diff --git a/libs/algorithm/string/test/Jamfile.v2 b/libs/algorithm/string/test/Jamfile.v2
new file mode 100644
index 000000000..7f60df703
--- /dev/null
+++ b/libs/algorithm/string/test/Jamfile.v2
@@ -0,0 +1,74 @@
+# Boost string_algo library test suite Jamfile ----------------------------
+#
+# Copyright Pavol Droba 2002-2003. 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)
+#
+# See http://www.boost.org for updates, documentation, and revision history.
+
+import testing ;
+
+alias unit_test_framework
+ : # sources
+ /boost//unit_test_framework
+ ;
+
+test-suite algorithm/string
+ : [ run
+ trim_test.cpp unit_test_framework
+ : :
+ :
+ : trim
+ ]
+ [ run
+ conv_test.cpp unit_test_framework
+ : :
+ :
+ : conv
+ ]
+ [ run
+ predicate_test.cpp unit_test_framework
+ : :
+ :
+ : predicate
+ ]
+ [ run
+ find_test.cpp unit_test_framework
+ : :
+ :
+ : find
+ ]
+ [ run
+ split_test.cpp unit_test_framework
+ : :
+ :
+ : split
+ ]
+ [ run
+ join_test.cpp unit_test_framework
+ : :
+ :
+ : join
+ ]
+ [ run
+ replace_test.cpp unit_test_framework
+ : :
+ :
+ : replace
+ ]
+ [ run
+ regex_test.cpp unit_test_framework
+ ../../../regex/build//boost_regex
+ : :
+ :
+ : regex
+ ]
+ [ run
+ find_format_test.cpp unit_test_framework
+ : :
+ :
+ : find_format
+ ]
+ ;
+
diff --git a/libs/algorithm/string/test/conv_test.cpp b/libs/algorithm/string/test/conv_test.cpp
new file mode 100644
index 000000000..c583d3efe
--- /dev/null
+++ b/libs/algorithm/string/test/conv_test.cpp
@@ -0,0 +1,94 @@
+// Boost string_algo library conv_test.cpp file ---------------------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/algorithm/string/case_conv.hpp>
+
+// Include unit test framework
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <iostream>
+#include <algorithm>
+#include <boost/test/test_tools.hpp>
+
+using namespace std;
+using namespace boost;
+
+void conv_test()
+{
+ string str1("AbCdEfG 123 xxxYYYzZzZ");
+ string str2("AbCdEfG 123 xxxYYYzZzZ");
+ string str3("");
+ const char pch[]="AbCdEfG 123 xxxYYYzZzZ";
+ unsigned int pchlen=sizeof(pch);
+
+ char* pch1=new char[pchlen];
+ std::copy(pch, pch+pchlen, pch1);
+ char* pch2=new char[pchlen];
+ std::copy(pch, pch+pchlen, pch2);
+
+ // *** iterator tests *** //
+
+ string strout;
+ to_lower_copy( back_inserter(strout), str1 );
+ BOOST_CHECK( strout=="abcdefg 123 xxxyyyzzzz" );
+ strout.clear();
+ to_upper_copy( back_inserter(strout), str1 );
+ BOOST_CHECK( strout=="ABCDEFG 123 XXXYYYZZZZ" );
+
+ strout.clear();
+ to_lower_copy( back_inserter(strout), "AbCdEfG 123 xxxYYYzZzZ" );
+ BOOST_CHECK( strout=="abcdefg 123 xxxyyyzzzz" );
+ strout.clear();
+ to_upper_copy( back_inserter(strout), "AbCdEfG 123 xxxYYYzZzZ" );
+ BOOST_CHECK( strout=="ABCDEFG 123 XXXYYYZZZZ" );
+
+ strout.clear();
+ to_lower_copy( back_inserter(strout), pch1 );
+ BOOST_CHECK( strout=="abcdefg 123 xxxyyyzzzz" );
+ strout.clear();
+ to_upper_copy( back_inserter(strout), pch1 );
+ BOOST_CHECK( strout=="ABCDEFG 123 XXXYYYZZZZ" );
+
+ // *** value passing tests *** //
+
+ BOOST_CHECK( to_lower_copy( str1 )=="abcdefg 123 xxxyyyzzzz" );
+ BOOST_CHECK( to_upper_copy( str1 )=="ABCDEFG 123 XXXYYYZZZZ" );
+
+ BOOST_CHECK( to_lower_copy( str3 )=="" );
+ BOOST_CHECK( to_upper_copy( str3 )=="" );
+
+ // *** inplace tests *** //
+
+ to_lower( str1 );
+ BOOST_CHECK( str1=="abcdefg 123 xxxyyyzzzz" );
+ to_upper( str2 );
+ BOOST_CHECK( str2=="ABCDEFG 123 XXXYYYZZZZ" );
+
+ // c-string modification
+ to_lower( pch1 );
+ BOOST_CHECK( string(pch1)=="abcdefg 123 xxxyyyzzzz" );
+ to_upper( pch2 );
+ BOOST_CHECK( string(pch2)=="ABCDEFG 123 XXXYYYZZZZ" );
+
+ to_lower( str3 );
+ BOOST_CHECK( str3=="" );
+ to_upper( str3 );
+ BOOST_CHECK( str3=="" );
+
+ delete[] pch1;
+ delete[] pch2;
+}
+
+// test main
+BOOST_AUTO_TEST_CASE( test_main )
+{
+ conv_test();
+}
diff --git a/libs/algorithm/string/test/find_format_test.cpp b/libs/algorithm/string/test/find_format_test.cpp
new file mode 100644
index 000000000..645cdba3a
--- /dev/null
+++ b/libs/algorithm/string/test/find_format_test.cpp
@@ -0,0 +1,162 @@
+// Boost string_algo library find_format_test.cpp file ------------------//
+
+// Copyright (c) 2009 Steven Watanabe
+// 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/algorithm/string/find_format.hpp>
+#include <boost/algorithm/string/finder.hpp>
+#include <boost/algorithm/string/formatter.hpp>
+
+// Include unit test framework
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <boost/test/test_tools.hpp>
+
+// We're only using const_formatter.
+template<class Formatter>
+struct formatter_result {
+ typedef boost::iterator_range<const char*> type;
+};
+
+template<class Formatter>
+struct checked_formatter {
+public:
+ checked_formatter(const Formatter& formatter) : formatter_(formatter) {}
+ template< typename T >
+ typename formatter_result<Formatter>::type operator()( const T & s ) const {
+ BOOST_CHECK( !s.empty() );
+ return formatter_(s);
+ }
+private:
+ Formatter formatter_;
+};
+
+template<class Formatter>
+checked_formatter<Formatter>
+make_checked_formatter(const Formatter& formatter) {
+ return checked_formatter<Formatter>(formatter);
+}
+
+void find_format_test()
+{
+ const std::string source = "$replace $replace";
+ std::string expected = "ok $replace";
+ std::string output(80, '\0');
+
+ std::string::iterator pos =
+ boost::find_format_copy(
+ output.begin(),
+ source,
+ boost::first_finder("$replace"),
+ make_checked_formatter(boost::const_formatter("ok")));
+ BOOST_CHECK(pos == output.begin() + expected.size());
+ output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
+ BOOST_CHECK_EQUAL(output, expected);
+
+ output =
+ boost::find_format_copy(
+ source,
+ boost::first_finder("$replace"),
+ make_checked_formatter(boost::const_formatter("ok")));
+ BOOST_CHECK_EQUAL(output, expected);
+
+ // now try finding a string that doesn't exist
+ output.resize(80);
+ pos =
+ boost::find_format_copy(
+ output.begin(),
+ source,
+ boost::first_finder("$noreplace"),
+ make_checked_formatter(boost::const_formatter("bad")));
+ BOOST_CHECK(pos == output.begin() + source.size());
+ output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
+ BOOST_CHECK_EQUAL(output, source);
+
+ output =
+ boost::find_format_copy(
+ source,
+ boost::first_finder("$noreplace"),
+ make_checked_formatter(boost::const_formatter("bad")));
+ BOOST_CHECK_EQUAL(output, source);
+
+ // in place version
+ output = source;
+ boost::find_format(
+ output,
+ boost::first_finder("$replace"),
+ make_checked_formatter(boost::const_formatter("ok")));
+ BOOST_CHECK_EQUAL(output, expected);
+ output = source;
+ boost::find_format(
+ output,
+ boost::first_finder("$noreplace"),
+ make_checked_formatter(boost::const_formatter("bad")));
+ BOOST_CHECK_EQUAL(output, source);
+}
+
+void find_format_all_test()
+{
+ const std::string source = "$replace $replace";
+ std::string expected = "ok ok";
+ std::string output(80, '\0');
+
+ std::string::iterator pos =
+ boost::find_format_all_copy(output.begin(),
+ source,
+ boost::first_finder("$replace"),
+ boost::const_formatter("ok"));
+ BOOST_CHECK(pos == output.begin() + expected.size());
+ output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
+ BOOST_CHECK_EQUAL(output, expected);
+
+ output =
+ boost::find_format_all_copy(
+ source,
+ boost::first_finder("$replace"),
+ make_checked_formatter(boost::const_formatter("ok")));
+ BOOST_CHECK_EQUAL(output, expected);
+
+ // now try finding a string that doesn't exist
+ output.resize(80);
+ pos =
+ boost::find_format_all_copy(
+ output.begin(),
+ source,
+ boost::first_finder("$noreplace"),
+ make_checked_formatter(boost::const_formatter("bad")));
+ BOOST_CHECK(pos == output.begin() + source.size());
+ output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
+ BOOST_CHECK_EQUAL(output, source);
+
+ output =
+ boost::find_format_all_copy(
+ source,
+ boost::first_finder("$noreplace"),
+ make_checked_formatter(boost::const_formatter("bad")));
+ BOOST_CHECK_EQUAL(output, source);
+
+ // in place version
+ output = source;
+ boost::find_format_all(
+ output,
+ boost::first_finder("$replace"),
+ make_checked_formatter(boost::const_formatter("ok")));
+ BOOST_CHECK_EQUAL(output, expected);
+ output = source;
+ boost::find_format_all(
+ output,
+ boost::first_finder("$noreplace"),
+ make_checked_formatter(boost::const_formatter("bad")));
+ BOOST_CHECK_EQUAL(output, source);
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+ find_format_test();
+ find_format_all_test();
+}
diff --git a/libs/algorithm/string/test/find_test.cpp b/libs/algorithm/string/test/find_test.cpp
new file mode 100644
index 000000000..85facb0a7
--- /dev/null
+++ b/libs/algorithm/string/test/find_test.cpp
@@ -0,0 +1,273 @@
+// Boost string_algo library substr_test.cpp file ------------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/algorithm/string/find.hpp>
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/split.hpp>
+
+// Include unit test framework
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <iterator>
+#include <sstream>
+#include <boost/test/test_tools.hpp>
+
+using namespace std;
+using namespace boost;
+
+void find_test()
+{
+ string str1("123abcxXxabcXxXabc321");
+ string str2("abc");
+ string str3("");
+ const char* pch1="123abcxxxabcXXXabc321";
+ vector<int> vec1( str1.begin(), str1.end() );
+
+ // find results ------------------------------------------------------------//
+ iterator_range<string::iterator> nc_result;
+ iterator_range<string::const_iterator> cv_result;
+
+ iterator_range<vector<int>::iterator> nc_vresult;
+ iterator_range<vector<int>::const_iterator> cv_vresult;
+
+ iterator_range<const char*> ch_result;
+
+ // basic tests ------------------------------------------------------------//
+
+
+ // find_first
+ BOOST_TEST_CHECKPOINT( "find_first" );
+
+ nc_result=find_first( str1, string("abc") );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 3) &&
+ ( (nc_result.end()-str1.begin()) == 6) );
+
+ cv_result=find_first( const_cast<const string&>(str1), str2 );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 3) &&
+ ( (cv_result.end()-str1.begin()) == 6) );
+
+ cv_result=ifind_first( const_cast<const string&>(str1), "xXX" );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 6) &&
+ ( (cv_result.end()-str1.begin()) == 9) );
+
+ ch_result=find_first( pch1, "abc" );
+ BOOST_CHECK(( (ch_result.begin() - pch1 ) == 3) && ( (ch_result.end() - pch1 ) == 6 ) );
+
+ // find_last
+ BOOST_TEST_CHECKPOINT( "find_last" );
+
+ nc_result=find_last( str1, string("abc") );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 15) &&
+ ( (nc_result.end()-str1.begin()) == 18) );
+
+ cv_result=find_last( const_cast<const string&>(str1), str2 );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 15) &&
+ ( (cv_result.end()-str1.begin()) == 18) );
+
+ cv_result=ifind_last( const_cast<const string&>(str1), "XXx" );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 12) &&
+ ( (cv_result.end()-str1.begin()) == 15) );
+
+ ch_result=find_last( pch1, "abc" );
+ BOOST_CHECK(( (ch_result.begin() - pch1 ) == 15) && ( (ch_result.end() - pch1 ) == 18 ) );
+
+ // find_nth
+ BOOST_TEST_CHECKPOINT( "find_nth" );
+
+ nc_result=find_nth( str1, string("abc"), 1 );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 9) &&
+ ( (nc_result.end()-str1.begin()) == 12) );
+
+ nc_result=find_nth( str1, string("abc"), -1 );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 15) &&
+ ( (nc_result.end()-str1.begin()) == 18) );
+
+
+ cv_result=find_nth( const_cast<const string&>(str1), str2, 1 );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 9) &&
+ ( (cv_result.end()-str1.begin()) == 12) );
+
+ cv_result=find_nth( const_cast<const string&>(str1), str2, -1 );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 15) &&
+ ( (cv_result.end()-str1.begin()) == 18) );
+
+ cv_result=ifind_nth( const_cast<const string&>(str1), "xxx", 1 );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 12) &&
+ ( (cv_result.end()-str1.begin()) == 15) );
+
+ cv_result=ifind_nth( const_cast<const string&>(str1), "xxx", 1 );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 12) &&
+ ( (cv_result.end()-str1.begin()) == 15) );
+
+
+ ch_result=find_nth( pch1, "abc", 1 );
+ BOOST_CHECK(( (ch_result.begin() - pch1 ) == 9) && ( (ch_result.end() - pch1 ) == 12 ) );
+
+ // find_head
+ BOOST_TEST_CHECKPOINT( "find_head" );
+
+ nc_result=find_head( str1, 6 );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 0) &&
+ ( (nc_result.end()-str1.begin()) == 6) );
+
+ nc_result=find_head( str1, -6 );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 0) &&
+ ( (str1.end()-nc_result.end()) == 6 ) );
+
+ cv_result=find_head( const_cast<const string&>(str1), 6 );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 0) &&
+ ( (cv_result.end()-str1.begin()) == 6) );
+
+ ch_result=find_head( pch1, 6 );
+ BOOST_CHECK( ( (ch_result.begin() - pch1 ) == 0 ) && ( (ch_result.end() - pch1 ) == 6 ) );
+
+ // find_tail
+ BOOST_TEST_CHECKPOINT( "find_tail" );
+
+ nc_result=find_tail( str1, 6 );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 15) &&
+ ( (nc_result.end()-str1.begin()) == 21) );
+
+ nc_result=find_tail( str1, -6 );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 6) &&
+ ( (nc_result.end()-str1.begin()) == 21) );
+
+
+ cv_result=find_tail( const_cast<const string&>(str1), 6 );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 15) &&
+ ( (cv_result.end()-str1.begin()) == 21) );
+
+ ch_result=find_tail( pch1, 6 );
+ BOOST_CHECK( ( (ch_result.begin() - pch1 ) == 15 ) && ( (ch_result.end() - pch1 ) == 21 ) );
+
+ // find_token
+ BOOST_TEST_CHECKPOINT( "find_token" );
+
+ nc_result=find_token( str1, is_any_of("abc"), token_compress_on );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 3) &&
+ ( (nc_result.end()-str1.begin()) == 6) );
+
+ cv_result=find_token( const_cast<const string&>(str1), is_any_of("abc"), token_compress_on );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 3) &&
+ ( (cv_result.end()-str1.begin()) == 6) );
+
+ nc_result=find_token( str1, is_any_of("abc"), token_compress_off );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 3) &&
+ ( (nc_result.end()-str1.begin()) == 4) );
+
+ cv_result=find_token( const_cast<const string&>(str1), is_any_of("abc"), token_compress_off );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 3) &&
+ ( (cv_result.end()-str1.begin()) == 4) );
+
+ ch_result=find_token( pch1, is_any_of("abc"), token_compress_off );
+ BOOST_CHECK( ( (ch_result.begin() - pch1 ) == 3 ) && ( (ch_result.end() - pch1 ) == 4 ) );
+
+ // generic find
+ BOOST_TEST_CHECKPOINT( "generic find" );
+
+ nc_result=find(str1, first_finder(string("abc")));
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 3) &&
+ ( (nc_result.end()-str1.begin()) == 6) );
+
+ cv_result=find(const_cast<const string&>(str1), first_finder(str2) );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 3) &&
+ ( (cv_result.end()-str1.begin()) == 6) );
+
+ // multi-type comparison test
+ BOOST_TEST_CHECKPOINT( "multi-type" );
+
+ nc_vresult=find_first( vec1, string("abc") );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 3) &&
+ ( (nc_result.end()-str1.begin()) == 6) );
+
+ cv_vresult=find_first( const_cast<const vector<int>&>(vec1), str2 );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 3) &&
+ ( (cv_result.end()-str1.begin()) == 6) );
+
+ // overflow test
+ BOOST_TEST_CHECKPOINT( "overflow" );
+
+ nc_result=find_first( str2, string("abcd") );
+ BOOST_CHECK( nc_result.begin()==nc_result.end() );
+ cv_result=find_first( const_cast<const string&>(str2), string("abcd") );
+ BOOST_CHECK( cv_result.begin()==cv_result.end() );
+
+ cv_result=find_head( const_cast<const string&>(str2), 4 );
+ BOOST_CHECK( string( cv_result.begin(), cv_result.end() )== string("abc") );
+ cv_result=find_tail( const_cast<const string&>(str2), 4 );
+ BOOST_CHECK( string( cv_result.begin(), cv_result.end() )== string("abc") );
+
+ // Empty string test
+ BOOST_TEST_CHECKPOINT( "empty" );
+
+ nc_result=find_first( str3, string("abcd") );
+ BOOST_CHECK( nc_result.begin()==nc_result.end() );
+ nc_result=find_first( str1, string("") );
+ BOOST_CHECK( nc_result.begin()==nc_result.end() );
+
+ cv_result=find_first( const_cast<const string&>(str3), string("abcd") );
+ BOOST_CHECK( cv_result.begin()==cv_result.end() );
+ cv_result=find_first( const_cast<const string&>(str1), string("") );
+ BOOST_CHECK( cv_result.begin()==cv_result.end() );
+
+ // iterator_range specific tests
+ ostringstream osstr;
+ osstr << find_first( str1, "abc" );
+ BOOST_CHECK( osstr.str()=="abc" );
+
+ // Empty string test
+ BOOST_TEST_CHECKPOINT( "overlapping" );
+
+ std::string overlap_target("aaaa");
+ std::vector<boost::iterator_range<std::string::iterator> > overlap_results;
+ boost::algorithm::find_all(overlap_results, overlap_target, string("aaa"));
+ BOOST_CHECK( overlap_results.size() == 2 );
+
+ std::string overlap_target2("aaaabbbbaaaa");
+ boost::algorithm::find_all(overlap_results, overlap_target2, string("bb"));
+ BOOST_CHECK( overlap_results.size() == 3 );
+ boost::algorithm::find_all(overlap_results, overlap_target2, string("aa"));
+ BOOST_CHECK( overlap_results.size() == 6 );
+}
+
+// test main
+BOOST_AUTO_TEST_CASE( test_main )
+{
+ find_test();
+}
diff --git a/libs/algorithm/string/test/join_test.cpp b/libs/algorithm/string/test/join_test.cpp
new file mode 100644
index 000000000..9c5150baf
--- /dev/null
+++ b/libs/algorithm/string/test/join_test.cpp
@@ -0,0 +1,78 @@
+// Boost string_algo library iterator_test.cpp file ---------------------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string/classification.hpp>
+// equals predicate is used for result comparison
+#include <boost/algorithm/string/predicate.hpp>
+
+// Include unit test framework
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <iostream>
+
+#include <boost/test/test_tools.hpp>
+
+
+using namespace std;
+using namespace boost;
+
+bool is_not_empty(const std::string& str)
+{
+ return !str.empty();
+}
+
+void join_test()
+{
+ // Prepare inputs
+ vector<string> tokens1;
+ tokens1.push_back("xx");
+ tokens1.push_back("abc");
+ tokens1.push_back("xx");
+
+ vector<string> tokens2;
+ tokens2.push_back("");
+ tokens2.push_back("xx");
+ tokens2.push_back("abc");
+ tokens2.push_back("");
+ tokens2.push_back("abc");
+ tokens2.push_back("xx");
+ tokens2.push_back("");
+
+ vector<string> tokens3;
+ tokens3.push_back("");
+ tokens3.push_back("");
+ tokens3.push_back("");
+
+ vector<string> empty_tokens;
+
+ vector<vector<int> > vtokens;
+ for(unsigned int n=0; n<tokens2.size(); ++n)
+ {
+ vtokens.push_back(vector<int>(tokens2[n].begin(), tokens2[n].end()));
+ }
+
+ BOOST_CHECK( equals(join(tokens1, "-"), "xx-abc-xx") );
+ BOOST_CHECK( equals(join(tokens2, "-"), "-xx-abc--abc-xx-") );
+ BOOST_CHECK( equals(join(vtokens, "-"), "-xx-abc--abc-xx-") );
+ BOOST_CHECK( equals(join(empty_tokens, "-"), "") );
+
+ BOOST_CHECK( equals(join_if(tokens2, "-", is_not_empty), "xx-abc-abc-xx") );
+ BOOST_CHECK( equals(join_if(empty_tokens, "-", is_not_empty), "") );
+ BOOST_CHECK( equals(join_if(tokens3, "-", is_not_empty), "") );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+ join_test();
+}
diff --git a/libs/algorithm/string/test/predicate_test.cpp b/libs/algorithm/string/test/predicate_test.cpp
new file mode 100644
index 000000000..ba1564e53
--- /dev/null
+++ b/libs/algorithm/string/test/predicate_test.cpp
@@ -0,0 +1,160 @@
+// Boost string_algo library predicate_test.cpp file ------------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/classification.hpp>
+
+// Include unit test framework
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <functional>
+#include <boost/test/test_tools.hpp>
+
+using namespace std;
+using namespace boost;
+
+void predicate_test()
+{
+ string str1("123xxx321");
+ string str1_prefix("123");
+ string str2("abc");
+ string str3("");
+ string str4("abc");
+ vector<int> vec1( str1.begin(), str1.end() );
+
+ // Basic tests
+ BOOST_CHECK( starts_with( str1, string("123") ) );
+ BOOST_CHECK( !starts_with( str1, string("1234") ) );
+
+ BOOST_CHECK( istarts_with( "aBCxxx", "abc" ) );
+ BOOST_CHECK( !istarts_with( "aBCxxx", "abcd" ) );
+
+ BOOST_CHECK( ends_with( str1, string("321") ) );
+ BOOST_CHECK( !ends_with( str1, string("123") ) );
+
+ BOOST_CHECK( iends_with( "aBCxXx", "XXX" ) );
+ BOOST_CHECK( !iends_with( "aBCxxX", "xXXX" ) );
+
+ BOOST_CHECK( contains( str1, string("xxx") ) );
+ BOOST_CHECK( !contains( str1, string("yyy") ) );
+
+ BOOST_CHECK( icontains( "123XxX321", "xxx" ) );
+ BOOST_CHECK( !icontains( "123xXx321", "yyy" ) );
+
+ BOOST_CHECK( equals( str2, string("abc") ) );
+ BOOST_CHECK( !equals( str1, string("yyy") ) );
+
+ BOOST_CHECK( iequals( "AbC", "abc" ) );
+ BOOST_CHECK( !iequals( "aBc", "yyy" ) );
+
+ BOOST_CHECK( lexicographical_compare("abc", "abd") );
+ BOOST_CHECK( !lexicographical_compare("abc", "abc") );
+ BOOST_CHECK( lexicographical_compare("abc", "abd", is_less()) );
+
+ BOOST_CHECK( !ilexicographical_compare("aBD", "AbC") );
+ BOOST_CHECK( ilexicographical_compare("aBc", "AbD") );
+ BOOST_CHECK( lexicographical_compare("abC", "aBd", is_iless()) );
+
+ // multi-type comparison test
+ BOOST_CHECK( starts_with( vec1, string("123") ) );
+ BOOST_CHECK( ends_with( vec1, string("321") ) );
+ BOOST_CHECK( contains( vec1, string("xxx") ) );
+ BOOST_CHECK( equals( vec1, str1 ) );
+
+ // overflow test
+ BOOST_CHECK( !starts_with( str2, string("abcd") ) );
+ BOOST_CHECK( !ends_with( str2, string("abcd") ) );
+ BOOST_CHECK( !contains( str2, string("abcd") ) );
+ BOOST_CHECK( !equals( str2, string("abcd") ) );
+
+ // equal test
+ BOOST_CHECK( starts_with( str2, string("abc") ) );
+ BOOST_CHECK( ends_with( str2, string("abc") ) );
+ BOOST_CHECK( contains( str2, string("abc") ) );
+ BOOST_CHECK( equals( str2, string("abc") ) );
+
+ //! Empty string test
+ BOOST_CHECK( starts_with( str2, string("") ) );
+ BOOST_CHECK( ends_with( str2, string("") ) );
+ BOOST_CHECK( contains( str2, string("") ) );
+ BOOST_CHECK( equals( str3, string("") ) );
+
+ //! Container compatibility test
+ BOOST_CHECK( starts_with( "123xxx321", "123" ) );
+ BOOST_CHECK( ends_with( "123xxx321", "321" ) );
+ BOOST_CHECK( contains( "123xxx321", "xxx" ) );
+ BOOST_CHECK( equals( "123xxx321", "123xxx321" ) );
+
+}
+
+template<typename Pred, typename Input>
+void test_pred(const Pred& pred, const Input& input, bool bYes)
+{
+ // test assignment operator
+ Pred pred1=pred;
+ pred1=pred;
+ pred1=pred1;
+ if(bYes)
+ {
+ BOOST_CHECK( all( input, pred ) );
+ BOOST_CHECK( all( input, pred1 ) );
+ }
+ else
+ {
+ BOOST_CHECK( !all( input, pred ) );
+ BOOST_CHECK( !all( input, pred1 ) );
+ }
+}
+
+#define TEST_CLASS( Pred, YesInput, NoInput )\
+{\
+ test_pred(Pred, YesInput, true); \
+ test_pred(Pred, NoInput, false); \
+}
+
+void classification_test()
+{
+ TEST_CLASS( is_space(), "\n\r\t ", "..." );
+ TEST_CLASS( is_alnum(), "ab129ABc", "_ab129ABc" );
+ TEST_CLASS( is_alpha(), "abc", "abc1" );
+ TEST_CLASS( is_cntrl(), "\n\t\r", "..." );
+ TEST_CLASS( is_digit(), "1234567890", "abc" );
+ TEST_CLASS( is_graph(), "123abc.,", " \t" );
+ TEST_CLASS( is_lower(), "abc", "Aasdf" );
+ TEST_CLASS( is_print(), "abs", "\003\004asdf" );
+ TEST_CLASS( is_punct(), ".,;\"", "abc" );
+ TEST_CLASS( is_upper(), "ABC", "aBc" );
+ TEST_CLASS( is_xdigit(), "ABC123", "XFD" );
+ TEST_CLASS( is_any_of( string("abc") ), "aaabbcc", "aaxb" );
+ TEST_CLASS( is_any_of( "abc" ), "aaabbcc", "aaxb" );
+ TEST_CLASS( is_from_range( 'a', 'c' ), "aaabbcc", "aaxb" );
+
+ TEST_CLASS( !is_classified(std::ctype_base::space), "...", "..\n\r\t " );
+ TEST_CLASS( ( !is_any_of("abc") && is_from_range('a','e') ) || is_space(), "d e", "abcde" );
+
+ // is_any_of test
+// TEST_CLASS( !is_any_of(""), "", "aaa" )
+ TEST_CLASS( is_any_of("a"), "a", "ab" )
+ TEST_CLASS( is_any_of("ba"), "ab", "abc" )
+ TEST_CLASS( is_any_of("cba"), "abc", "abcd" )
+ TEST_CLASS( is_any_of("hgfedcba"), "abcdefgh", "abcdefghi" )
+ TEST_CLASS( is_any_of("qponmlkjihgfedcba"), "abcdefghijklmnopq", "zzz" )
+}
+
+#undef TEST_CLASS
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+ predicate_test();
+ classification_test();
+}
diff --git a/libs/algorithm/string/test/regex_test.cpp b/libs/algorithm/string/test/regex_test.cpp
new file mode 100644
index 000000000..f93c1d9d3
--- /dev/null
+++ b/libs/algorithm/string/test/regex_test.cpp
@@ -0,0 +1,158 @@
+// Boost string_algo library substr_test.cpp file ------------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/algorithm/string/regex.hpp>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string/sequence_traits.hpp>
+// equals predicate is used for result comparison
+#include <boost/algorithm/string/predicate.hpp>
+
+
+// Include unit test framework
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <boost/regex.hpp>
+#include <boost/test/test_tools.hpp>
+
+using namespace std;
+using namespace boost;
+
+static void find_test()
+{
+ string str1("123a1cxxxa23cXXXa456c321");
+ const char* pch1="123a1cxxxa23cXXXa456c321";
+ regex rx("a[0-9]+c");
+ vector<int> vec1( str1.begin(), str1.end() );
+ vector<string> tokens;
+
+ // find results
+ iterator_range<string::iterator> nc_result;
+ iterator_range<string::const_iterator> cv_result;
+
+ iterator_range<vector<int>::iterator> nc_vresult;
+ iterator_range<vector<int>::const_iterator> cv_vresult;
+
+ iterator_range<const char*> ch_result;
+
+ // basic tests
+ nc_result=find_regex( str1, rx );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 3) &&
+ ( (nc_result.end()-str1.begin()) == 6) );
+
+ cv_result=find_regex( str1, rx );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 3) &&
+ ( (cv_result.end()-str1.begin()) == 6) );
+
+ ch_result=find_regex( pch1, rx );
+ BOOST_CHECK(( (ch_result.begin() - pch1 ) == 3) && ( (ch_result.end() - pch1 ) == 6 ) );
+
+ // multi-type comparison test
+ nc_vresult=find_regex( vec1, rx );
+ BOOST_CHECK(
+ ( (nc_result.begin()-str1.begin()) == 3) &&
+ ( (nc_result.end()-str1.begin()) == 6) );
+
+ cv_vresult=find_regex( vec1, rx );
+ BOOST_CHECK(
+ ( (cv_result.begin()-str1.begin()) == 3) &&
+ ( (cv_result.end()-str1.begin()) == 6) );
+
+ // find_all_regex test
+ find_all_regex( tokens, str1, rx );
+
+ BOOST_REQUIRE( tokens.size()==3 );
+ BOOST_CHECK( tokens[0]==string("a1c") );
+ BOOST_CHECK( tokens[1]==string("a23c") );
+ BOOST_CHECK( tokens[2]==string("a456c") );
+
+ // split_regex test
+ split_regex( tokens, str1, rx );
+
+ BOOST_REQUIRE( tokens.size()==4 );
+ BOOST_CHECK( tokens[0]==string("123") );
+ BOOST_CHECK( tokens[1]==string("xxx") );
+ BOOST_CHECK( tokens[2]==string("XXX") );
+ BOOST_CHECK( tokens[3]==string("321") );
+
+}
+
+static void join_test()
+{
+ // Prepare inputs
+ vector<string> tokens1;
+ tokens1.push_back("xx");
+ tokens1.push_back("abc");
+ tokens1.push_back("xx");
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ BOOST_CHECK( equals(join_if(tokens1, "-", regex("x+")), "xx-xx") );
+ BOOST_CHECK( equals(join_if(tokens1, "-", regex("[abc]+")), "abc") );
+#else
+ BOOST_CHECK( equals(join_if_regex(tokens1, "-", regex("x+")), "xx-xx") );
+ BOOST_CHECK( equals(join_if_regex(tokens1, "-", regex("[abc]+")), "abc") );
+#endif
+}
+
+static void replace_test()
+{
+ string str1("123a1cxxxa23cXXXa456c321");
+ regex rx1("a([0-9]+)c");
+ regex rx2("([xX]+)");
+ regex rx3("_[^_]*_");
+ string fmt1("_A$1C_");
+ string fmt2("_xXx_");
+ vector<int> vec1( str1.begin(), str1.end() );
+
+ // immutable tests
+
+ // basic tests
+ BOOST_CHECK( replace_regex_copy( str1, rx1, fmt1 )==string("123_A1C_xxxa23cXXXa456c321") );
+ BOOST_CHECK( replace_all_regex_copy( str1, rx1, fmt1 )==string("123_A1C_xxx_A23C_XXX_A456C_321") );
+ BOOST_CHECK( erase_regex_copy( str1, rx1 )==string("123xxxa23cXXXa456c321") );
+ BOOST_CHECK( erase_all_regex_copy( str1, rx1 )==string(string("123xxxXXX321")) );
+
+ // output iterator variants test
+ string strout;
+ replace_regex_copy( back_inserter(strout), str1, rx1, fmt1 );
+ BOOST_CHECK( strout==string("123_A1C_xxxa23cXXXa456c321") );
+ strout.clear();
+ replace_all_regex_copy( back_inserter(strout), str1, rx1, fmt1 );
+ BOOST_CHECK( strout==string("123_A1C_xxx_A23C_XXX_A456C_321") );
+ strout.clear();
+ erase_regex_copy( back_inserter(strout), str1, rx1 );
+ BOOST_CHECK( strout==string("123xxxa23cXXXa456c321") );
+ strout.clear();
+ erase_all_regex_copy( back_inserter(strout), str1, rx1 );
+ BOOST_CHECK( strout==string("123xxxXXX321") );
+ strout.clear();
+
+ // in-place test
+ replace_regex( str1, rx1, fmt2 );
+ BOOST_CHECK( str1==string("123_xXx_xxxa23cXXXa456c321") );
+
+ replace_all_regex( str1, rx2, fmt1 );
+ BOOST_CHECK( str1==string("123__AxXxC___AxxxC_a23c_AXXXC_a456c321") );
+ erase_regex( str1, rx3 );
+ BOOST_CHECK( str1==string("123AxXxC___AxxxC_a23c_AXXXC_a456c321") );
+ erase_all_regex( str1, rx3 );
+ BOOST_CHECK( str1==string("123AxXxCa23ca456c321") );
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+ find_test();
+ join_test();
+ replace_test();
+}
diff --git a/libs/algorithm/string/test/replace_test.cpp b/libs/algorithm/string/test/replace_test.cpp
new file mode 100644
index 000000000..789d8e482
--- /dev/null
+++ b/libs/algorithm/string/test/replace_test.cpp
@@ -0,0 +1,321 @@
+// Boost string_algo library substr_test.cpp file ------------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/algorithm/string/erase.hpp>
+#include <boost/algorithm/string/std/list_traits.hpp>
+#include <boost/algorithm/string/std/string_traits.hpp>
+#include <boost/algorithm/string/finder.hpp>
+#include <boost/algorithm/string/formatter.hpp>
+#include <boost/algorithm/string/classification.hpp>
+
+// Include unit test framework
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+
+// equals predicate is used for result comparison
+#include <boost/algorithm/string/predicate.hpp>
+
+#include <boost/test/test_tools.hpp>
+
+using namespace std;
+using namespace boost;
+
+void sequence_traits_test()
+{
+ // basic_string traits
+ BOOST_CHECK( boost::algorithm::has_native_replace<string>::value );
+ BOOST_CHECK( !boost::algorithm::has_stable_iterators<string>::value );
+ BOOST_CHECK( !boost::algorithm::has_const_time_insert<string>::value );
+ BOOST_CHECK( !boost::algorithm::has_const_time_erase<string>::value );
+
+ // vector traits
+ BOOST_CHECK( !boost::algorithm::has_native_replace< vector<char> >::value );
+ BOOST_CHECK( !boost::algorithm::has_stable_iterators< vector<char> >::value );
+ BOOST_CHECK( !boost::algorithm::has_const_time_insert< vector<char> >::value );
+ BOOST_CHECK( !boost::algorithm::has_const_time_erase< vector<char> >::value );
+
+ // list traits
+ BOOST_CHECK( !boost::algorithm::has_native_replace< list<char> >::value );
+ BOOST_CHECK( boost::algorithm::has_stable_iterators< list<char> >::value );
+ BOOST_CHECK( boost::algorithm::has_const_time_insert< list<char> >::value );
+ BOOST_CHECK( boost::algorithm::has_const_time_erase< list<char> >::value );
+}
+
+// Combine tests for all variants of the algorithm
+#define C_ ,
+#define TEST_ALGO( Algo, Input, Params, Output ) \
+{\
+ BOOST_TEST_CHECKPOINT( #Algo " - Copy" );\
+\
+ string str1(Input);\
+\
+ /* Copy test */ \
+ BOOST_CHECK( Algo##_copy( str1, Params )==Output );\
+\
+ BOOST_TEST_CHECKPOINT( #Algo " - Iterator" );\
+ /* Iterator test */\
+ string strout;\
+ Algo##_copy( back_inserter(strout), str1, Params );\
+ BOOST_CHECK( strout==Output ); \
+\
+ /* In-place test */\
+ vector<char> vec1( str1.begin(), str1.end() );\
+ list<char> list1( str1.begin(), str1.end() );\
+\
+ BOOST_TEST_CHECKPOINT( #Algo " - Inplace(string)" );\
+ Algo( str1, Params ); \
+ BOOST_CHECK( equals( str1, Output ) ); \
+\
+ BOOST_TEST_CHECKPOINT( #Algo " - Inplace(vector)" );\
+ Algo( vec1, Params ); \
+ BOOST_CHECK( equals( vec1, Output ) );\
+\
+ BOOST_TEST_CHECKPOINT( #Algo " - Inplace(list)" );\
+ Algo( list1, Params ); \
+ BOOST_CHECK( equals( list1, Output ) );\
+}
+
+void replace_first_test()
+{
+ // replace first
+ TEST_ALGO( replace_first, "1abc3abc2", string("abc") C_ string("YYY"), string("1YYY3abc2") );
+ TEST_ALGO( ireplace_first, "1AbC3abc2", "aBc" C_ "YYY", string("1YYY3abc2") );
+ TEST_ALGO( replace_first, "1abc3abc2", string("abc") C_ string("Z"), string("1Z3abc2") );
+ TEST_ALGO( replace_first, "1abc3abc2", string("abc") C_ string("XXXX"), string("1XXXX3abc2") );
+ TEST_ALGO( replace_first, "1abc3abc2", string("") C_ string("XXXX"), string("1abc3abc2") );
+ TEST_ALGO( replace_first, "1abc3abc2", "" C_ "XXXX", string("1abc3abc2") );
+ TEST_ALGO( replace_first, "", string("") C_ string("XXXX"), string("") );
+ TEST_ALGO( erase_first, "1abc3abc2", string("abc"), string("13abc2") );
+ TEST_ALGO( ierase_first, "1aBc3abc2", "abC", "13abc2" );
+ TEST_ALGO( erase_first, "1abc3abc2", "abc", "13abc2" );
+ TEST_ALGO( erase_first, "1abc3abc2", string(""), string("1abc3abc2") );
+ TEST_ALGO( erase_first, "", string("abc"), string("") );
+}
+
+void replace_last_test()
+{
+ // replace last
+ TEST_ALGO( replace_last, "1abc3abc2", string("abc") C_ string("YYY"), string("1abc3YYY2") );
+ TEST_ALGO( ireplace_last, "1abc3AbC2", "aBc" C_ "YYY", string("1abc3YYY2") );
+ TEST_ALGO( replace_last, "1abc3abc2", string("abc") C_ string("Z"), string("1abc3Z2") );
+ TEST_ALGO( replace_last, "1abc3abc2", string("abc") C_ string("XXXX"), string("1abc3XXXX2") );
+ TEST_ALGO( replace_last, "1abc3abc2", "abc" C_ "XXXX", string("1abc3XXXX2") );
+ TEST_ALGO( replace_last, "", string("") C_ string("XXXX"), string("") );
+ TEST_ALGO( erase_last, "1abc3abc2", string("abc"), string("1abc32") );
+ TEST_ALGO( ierase_last, "1aBc3aBc2", "ABC", string("1aBc32") );
+ TEST_ALGO( erase_last, "1abc3abc2", "abc", string("1abc32") );
+ TEST_ALGO( erase_last, "1abc3abc2", string(""), string("1abc3abc2") );
+ TEST_ALGO( erase_last, "", string("abc"), string("") );
+}
+
+void replace_all_test()
+{
+ // replace all
+ TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("YYY"), string("1YYY3YYY2") );
+ TEST_ALGO( replace_all, string("1abc3abc2"), "/" C_ "\\", string("1abc3abc2") );
+ TEST_ALGO( ireplace_all, "1aBc3AbC2", "abC" C_ "YYY", string("1YYY3YYY2") );
+ TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("Z"), string("1Z3Z2") );
+ TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("XXXX"), string("1XXXX3XXXX2") );
+ TEST_ALGO( replace_all, "1abc3abc2", "abc" C_ "XXXX", string("1XXXX3XXXX2") );
+ TEST_ALGO( replace_all, "", string("") C_ string("XXXX"), string("") );
+ TEST_ALGO( erase_all, "1abc3abc2", string("abc"), string("132") );
+ TEST_ALGO( ierase_all, "1aBc3aBc2", "aBC", string("132") );
+ TEST_ALGO( erase_all, "1abc3abc2", "abc", string("132") );
+ TEST_ALGO( erase_all, "1abc3abc2", string(""), string("1abc3abc2") );
+ TEST_ALGO( erase_all, "", string("abc"), string("") );
+}
+
+void replace_nth_test()
+{
+ // replace nth
+ TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 0 C_ string("YYY"), string("1YYY3abc2") );
+ TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ -1 C_ string("YYY"), string("1abc3YYY2") );
+ TEST_ALGO( ireplace_nth, "1AbC3abc2", "aBc" C_ 0 C_ "YYY", string("1YYY3abc2") );
+ TEST_ALGO( ireplace_nth, "1AbC3abc2", "aBc" C_ -1 C_ "YYY", string("1AbC3YYY2") );
+ TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 0 C_ string("Z"), string("1Z3abc2") );
+ TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 0 C_ string("XXXX"), string("1XXXX3abc2") );
+ TEST_ALGO( replace_nth, "1abc3abc2", "abc" C_ 0 C_ "XXXX", string("1XXXX3abc2") );
+ TEST_ALGO( replace_nth, "1abc3abc2", "abc" C_ 3 C_ "XXXX", string("1abc3abc2") );
+ TEST_ALGO( replace_nth, "1abc3abc2", "abc" C_ -3 C_ "XXXX", string("1abc3abc2") );
+ TEST_ALGO( replace_nth, "1abc3abc2", string("") C_ 0 C_ string("XXXX"), string("1abc3abc2") );
+ TEST_ALGO( replace_nth, "", string("") C_ 0 C_ string("XXXX"), string("") );
+ TEST_ALGO( replace_nth, "", string("") C_ -1 C_ string("XXXX"), string("") );
+ TEST_ALGO( erase_nth, "1abc3abc2", string("abc") C_ 0, string("13abc2") );
+ TEST_ALGO( erase_nth, "1abc3abc2", string("abc") C_ -1, string("1abc32") );
+ TEST_ALGO( erase_nth, "1abc3abc2", string("abc") C_ -3, string("1abc3abc2") );
+ TEST_ALGO( ierase_nth, "1aBc3aBc2", "ABC" C_ 0, string("13aBc2") );
+ TEST_ALGO( ierase_nth, "1aBc3aBc2", "ABC" C_ -1, string("1aBc32") );
+ TEST_ALGO( ierase_nth, "1aBc3aBc2", "ABC" C_ -3, string("1aBc3aBc2") );
+ TEST_ALGO( erase_nth, "1abc3abc2", "abc" C_ 0, string("13abc2") );
+ TEST_ALGO( erase_nth, "1abc3abc2", string("") C_ 0, string("1abc3abc2") );
+ TEST_ALGO( erase_nth, "", string("abc") C_ 0, string("") );
+ TEST_ALGO( erase_nth, "", string("abc") C_ -1, string("") );
+ TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 1 C_ string("YYY"), string("1abc3YYY2") );
+ TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 2 C_ string("YYY"), string("1abc3abc2") );
+}
+
+void replace_head_test()
+{
+ // replace head
+ TEST_ALGO( replace_head, "abc3abc2", 3 C_ string("YYY"), string("YYY3abc2") );
+ TEST_ALGO( replace_head, "abc3abc2", -3 C_ string("YYY"), string("YYYbc2") );
+ TEST_ALGO( replace_head, "abc3abc2", 3 C_ "YYY", string("YYY3abc2") );
+ TEST_ALGO( replace_head, "abc", 3 C_ string("Z"), string("Z") );
+ TEST_ALGO( replace_head, "abc", 6 C_ string("XXXX"), string("XXXX") );
+ TEST_ALGO( replace_head, "abc", -6 C_ string("XXXX"), string("abc") );
+ TEST_ALGO( replace_head, "abc3abc2", 0 C_ string("XXXX"), string("abc3abc2") );
+ TEST_ALGO( replace_head, "", 4 C_ string("XXXX"), string("") );
+ TEST_ALGO( replace_head, "", -4 C_ string("XXXX"), string("") );
+ TEST_ALGO( erase_head, "abc3abc2", 3, string("3abc2") );
+ TEST_ALGO( erase_head, "abc3abc2", -3, string("bc2") );
+ TEST_ALGO( erase_head, "abc3abc2", 0, string("abc3abc2") );
+ TEST_ALGO( erase_head, "", 4, string("") );
+ TEST_ALGO( erase_head, "", -4, string("") );
+}
+
+void replace_tail_test()
+{
+ // replace tail
+ TEST_ALGO( replace_tail, "abc3abc", 3 C_ string("YYY"), string("abc3YYY") );
+ TEST_ALGO( replace_tail, "abc3abc", -3 C_ "YYY", string("abcYYY") );
+ TEST_ALGO( replace_tail, "abc", 3 C_ string("Z"), string("Z") );
+ TEST_ALGO( replace_tail, "abc", 6 C_ string("XXXX"), string("XXXX") );
+ TEST_ALGO( replace_tail, "abc", -6 C_ string("XXXX"), string("abc") );
+ TEST_ALGO( replace_tail, "abc3abc", 0 C_ string("XXXX"), string("abc3abc") );
+ TEST_ALGO( replace_tail, "", 4 C_ string("XXXX"), string("") );
+ TEST_ALGO( replace_tail, "", -4 C_ string("XXXX"), string("") );
+ TEST_ALGO( erase_tail, "abc3abc", 3, string("abc3") );
+ TEST_ALGO( erase_tail, "abc3abc", -3, string("abc") );
+ TEST_ALGO( erase_tail, "abc3abc", 0, string("abc3abc") );
+ TEST_ALGO( erase_tail, "", 4, string("") );
+ TEST_ALGO( erase_tail, "", -4, string("") );
+}
+
+void replace_range_test()
+{
+ // replace_range
+ {
+ BOOST_TEST_CHECKPOINT( "replace_range" );
+
+ string str1("1abc3abc2");
+ BOOST_CHECK(
+ replace_range_copy(
+ str1,
+ make_iterator_range(str1.begin()+1, str1.begin()+4),
+ string("XXX") )==string("1XXX3abc2") );
+
+ string strout;
+ replace_range_copy(
+ back_inserter( strout ),
+ str1,
+ make_iterator_range(str1.begin()+1, str1.begin()+4),
+ string("XXX") );
+ BOOST_CHECK( strout==string("1XXX3abc2") );
+
+ replace_range(
+ str1,
+ make_iterator_range(str1.begin()+1, str1.begin()+4),
+ string("XXX") );
+ BOOST_CHECK( str1==string("1XXX3abc2") );
+ }
+ // erase_range
+ {
+ BOOST_TEST_CHECKPOINT( "erase_range" );
+
+ string str1("1abc3abc2");
+ BOOST_CHECK(
+ erase_range_copy(
+ str1,
+ make_iterator_range(str1.begin()+1, str1.begin()+4))==string("13abc2") );
+
+ string strout;
+ erase_range_copy(
+ back_inserter( strout ),
+ str1,
+ make_iterator_range(str1.begin()+1, str1.begin()+4));
+ BOOST_CHECK( strout==string("13abc2") );
+
+ erase_range(
+ str1,
+ make_iterator_range(str1.begin()+1, str1.begin()+4));
+ BOOST_CHECK( str1==string("13abc2") );
+ }
+}
+
+void collection_comp_test()
+{
+ // container traits compatibility tests
+ {
+ string strout;
+ replace_first_copy( back_inserter(strout), "1abc3abc2", "abc", "YYY" );
+ BOOST_CHECK( strout==string("1YYY3abc2") );
+ }
+ {
+ string strout;
+ replace_last_copy( back_inserter(strout), "1abc3abc2", "abc", "YYY" );
+ BOOST_CHECK( strout==string("1abc3YYY2") );
+ }
+ {
+ string strout;
+ replace_all_copy( back_inserter(strout), "1abc3abc2", "abc", "YYY" );
+ BOOST_CHECK( strout==string("1YYY3YYY2") );
+ }
+ {
+ string strout;
+ replace_nth_copy( back_inserter(strout), "1abc3abc2", "abc", 1, "YYY" );
+ BOOST_CHECK( strout==string("1abc3YYY2") );
+ }
+ {
+ string strout;
+ replace_head_copy( back_inserter(strout), "abc3abc2", 3 , "YYY" );
+ BOOST_CHECK( strout==string("YYY3abc2") );
+ }
+ {
+ string strout;
+ replace_tail_copy( back_inserter(strout), "abc3abc", 3 , "YYY" );
+ BOOST_CHECK( strout==string("abc3YYY") );
+ }
+}
+
+void dissect_format_test()
+{
+ BOOST_CHECK(
+ find_format_all_copy(
+ string("aBc123Abc"),
+ first_finder("abc", is_iequal()),
+ dissect_formatter(token_finder(is_upper())))=="B123A");
+
+
+ BOOST_CHECK(
+ find_format_all_copy(
+ string("abc 123 abc"),
+ token_finder(is_space(), token_compress_on),
+ dissect_formatter(head_finder(1)))=="abc 123 abc");
+
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+ sequence_traits_test();
+ replace_first_test();
+ replace_last_test();
+ replace_all_test();
+ replace_nth_test();
+ replace_head_test();
+ replace_tail_test();
+ replace_range_test();
+ collection_comp_test();
+ dissect_format_test();
+}
diff --git a/libs/algorithm/string/test/split_test.cpp b/libs/algorithm/string/test/split_test.cpp
new file mode 100644
index 000000000..429f3c4f6
--- /dev/null
+++ b/libs/algorithm/string/test/split_test.cpp
@@ -0,0 +1,193 @@
+// Boost string_algo library iterator_test.cpp file ---------------------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/classification.hpp>
+// equals predicate is used for result comparison
+#include <boost/algorithm/string/predicate.hpp>
+
+// Include unit test framework
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+
+#include <boost/test/test_tools.hpp>
+
+
+using namespace std;
+using namespace boost;
+
+template< typename T1, typename T2 >
+void deep_compare( const T1& X, const T2& Y )
+{
+ BOOST_REQUIRE( X.size() == Y.size() );
+ for( unsigned int nIndex=0; nIndex<X.size(); ++nIndex )
+ {
+ BOOST_CHECK( equals( X[nIndex], Y[nIndex] ) );
+ }
+}
+
+void iterator_test()
+{
+ string str1("xx-abc--xx-abb");
+ string str2("Xx-abc--xX-abb-xx");
+ string str3("xx");
+ string strempty("");
+ const char* pch1="xx-abc--xx-abb";
+ vector<string> tokens;
+ vector< vector<int> > vtokens;
+
+ // find_all tests
+ find_all(
+ tokens,
+ pch1,
+ "xx" );
+
+ BOOST_REQUIRE( tokens.size()==2 );
+ BOOST_CHECK( tokens[0]==string("xx") );
+ BOOST_CHECK( tokens[1]==string("xx") );
+
+ ifind_all(
+ tokens,
+ str2,
+ "xx" );
+
+ BOOST_REQUIRE( tokens.size()==3 );
+ BOOST_CHECK( tokens[0]==string("Xx") );
+ BOOST_CHECK( tokens[1]==string("xX") );
+ BOOST_CHECK( tokens[2]==string("xx") );
+
+ find_all(
+ tokens,
+ str1,
+ "xx" );
+
+ BOOST_REQUIRE( tokens.size()==2 );
+ BOOST_CHECK( tokens[0]==string("xx") );
+ BOOST_CHECK( tokens[1]==string("xx") );
+
+ find_all(
+ vtokens,
+ str1,
+ string("xx") );
+ deep_compare( tokens, vtokens );
+
+ // split tests
+ split(
+ tokens,
+ str2,
+ is_any_of("xX"),
+ token_compress_on );
+
+ BOOST_REQUIRE( tokens.size()==4 );
+ BOOST_CHECK( tokens[0]==string("") );
+ BOOST_CHECK( tokens[1]==string("-abc--") );
+ BOOST_CHECK( tokens[2]==string("-abb-") );
+ BOOST_CHECK( tokens[3]==string("") );
+
+ split(
+ tokens,
+ pch1,
+ is_any_of("x"),
+ token_compress_on );
+
+ BOOST_REQUIRE( tokens.size()==3 );
+ BOOST_CHECK( tokens[0]==string("") );
+ BOOST_CHECK( tokens[1]==string("-abc--") );
+ BOOST_CHECK( tokens[2]==string("-abb") );
+
+ split(
+ vtokens,
+ str1,
+ is_any_of("x"),
+ token_compress_on );
+ deep_compare( tokens, vtokens );
+
+ split(
+ tokens,
+ str1,
+ is_punct(),
+ token_compress_off );
+
+ BOOST_REQUIRE( tokens.size()==5 );
+ BOOST_CHECK( tokens[0]==string("xx") );
+ BOOST_CHECK( tokens[1]==string("abc") );
+ BOOST_CHECK( tokens[2]==string("") );
+ BOOST_CHECK( tokens[3]==string("xx") );
+ BOOST_CHECK( tokens[4]==string("abb") );
+
+ split(
+ tokens,
+ str3,
+ is_any_of(","),
+ token_compress_off);
+
+ BOOST_REQUIRE( tokens.size()==1 );
+ BOOST_CHECK( tokens[0]==string("xx") );
+
+ split(
+ tokens,
+ strempty,
+ is_punct(),
+ token_compress_off);
+
+ BOOST_REQUIRE( tokens.size()==1 );
+ BOOST_CHECK( tokens[0]==string("") );
+
+
+ find_iterator<string::iterator> fiter=make_find_iterator(str1, first_finder("xx"));
+ find_iterator<string::iterator> fiter2;
+
+ BOOST_CHECK(equals(*fiter, "xx"));
+ ++fiter;
+
+ fiter2 = fiter;
+ BOOST_CHECK(equals(*fiter, "xx"));
+ BOOST_CHECK(equals(*fiter2, "xx"));
+
+ ++fiter;
+ BOOST_CHECK(fiter==find_iterator<string::iterator>());
+ BOOST_CHECK(equals(*fiter2, "xx"));
+
+ ++fiter2;
+ BOOST_CHECK(fiter2==find_iterator<string::iterator>());
+
+ split_iterator<string::iterator> siter=make_split_iterator(str1, token_finder(is_any_of("-"), token_compress_on));
+ split_iterator<string::iterator> siter2;
+ BOOST_CHECK(equals(*siter, "xx"));
+ ++siter;
+
+ siter2 = siter;
+ BOOST_CHECK(equals(*siter, "abc"));
+ BOOST_CHECK(equals(*siter2, "abc"));
+
+ ++siter;
+ BOOST_CHECK(equals(*siter, "xx"));
+ BOOST_CHECK(equals(*siter2, "abc"));
+
+ ++siter;
+ BOOST_CHECK(equals(*siter, "abb"));
+ ++siter;
+ BOOST_CHECK(siter==split_iterator<string::iterator>(siter));
+ BOOST_CHECK(siter==split_iterator<string::iterator>());
+
+// Make sure we work with forward iterators
+// See bug #7989
+ list<char> l1;
+ find_iterator<list<char>::iterator> liter=make_find_iterator(l1, first_finder("xx"));
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+ iterator_test();
+}
diff --git a/libs/algorithm/string/test/trim_test.cpp b/libs/algorithm/string/test/trim_test.cpp
new file mode 100644
index 000000000..b254caaa4
--- /dev/null
+++ b/libs/algorithm/string/test/trim_test.cpp
@@ -0,0 +1,202 @@
+// Boost string_algo library trim_test.cpp file ---------------------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/algorithm/string/trim_all.hpp>
+
+// Include unit test framework
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <iostream>
+#include <boost/test/test_tools.hpp>
+
+using namespace std;
+using namespace boost;
+
+void trim_test()
+{
+ string str1(" 1x x x x1 ");
+ string str2(" 2x x x x2 ");
+ string str3(" ");
+
+ // *** value passing tests *** //
+
+ // general string test
+ BOOST_CHECK( trim_left_copy( str1 )=="1x x x x1 " ) ;
+ BOOST_CHECK( trim_right_copy( str1 )==" 1x x x x1" ) ;
+ BOOST_CHECK( trim_copy( str1 )=="1x x x x1" ) ;
+
+ // spaces-only string test
+ BOOST_CHECK( trim_left_copy( str3 )=="" );
+ BOOST_CHECK( trim_right_copy( str3 )=="" );
+ BOOST_CHECK( trim_copy( str3 )=="" );
+
+ // empty string check
+ BOOST_CHECK( trim_left_copy( string("") )=="" );
+ BOOST_CHECK( trim_right_copy( string("") )=="" );
+ BOOST_CHECK( trim_copy( string("") )=="" );
+
+ // iterator tests
+ string str;
+ trim_left_copy_if( std::back_inserter(str), str1, is_space() );
+ BOOST_CHECK( str=="1x x x x1 " );
+
+ str.clear();
+ trim_right_copy_if( std::back_inserter(str), str1, is_space() );
+ BOOST_CHECK( str==" 1x x x x1" );
+
+ str.clear();
+ trim_copy_if( std::back_inserter(str), str1, is_space() );
+ BOOST_CHECK( str=="1x x x x1" );
+
+ str.clear();
+ trim_left_copy_if(
+ std::back_inserter(str),
+ " 1x x x x1 ",
+ is_space() );
+ BOOST_CHECK( str=="1x x x x1 " );
+
+ str.clear();
+ trim_right_copy_if(
+ std::back_inserter(str),
+ " 1x x x x1 ",
+ is_space() );
+ BOOST_CHECK( str==" 1x x x x1" );
+
+ str.clear();
+ trim_copy_if(
+ std::back_inserter(str),
+ " 1x x x x1 ",
+ is_space() );
+ BOOST_CHECK( str=="1x x x x1" );
+ // *** inplace tests *** //
+
+ // general string test
+ trim_left( str1 );
+ BOOST_CHECK( str1=="1x x x x1 " );
+ trim_right( str1 );
+ BOOST_CHECK( str1=="1x x x x1" );
+ trim( str2 );
+ BOOST_CHECK( str2=="2x x x x2" );
+
+ // spaces-only string test
+ str3 = " "; trim_left( str3 );
+ BOOST_CHECK( str3=="" );
+ str3 = " "; trim_right( str3 );
+ BOOST_CHECK( str3=="" );
+ str3 = " "; trim( str3 );
+ BOOST_CHECK( str3=="" );
+
+ // empty string check
+ str3 = ""; trim_left( str3 );
+ BOOST_CHECK( str3=="" );
+ str3 = ""; trim_right( str3 );
+ BOOST_CHECK( str3=="" );
+ str3 = ""; trim( str3 );
+ BOOST_CHECK( str3=="" );
+
+ // *** non-standard predicate tests *** //
+ BOOST_CHECK(
+ trim_copy_if(
+ string("123abc456"),
+ is_classified(std::ctype_base::digit) )=="abc" );
+ BOOST_CHECK( trim_copy_if( string("<>abc<>"), is_any_of( "<<>>" ) )=="abc" );
+}
+
+void trim_all_test()
+{
+ string str1(" 1x x x x1 ");
+ string str2("+---...2x+--x--+x-+-x2...---+");
+ string str3(" ");
+
+ // *** value passing tests *** //
+
+ // general string test
+ BOOST_CHECK( trim_all_copy( str1 )=="1x x x x1" ) ;
+ BOOST_CHECK( trim_all_copy_if( str2, is_punct() )=="2x+x-x-x2" ) ;
+
+ // spaces-only string test
+ BOOST_CHECK( trim_all_copy( str3 )=="" );
+
+ // empty string check
+ BOOST_CHECK( trim_all_copy( string("") )=="" );
+
+ // general string test
+ trim_all( str1 );
+ BOOST_CHECK( str1=="1x x x x1" ) ;
+ trim_all_if( str2, is_punct() );
+ BOOST_CHECK( str2=="2x+x-x-x2" ) ;
+
+ // spaces-only string test
+ str3 = " "; trim_all( str3 );
+ BOOST_CHECK( str3=="" );
+
+ // empty string check
+ str3 = ""; trim_all( str3 );
+ BOOST_CHECK( str3=="" );
+ BOOST_CHECK( str3=="" );
+
+ // *** non-standard predicate tests *** //
+ BOOST_CHECK(
+ trim_all_copy_if(
+ string("123abc127deb456"),
+ is_classified(std::ctype_base::digit) )=="abc1deb" );
+ BOOST_CHECK( trim_all_copy_if( string("<>abc<>def<>"), is_any_of( "<<>>" ) )=="abc<def" );
+}
+
+void trim_fill_test()
+{
+ string str1(" 1x x x x1 ");
+ string str2("+---...2x+--x--+x-+-x2...---+");
+ string str3(" ");
+
+ // *** value passing tests *** //
+
+ // general string test
+ BOOST_CHECK( trim_fill_copy( str1, "-" )=="1x-x-x-x1" ) ;
+ BOOST_CHECK( trim_fill_copy_if( str2, " ", is_punct() )=="2x x x x2" ) ;
+
+ // spaces-only string test
+ BOOST_CHECK( trim_fill_copy( str3, " " )=="" );
+
+ // empty string check
+ BOOST_CHECK( trim_fill_copy( string(""), " " )=="" );
+
+ // general string test
+ trim_fill( str1, "-" );
+ BOOST_CHECK( str1=="1x-x-x-x1" ) ;
+ trim_fill_if( str2, "", is_punct() );
+ BOOST_CHECK( str2=="2xxxx2" ) ;
+
+ // spaces-only string test
+ str3 = " "; trim_fill( str3, "" );
+ BOOST_CHECK( str3=="" );
+
+ // empty string check
+ str3 = ""; trim_fill( str3, "" );
+ BOOST_CHECK( str3=="" );
+ BOOST_CHECK( str3=="" );
+
+ // *** non-standard predicate tests *** //
+ BOOST_CHECK(
+ trim_fill_copy_if(
+ string("123abc127deb456"),
+ "+",
+ is_classified(std::ctype_base::digit) )=="abc+deb" );
+ BOOST_CHECK( trim_fill_copy_if( string("<>abc<>def<>"), "-", is_any_of( "<<>>" ) )=="abc-def" );
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+ trim_test();
+ trim_all_test();
+ trim_fill_test();
+}
View Lorry Controller Status