forked from boostorg/algorithm
String Algorithm Library: initial commit
[SVN r22431]
This commit is contained in:
Pavol Droba
68
string/test/Jamfile
Normal file
68
string/test/Jamfile
Normal file
@ -0,0 +1,68 @@
|
||||
# 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.
|
||||
|
||||
subproject libs/algorithm/string/test ;
|
||||
|
||||
# bring in rules for testing
|
||||
SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
|
||||
include testing.jam ;
|
||||
|
||||
test-suite "string_algo"
|
||||
: [ run
|
||||
container_test.cpp
|
||||
: :
|
||||
:
|
||||
: container
|
||||
]
|
||||
: [ run
|
||||
trim_test.cpp
|
||||
: :
|
||||
:
|
||||
: trim
|
||||
]
|
||||
: [ run
|
||||
conv_test.cpp
|
||||
: :
|
||||
:
|
||||
: conv
|
||||
]
|
||||
: [ run
|
||||
predicate_test.cpp
|
||||
: :
|
||||
:
|
||||
: predicate
|
||||
]
|
||||
: [ run
|
||||
find_test.cpp
|
||||
: :
|
||||
:
|
||||
: find
|
||||
]
|
||||
: [ run
|
||||
split_test.cpp
|
||||
: :
|
||||
:
|
||||
: split
|
||||
]
|
||||
: [ run
|
||||
replace_test.cpp
|
||||
: :
|
||||
:
|
||||
: replace
|
||||
]
|
||||
: [ run
|
||||
regex_test.cpp
|
||||
<lib>../../../regex/build/boost_regex
|
||||
: :
|
||||
:
|
||||
: regex
|
||||
]
|
||||
|
||||
;
|
||||
|
||||
127
string/test/container_test.cpp
Normal file
127
string/test/container_test.cpp
Normal file
@ -0,0 +1,127 @@
|
||||
// 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 unit test framework
|
||||
#include <boost/test/included/test_exec_monitor.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/algorithm/string/collection_traits.hpp>
|
||||
#include <boost/type_traits.hpp>
|
||||
|
||||
// equals predicate is used for result comparison
|
||||
#include <boost/algorithm/string/predicate.hpp>
|
||||
|
||||
// test tools
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
namespace algo = ::boost::algorithm;
|
||||
|
||||
template< typename T >
|
||||
void argument_cv_test( const T& C, const string& strResult )
|
||||
{
|
||||
BOOST_CHECK( equals( make_iterator_range(algo::begin(C),algo::end(C)), strResult ) );
|
||||
BOOST_CHECK( algo::size(C)==strResult.size() );
|
||||
BOOST_CHECK( algo::empty(C)==strResult.empty() );
|
||||
}
|
||||
|
||||
template< typename T >
|
||||
void argument_test( T& C, const string& strResult )
|
||||
{
|
||||
BOOST_CHECK( equals( make_iterator_range(algo::begin(C),algo::end(C)), strResult ) );
|
||||
BOOST_CHECK( algo::size(C)==strResult.size() );
|
||||
BOOST_CHECK( algo::empty(C)==strResult.empty() );
|
||||
}
|
||||
|
||||
void container_test()
|
||||
{
|
||||
BOOST_CHECKPOINT( "type test" );
|
||||
|
||||
// types test
|
||||
BOOST_REQUIRE( (is_same<
|
||||
algo::result_iterator_of<string>::type,
|
||||
string::iterator>::value) );
|
||||
BOOST_REQUIRE( (is_same<
|
||||
algo::result_iterator_of<const string>::type,
|
||||
string::const_iterator>::value) );
|
||||
BOOST_REQUIRE( (is_same<
|
||||
algo::result_iterator_of<char[4]>::type, char*>::value) );
|
||||
BOOST_REQUIRE( (is_same<
|
||||
algo::result_iterator_of<const char[4]>::type,
|
||||
const char*>::value) );
|
||||
BOOST_REQUIRE( (is_same<
|
||||
algo::result_iterator_of<char*>::type, char*>::value) );
|
||||
BOOST_REQUIRE( (is_same<
|
||||
algo::result_iterator_of<const char*>::type,
|
||||
const char*>::value) );
|
||||
BOOST_REQUIRE( (is_same<
|
||||
algo::result_iterator_of<
|
||||
pair<string::iterator, string::iterator> >::type, string::iterator>::value) );
|
||||
BOOST_REQUIRE( (is_same<
|
||||
algo::result_iterator_of<
|
||||
const pair<string::iterator, string::iterator> >::type,
|
||||
string::iterator>::value) );
|
||||
|
||||
BOOST_CHECKPOINT( "non-empty sequence test" );
|
||||
|
||||
string str1("abc");
|
||||
vector<char> vec1( str1.begin(), str1.end() );
|
||||
pair<string::iterator, string::iterator> pair1=
|
||||
make_pair( str1.begin(), str1.end() );
|
||||
char ach1[]="abc";
|
||||
char *pch1="abc";
|
||||
|
||||
// begin/end tests
|
||||
argument_cv_test( str1, "abc" );
|
||||
argument_test( str1, "abc" );
|
||||
argument_cv_test( vec1, "abc" );
|
||||
argument_test( vec1, "abc" );
|
||||
argument_cv_test( pair1, "abc" );
|
||||
argument_test( pair1, "abc" );
|
||||
argument_cv_test( ach1, "abc" );
|
||||
argument_test( ach1, "abc" );
|
||||
argument_cv_test( pch1, "abc" );
|
||||
argument_test( pch1, "abc" );
|
||||
|
||||
BOOST_CHECKPOINT( "empty sequence test" );
|
||||
|
||||
string str2;
|
||||
vector<char> vec2( str2.begin(), str2.end() );
|
||||
pair<string::iterator, string::iterator> pair2=
|
||||
make_pair( str2.begin(), str2.end() );
|
||||
char ach2[]="";
|
||||
char *pch2=0;
|
||||
|
||||
// begin/end tests
|
||||
argument_cv_test( str2, "" );
|
||||
argument_test( str2, "" );
|
||||
argument_cv_test( vec2, "" );
|
||||
argument_test( vec2, "" );
|
||||
argument_cv_test( pair2, "" );
|
||||
argument_test( pair2, "" );
|
||||
argument_cv_test( ach2, "" );
|
||||
argument_test( ach2, "" );
|
||||
argument_cv_test( pch2, "" );
|
||||
argument_test( pch2, "" );
|
||||
};
|
||||
|
||||
|
||||
// test main
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
container_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
88
string/test/conv_test.cpp
Normal file
88
string/test/conv_test.cpp
Normal file
@ -0,0 +1,88 @@
|
||||
// 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 unit test framework
|
||||
#include <boost/test/included/test_exec_monitor.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <boost/algorithm/string/case_conv.hpp>
|
||||
#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("");
|
||||
char* pch1=strdup("AbCdEfG 123 xxxYYYzZzZ");
|
||||
char* pch2=strdup("AbCdEfG 123 xxxYYYzZzZ");
|
||||
|
||||
// *** 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=="" );
|
||||
|
||||
free(pch1);
|
||||
free(pch2);
|
||||
}
|
||||
|
||||
// test main
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
conv_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
230
string/test/find_test.cpp
Normal file
230
string/test/find_test.cpp
Normal file
@ -0,0 +1,230 @@
|
||||
// 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 unit test framework
|
||||
#include <boost/test/included/test_exec_monitor.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <iterator>
|
||||
#include <sstream>
|
||||
#include <boost/algorithm/string/find.hpp>
|
||||
#include <boost/algorithm/string/classification.hpp>
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
void find_test()
|
||||
{
|
||||
string str1("123abcxXxabcXxXabc321");
|
||||
string str2("abc");
|
||||
string str3("");
|
||||
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_CHECKPOINT( "find_first" );
|
||||
|
||||
nc_result=find_first( str1, string("abc") );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
|
||||
|
||||
cv_result=find_first( const_cast<const string&>(str1), str2 );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 6) );
|
||||
|
||||
cv_result=ifind_first( const_cast<const string&>(str1), "xXX" );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 6) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 9) );
|
||||
|
||||
ch_result=find_first( pch1, "abc" );
|
||||
BOOST_CHECK(( (ch_result.begin() - pch1 ) == 3) && ( (ch_result.end() - pch1 ) == 6 ) );
|
||||
|
||||
// find_last
|
||||
BOOST_CHECKPOINT( "find_last" );
|
||||
|
||||
nc_result=find_last( str1, string("abc") );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 15) &&
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.end()) == 18) );
|
||||
|
||||
cv_result=find_last( const_cast<const string&>(str1), str2 );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 15) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 18) );
|
||||
|
||||
cv_result=ifind_last( const_cast<const string&>(str1), "XXx" );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 12) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 15) );
|
||||
|
||||
ch_result=find_last( pch1, "abc" );
|
||||
BOOST_CHECK(( (ch_result.begin() - pch1 ) == 15) && ( (ch_result.end() - pch1 ) == 18 ) );
|
||||
|
||||
// find_nth
|
||||
BOOST_CHECKPOINT( "find_nth" );
|
||||
|
||||
nc_result=find_nth( str1, string("abc"), 1 );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 9) &&
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.end()) == 12) );
|
||||
|
||||
cv_result=find_nth( const_cast<const string&>(str1), str2, 1 );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 9) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 12) );
|
||||
|
||||
cv_result=ifind_nth( const_cast<const string&>(str1), "xxx", 1 );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 12) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 15) );
|
||||
|
||||
ch_result=find_nth( pch1, "abc", 1 );
|
||||
BOOST_CHECK(( (ch_result.begin() - pch1 ) == 9) && ( (ch_result.end() - pch1 ) == 12 ) );
|
||||
|
||||
// find_head
|
||||
BOOST_CHECKPOINT( "find_head" );
|
||||
|
||||
nc_result=find_head( str1, 6 );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 0) &&
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
|
||||
|
||||
cv_result=find_head( const_cast<const string&>(str1), 6 );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 0) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 6) );
|
||||
|
||||
ch_result=find_head( pch1, 6 );
|
||||
BOOST_CHECK( ( (ch_result.begin() - pch1 ) == 0 ) && ( (ch_result.end() - pch1 ) == 6 ) );
|
||||
|
||||
// find_tail
|
||||
BOOST_CHECKPOINT( "find_tail" );
|
||||
|
||||
nc_result=find_tail( str1, 6 );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 15) &&
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.end()) == 21) );
|
||||
|
||||
cv_result=find_tail( const_cast<const string&>(str1), 6 );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 15) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 21) );
|
||||
|
||||
ch_result=find_tail( pch1, 6 );
|
||||
BOOST_CHECK( ( (ch_result.begin() - pch1 ) == 15 ) && ( (ch_result.end() - pch1 ) == 21 ) );
|
||||
|
||||
// find_token
|
||||
BOOST_CHECKPOINT( "find_token" );
|
||||
|
||||
nc_result=find_token( str1, is_any_of("abc"), token_compress_on );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
|
||||
|
||||
cv_result=find_token( const_cast<const string&>(str1), is_any_of("abc"), token_compress_on );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 6) );
|
||||
|
||||
nc_result=find_token( str1, is_any_of("abc"), token_compress_off );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.end()) == 4) );
|
||||
|
||||
cv_result=find_token( const_cast<const string&>(str1), is_any_of("abc"), token_compress_off );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 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_CHECKPOINT( "generic find" );
|
||||
|
||||
nc_result=find(str1, first_finder(string("abc")));
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
|
||||
|
||||
cv_result=find(const_cast<const string&>(str1), first_finder(str2) );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 6) );
|
||||
|
||||
// multi-type comparison test
|
||||
BOOST_CHECKPOINT( "multi-type" );
|
||||
|
||||
nc_vresult=find_first( vec1, string("abc") );
|
||||
BOOST_CHECK(
|
||||
(distance<vector<int>::const_iterator>( vec1.begin(),nc_vresult.begin()) == 3) &&
|
||||
(distance<vector<int>::const_iterator>( vec1.begin(),nc_vresult.end()) == 6) );
|
||||
|
||||
cv_vresult=find_first( const_cast<const vector<int>&>(vec1), str2 );
|
||||
BOOST_CHECK(
|
||||
(distance<vector<int>::const_iterator>( vec1.begin(),cv_vresult.begin()) == 3) &&
|
||||
(distance<vector<int>::const_iterator>( vec1.begin(),cv_vresult.end()) == 6) );
|
||||
|
||||
// overflow test
|
||||
BOOST_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_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
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
find_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
125
string/test/predicate_test.cpp
Normal file
125
string/test/predicate_test.cpp
Normal file
@ -0,0 +1,125 @@
|
||||
// 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 unit test framework
|
||||
#include <boost/test/included/test_exec_monitor.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
#include <boost/algorithm/string/predicate.hpp>
|
||||
#include <boost/algorithm/string/classification.hpp>
|
||||
#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" ) );
|
||||
|
||||
// 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" ) );
|
||||
}
|
||||
|
||||
#define TEST_CLASS( Pred, YesInput, NoInput )\
|
||||
{\
|
||||
BOOST_CHECK( all( string(YesInput), Pred ) );\
|
||||
BOOST_CHECK( !all( string(NoInput), Pred ) );\
|
||||
}
|
||||
|
||||
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", "\nasdf" );
|
||||
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" );
|
||||
}
|
||||
|
||||
#undef TEST_CLASS
|
||||
|
||||
// test main
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
predicate_test();
|
||||
classification_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
135
string/test/regex_test.cpp
Normal file
135
string/test/regex_test.cpp
Normal file
@ -0,0 +1,135 @@
|
||||
// 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 unit test framework
|
||||
#include <boost/test/included/test_exec_monitor.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <boost/regex.hpp>
|
||||
#include <boost/algorithm/string/regex.hpp>
|
||||
#include <boost/test/test_tools.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost;
|
||||
|
||||
static void find_test()
|
||||
{
|
||||
string str1("123a1cxxxa23cXXXa456c321");
|
||||
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(
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),nc_result.end()) == 6) );
|
||||
|
||||
cv_result=find_regex( str1, rx );
|
||||
BOOST_CHECK(
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.begin()) == 3) &&
|
||||
(distance<string::const_iterator>( str1.begin(),cv_result.end()) == 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(
|
||||
(distance<vector<int>::const_iterator>( vec1.begin(),nc_vresult.begin()) == 3) &&
|
||||
(distance<vector<int>::const_iterator>( vec1.begin(),nc_vresult.end()) == 6) );
|
||||
|
||||
cv_vresult=find_regex( vec1, rx );
|
||||
BOOST_CHECK(
|
||||
(distance<vector<int>::const_iterator>( vec1.begin(),cv_vresult.begin()) == 3) &&
|
||||
(distance<vector<int>::const_iterator>( vec1.begin(),cv_vresult.end()) == 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 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() );
|
||||
|
||||
// inmutable 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") );
|
||||
}
|
||||
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
find_test();
|
||||
replace_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
247
string/test/replace_test.cpp
Normal file
247
string/test/replace_test.cpp
Normal file
@ -0,0 +1,247 @@
|
||||
// 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 unit test framework
|
||||
#include <boost/test/included/test_exec_monitor.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <iostream>
|
||||
|
||||
#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>
|
||||
|
||||
// equals predicate is used for result comparison
|
||||
#include <boost/algorithm/string/predicate.hpp>
|
||||
|
||||
#include <boost/test/test_tools.hpp>
|
||||
#include <boost/preprocessor/seq/enum.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 TEST_ALGO( Algo, Input, Params, Output ) \
|
||||
{\
|
||||
BOOST_CHECKPOINT( #Input );\
|
||||
\
|
||||
string str1(Input);\
|
||||
\
|
||||
/* Copy test */ \
|
||||
BOOST_CHECK( Algo##_copy( str1, BOOST_PP_SEQ_ENUM( Params ) )==Output );\
|
||||
\
|
||||
/* Iterator test */\
|
||||
string strout;\
|
||||
Algo##_copy( back_inserter(strout), str1, BOOST_PP_SEQ_ENUM( Params ) );\
|
||||
BOOST_CHECK( strout==Output ); \
|
||||
\
|
||||
/* In-place test */\
|
||||
vector<char> vec1( str1.begin(), str1.end() );\
|
||||
list<char> list1( str1.begin(), str1.end() );\
|
||||
Algo( str1, BOOST_PP_SEQ_ENUM( Params ) ); \
|
||||
BOOST_CHECK( equals( str1, Output ) );\
|
||||
Algo( vec1, BOOST_PP_SEQ_ENUM( Params ) ); \
|
||||
BOOST_CHECK( equals( vec1, Output ) );\
|
||||
Algo( list1, BOOST_PP_SEQ_ENUM( Params ) ); \
|
||||
BOOST_CHECK( equals( list1, Output ) );\
|
||||
}
|
||||
|
||||
void replace_test()
|
||||
{
|
||||
// replace first
|
||||
TEST_ALGO( replace_first, "1abc3abc2", (string("abc"))(string("YYY")), string("1YYY3abc2") );
|
||||
TEST_ALGO( ireplace_first, "1AbC3abc2", ("aBc")("YYY"), string("1YYY3abc2") );
|
||||
TEST_ALGO( replace_first, "1abc3abc2", (string("abc"))(string("Z")), string("1Z3abc2") );
|
||||
TEST_ALGO( replace_first, "1abc3abc2", (string("abc"))(string("XXXX")), string("1XXXX3abc2") );
|
||||
TEST_ALGO( replace_first, "1abc3abc2", (string(""))(string("XXXX")), string("1abc3abc2") );
|
||||
TEST_ALGO( replace_first, "1abc3abc2", ("")("XXXX"), string("1abc3abc2") );
|
||||
TEST_ALGO( replace_first, "", (string(""))(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("") );
|
||||
|
||||
// replace last
|
||||
TEST_ALGO( replace_last, "1abc3abc2", (string("abc"))(string("YYY")), string("1abc3YYY2") );
|
||||
TEST_ALGO( ireplace_last, "1abc3AbC2", ("aBc")("YYY"), string("1abc3YYY2") );
|
||||
TEST_ALGO( replace_last, "1abc3abc2", (string("abc"))(string("Z")), string("1abc3Z2") );
|
||||
TEST_ALGO( replace_last, "1abc3abc2", (string("abc"))(string("XXXX")), string("1abc3XXXX2") );
|
||||
TEST_ALGO( replace_last, "1abc3abc2", ("abc")("XXXX"), string("1abc3XXXX2") );
|
||||
TEST_ALGO( replace_last, "", (string(""))(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("") );
|
||||
|
||||
// replace all
|
||||
TEST_ALGO( replace_all, "1abc3abc2", (string("abc"))(string("YYY")), string("1YYY3YYY2") );
|
||||
TEST_ALGO( ireplace_all, "1aBc3AbC2", ("abC")("YYY"), string("1YYY3YYY2") );
|
||||
TEST_ALGO( replace_all, "1abc3abc2", (string("abc"))(string("Z")), string("1Z3Z2") );
|
||||
TEST_ALGO( replace_all, "1abc3abc2", (string("abc"))(string("XXXX")), string("1XXXX3XXXX2") );
|
||||
TEST_ALGO( replace_all, "1abc3abc2", ("abc")("XXXX"), string("1XXXX3XXXX2") );
|
||||
TEST_ALGO( replace_all, "", (string(""))(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("") );
|
||||
|
||||
// replace nth
|
||||
TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(0)(string("YYY")), string("1YYY3abc2") );
|
||||
TEST_ALGO( ireplace_nth, "1AbC3abc2", ("aBc")(0)("YYY"), string("1YYY3abc2") );
|
||||
TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(0)(string("Z")), string("1Z3abc2") );
|
||||
TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(0)(string("XXXX")), string("1XXXX3abc2") );
|
||||
TEST_ALGO( replace_nth, "1abc3abc2", ("abc")(0)("XXXX"), string("1XXXX3abc2") );
|
||||
TEST_ALGO( replace_nth, "1abc3abc2", (string(""))(0)(string("XXXX")), string("1abc3abc2") );
|
||||
TEST_ALGO( replace_nth, "", (string(""))(0)(string("XXXX")), string("") );
|
||||
TEST_ALGO( erase_nth, "1abc3abc2", (string("abc"))(0), string("13abc2") );
|
||||
TEST_ALGO( ierase_nth, "1aBc3aBc2", ("ABC")(0), string("13aBc2") );
|
||||
TEST_ALGO( erase_nth, "1abc3abc2", ("abc")(0), string("13abc2") );
|
||||
TEST_ALGO( erase_nth, "1abc3abc2", (string(""))(0), string("1abc3abc2") );
|
||||
TEST_ALGO( erase_nth, "", (string("abc"))(0), string("") );
|
||||
TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(1)(string("YYY")), string("1abc3YYY2") );
|
||||
TEST_ALGO( replace_nth, "1abc3abc2", (string("abc"))(2)(string("YYY")), string("1abc3abc2") );
|
||||
|
||||
// replace head
|
||||
TEST_ALGO( replace_head, "abc3abc2", (3)(string("YYY")), string("YYY3abc2") );
|
||||
TEST_ALGO( replace_head, "abc3abc2", (3)("YYY"), string("YYY3abc2") );
|
||||
TEST_ALGO( replace_head, "abc", (3)(string("Z")), string("Z") );
|
||||
TEST_ALGO( replace_head, "abc", (6)(string("XXXX")), string("XXXX") );
|
||||
TEST_ALGO( replace_head, "abc3abc2", (0)(string("XXXX")), string("abc3abc2") );
|
||||
TEST_ALGO( replace_head, "", (4)(string("XXXX")), string("") );
|
||||
TEST_ALGO( erase_head, "abc3abc2", (3), string("3abc2") );
|
||||
TEST_ALGO( erase_head, "abc3abc2", (0), string("abc3abc2") );
|
||||
TEST_ALGO( erase_head, "", (4), string("") );
|
||||
|
||||
// replace tail
|
||||
TEST_ALGO( replace_tail, "abc3abc", (3)(string("YYY")), string("abc3YYY") );
|
||||
TEST_ALGO( replace_tail, "abc3abc", (3)("YYY"), string("abc3YYY") );
|
||||
TEST_ALGO( replace_tail, "abc", (3)(string("Z")), string("Z") );
|
||||
TEST_ALGO( replace_tail, "abc", (6)(string("XXXX")), string("XXXX") );
|
||||
TEST_ALGO( replace_tail, "abc3abc", (0)(string("XXXX")), string("abc3abc") );
|
||||
TEST_ALGO( replace_tail, "", (4)(string("XXXX")), string("") );
|
||||
TEST_ALGO( erase_tail, "abc3abc", (3), string("abc3") );
|
||||
TEST_ALGO( erase_tail, "abc3abc", (0), string("abc3abc") );
|
||||
TEST_ALGO( erase_tail, "", (4), string("") );
|
||||
|
||||
// replace_range
|
||||
{
|
||||
BOOST_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_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") );
|
||||
}
|
||||
|
||||
// container traits complatibility 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") );
|
||||
}
|
||||
}
|
||||
|
||||
// test main
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
sequence_traits_test();
|
||||
replace_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
123
string/test/split_test.cpp
Normal file
123
string/test/split_test.cpp
Normal file
@ -0,0 +1,123 @@
|
||||
// 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 unit test framework
|
||||
#include <boost/test/included/test_exec_monitor.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
|
||||
#include <boost/test/test_tools.hpp>
|
||||
#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>
|
||||
|
||||
|
||||
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");
|
||||
string str3("xx");
|
||||
char* pch1="xx-abc--xx-abb";
|
||||
vector<string> tokens;
|
||||
vector< vector<int> > vtokens;
|
||||
|
||||
ifind_all(
|
||||
tokens,
|
||||
str2,
|
||||
"xx" );
|
||||
|
||||
BOOST_REQUIRE( tokens.size()==2 );
|
||||
BOOST_CHECK( tokens[0]==string("Xx") );
|
||||
BOOST_CHECK( tokens[1]==string("xX") );
|
||||
|
||||
// find_all tests
|
||||
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,
|
||||
str1,
|
||||
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(
|
||||
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") );
|
||||
}
|
||||
|
||||
// test main
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
iterator_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
117
string/test/trim_test.cpp
Normal file
117
string/test/trim_test.cpp
Normal file
@ -0,0 +1,117 @@
|
||||
// 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 unit test framework
|
||||
#include <boost/test/included/test_exec_monitor.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <boost/algorithm/string/trim.hpp>
|
||||
#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" );
|
||||
}
|
||||
|
||||
// test main
|
||||
int test_main( int, char*[] )
|
||||
{
|
||||
trim_test();
|
||||
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user