[DEV] add v1.66.0

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
+        ]
+    ;
+

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();
+}

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();
+}

libs/algorithm/string/test/find_test.cpp

@@ -0,0 +1,275 @@
+//  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) );
+
+    string s1("abc def ghi jkl");
+    find_iterator<string::iterator> fEnd;
+
+    find_iterator<string::iterator> fxIt = make_find_iterator(s1,
+            token_finder(is_alnum(), token_compress_on));
+    BOOST_CHECK((fxIt != fEnd) && (*fxIt == string("abc")));
+    ++fxIt;
+    BOOST_CHECK((fxIt != fEnd) && (*fxIt == string("def")));
+    ++fxIt;
+    BOOST_CHECK((fxIt != fEnd) && (*fxIt == string("ghi")));
+    ++fxIt;
+    BOOST_CHECK((fxIt != fEnd) && (*fxIt == string("jkl")));
+    ++fxIt;
+    BOOST_CHECK(fxIt == fEnd);
+
+    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" );
+
+}
+
+// test main 
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    find_test();
+}

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();
+}

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();
+}

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();
+}

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();
+}

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();
+}

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();
+}