diff options
Diffstat (limited to 'src/boost/libs/algorithm/string')
20 files changed, 2434 insertions, 0 deletions
diff --git a/src/boost/libs/algorithm/string/example/Jamfile b/src/boost/libs/algorithm/string/example/Jamfile new file mode 100644 index 000000000..74c923f8b --- /dev/null +++ b/src/boost/libs/algorithm/string/example/Jamfile @@ -0,0 +1,18 @@ +# Boost string_algo library examples 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. + + +exe conv_example : conv_example.cpp ; +exe predicate_example : predicate_example.cpp ; +exe find_example : find_example.cpp ; +exe replace_example : replace_example.cpp ; +exe rle_example : rle_example.cpp ; +exe trim_example : trim_example.cpp ; +exe regex_example : regex_example.cpp /boost/regex//boost_regex ; +exe split_example : split_example.cpp ;
\ No newline at end of file diff --git a/src/boost/libs/algorithm/string/example/conv_example.cpp b/src/boost/libs/algorithm/string/example/conv_example.cpp new file mode 100644 index 000000000..b6a08f9ca --- /dev/null +++ b/src/boost/libs/algorithm/string/example/conv_example.cpp @@ -0,0 +1,41 @@ +// Boost string_algo library example 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 <string> +#include <vector> +#include <iostream> +#include <iterator> +#include <boost/algorithm/string/case_conv.hpp> + +using namespace std; +using namespace boost; + +int main() +{ + cout << "* Case Conversion Example *" << endl << endl; + + string str1("AbCdEfG"); + vector<char> vec1( str1.begin(), str1.end() ); + + // Convert vector of chars to lower case + cout << "lower-cased copy of vec1: "; + to_lower_copy( ostream_iterator<char>(cout), vec1 ); + cout << endl; + + // Conver string str1 to upper case ( copy the input ) + cout << "upper-cased copy of str1: " << to_upper_copy( str1 ) << endl; + + // Inplace conversion + to_lower( str1 ); + cout << "lower-cased str1: " << str1 << endl; + + cout << endl; + + return 0; +} diff --git a/src/boost/libs/algorithm/string/example/find_example.cpp b/src/boost/libs/algorithm/string/example/find_example.cpp new file mode 100644 index 000000000..7fd7e60a1 --- /dev/null +++ b/src/boost/libs/algorithm/string/example/find_example.cpp @@ -0,0 +1,58 @@ +// Boost string_algo library example 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 <string> +#include <iostream> +#include <algorithm> +#include <functional> +#include <boost/algorithm/string/case_conv.hpp> +#include <boost/algorithm/string/find.hpp> + +using namespace std; +using namespace boost; + +int main() +{ + cout << "* Find Example *" << endl << endl; + + string str1("abc___cde___efg"); + string str2("abc"); + + // find "cde" substring + iterator_range<string::iterator> range=find_first( str1, string("cde") ); + + // convert a substring to upper case + // note that iterator range can be directly passed to the algorithm + to_upper( range ); + + cout << "str1 with upper-cased part matching cde: " << str1 << endl; + + // get a head of the string + iterator_range<string::iterator> head=find_head( str1, 3 ); + cout << "head(3) of the str1: " << string( head.begin(), head.end() ) << endl; + + // get the tail + head=find_tail( str2, 5 ); + cout << "tail(5) of the str2: " << string( head.begin(), head.end() ) << endl; + + // char processing + char text[]="hello dolly!"; + iterator_range<char*> crange=find_last(text,"ll"); + + // transform the range ( add 1 ) + transform( crange.begin(), crange.end(), crange.begin(), bind2nd( plus<char>(), 1 ) ); + // uppercase the range + to_upper( crange ); + + cout << text << endl; + + cout << endl; + + return 0; +} diff --git a/src/boost/libs/algorithm/string/example/predicate_example.cpp b/src/boost/libs/algorithm/string/example/predicate_example.cpp new file mode 100644 index 000000000..26d24e470 --- /dev/null +++ b/src/boost/libs/algorithm/string/example/predicate_example.cpp @@ -0,0 +1,59 @@ +// Boost string_algo library example 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 <string> +#include <iostream> +#include <functional> +#include <boost/algorithm/string/predicate.hpp> +#include <boost/algorithm/string/classification.hpp> + +using namespace std; +using namespace boost; + +int main() +{ + cout << "* Predicate Example *" << endl << endl; + + string str1("123xxx321"); + string str2("abc"); + + // Check if str1 starts with '123' + cout << "str1 starts with \"123\": " << + (starts_with( str1, string("123") )?"true":"false") << endl; + + // Check if str1 ends with '123' + cout << "str1 ends with \"123\": " << + (ends_with( str1, string("123") )?"true":"false") << endl; + + // Check if str1 contains 'xxx' + cout << "str1 contains \"xxx\": " << + (contains( str1, string("xxx") )?"true":"false") << endl; + + + // Check if str2 equals to 'abc' + cout << "str2 equals \"abc\": " << + (equals( str2, string("abc") )?"true":"false") << endl; + + + // Classification functors and all predicate + if ( all(";.,", is_punct() ) ) + { + cout << "\";.,\" are all punctuation characters" << endl; + } + + // Classification predicates can be combined + if ( all("abcxxx", is_any_of("xabc") && !is_space() ) ) + { + cout << "true" << endl; + } + + cout << endl; + + return 0; +} diff --git a/src/boost/libs/algorithm/string/example/regex_example.cpp b/src/boost/libs/algorithm/string/example/regex_example.cpp new file mode 100644 index 000000000..9eba1c73a --- /dev/null +++ b/src/boost/libs/algorithm/string/example/regex_example.cpp @@ -0,0 +1,42 @@ +// Boost string_algo library example 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 <string> +#include <iostream> +#include <iterator> +#include <boost/regex.hpp> +#include <boost/algorithm/string/regex.hpp> + +using namespace std; +using namespace boost; + +int main() +{ + cout << "* Regex Example *" << endl << endl; + + string str1("abc__(456)__123__(123)__cde"); + + // Replace all substrings matching (digit+) + cout << + "replace all (digit+) in str1 with #digit+# :" << + replace_all_regex_copy( str1, regex("\\(([0-9]+)\\)"), string("#$1#") ) << endl; + + // Erase all substrings matching (digit+) + cout << + "remove all sequences of letters from str1 :" << + erase_all_regex_copy( str1, regex("[[:alpha:]]+") ) << endl; + + // in-place regex transformation + replace_all_regex( str1, regex("_(\\([^\\)]*\\))_"), string("-$1-") ); + cout << "transformad str1: " << str1 << endl; + + cout << endl; + + return 0; +} diff --git a/src/boost/libs/algorithm/string/example/replace_example.cpp b/src/boost/libs/algorithm/string/example/replace_example.cpp new file mode 100644 index 000000000..12089fa2d --- /dev/null +++ b/src/boost/libs/algorithm/string/example/replace_example.cpp @@ -0,0 +1,89 @@ +// Boost string_algo library example 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 <string> +#include <iostream> +#include <iterator> +//#include <boost/algorithm/string/replace.hpp> +//#include <boost/algorithm/string/erase.hpp> +//#include <boost/algorithm/string/case_conv.hpp> +#include <boost/algorithm/string.hpp> + +//Following two includes contain second-layer function. +//They are already included by first-layer header + +//#include <boost/algorithm/string/replace2.hpp> +//#include <boost/algorithm/string/find2.hpp> + +using namespace std; +using namespace boost; + +// uppercase formatter +/* + Convert an input to upper case. + Note, that this formatter can be used only on std::string inputs. +*/ +inline string upcase_formatter( + const iterator_range<string::const_iterator>& Replace ) +{ + string Temp(Replace.begin(), Replace.end()); + to_upper(Temp); + return Temp; +} + +int main() +{ + cout << "* Replace Example *" << endl << endl; + + string str1("abc___cde___efg"); + + // Erase 6-9th characters from the string + cout << "str1 without 6th to 9th character:" << + erase_range_copy( str1, make_iterator_range(str1.begin()+6, str1.begin()+9) ) << endl; + + // Replace 6-9th character with '+++' + cout << "str1 with 6th to 9th character replaced with '+++': " << + replace_range_copy( + str1, make_iterator_range(str1.begin()+6, str1.begin()+9), "+++" ) << endl; + + cout << "str1 with 'cde' replaced with 'XYZ': "; + + // Replace first 'cde' with 'XYZ'. Modify the input + replace_first_copy( ostream_iterator<char>(cout), str1, "cde", "XYZ" ); + cout << endl; + + // Replace all '___' + cout << "str1 with all '___' replaced with '---': " << + replace_all_copy( str1, "___", "---" ) << endl; + + // Erase all '___' + cout << "str1 without all '___': " << + erase_all_copy( str1, "___" ) << endl; + + // replace third and 5th occurrence of _ in str1 + // note that nth argument is 0-based + replace_nth( str1, "_", 4, "+" ); + replace_nth( str1, "_", 2, "+" ); + + cout << "str1 with third and 5th occurrence of _ replace: " << str1 << endl; + + // Custom formatter examples + string str2("abC-xxxx-AbC-xxxx-abc"); + + // Find string 'abc' ignoring the case and convert it to upper case + cout << "Upcase all 'abc'(s) in the str2: " << + find_format_all_copy( + str2, + first_finder("abc", is_iequal()), + upcase_formatter ); + + cout << endl; + + return 0; +} diff --git a/src/boost/libs/algorithm/string/example/rle_example.cpp b/src/boost/libs/algorithm/string/example/rle_example.cpp new file mode 100644 index 000000000..ff47ccca4 --- /dev/null +++ b/src/boost/libs/algorithm/string/example/rle_example.cpp @@ -0,0 +1,248 @@ +// Boost string_algo library example 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. + +/* + RLE compression using replace framework. Goal is to compress a sequence of + repeating characters into 3 bytes ( repeat mark, character and repetition count ). + For simplification, it works only on numeric-value sequences. +*/ + +#include <string> +#include <iostream> +#include <limits> +#include <iterator> +#include <boost/algorithm/string/find_format.hpp> +#include <boost/algorithm/string/finder.hpp> + +using namespace std; +using namespace boost; + +// replace mark specification, specialize for a specific element type +template< typename T > T repeat_mark() { return (std::numeric_limits<T>::max)(); }; + +// Compression ----------------------------------------------------------------------- + + +// compress finder -rle +/* + Find a sequence which can be compressed. It has to be at least 3-character long + sequence of repetitive characters +*/ +struct find_compressF +{ + // Construction + find_compressF() {} + + // Operation + template<typename ForwardIteratorT> + iterator_range<ForwardIteratorT> operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + typedef ForwardIteratorT input_iterator_type; + typedef typename std::iterator_traits<input_iterator_type>::value_type value_type; + typedef iterator_range<input_iterator_type> result_type; + + // begin of the matching segment + input_iterator_type MStart=End; + // Repetition counter + value_type Cnt=0; + + // Search for a sequence of repetitive characters + for(input_iterator_type It=Begin; It!=End;) + { + input_iterator_type It2=It++; + + if ( It==End || Cnt>=(std::numeric_limits<value_type>::max)() ) + { + return result_type( MStart, It ); + } + + if ( *It==*It2 ) + { + if ( MStart==End ) + { + // Mark the start + MStart=It2; + } + + // Increate repetition counter + Cnt++; + } + else + { + if ( MStart!=End ) + { + if ( Cnt>2 ) + return result_type( MStart, It ); + else + { + MStart=End; + Cnt=0; + } + } + } + } + + return result_type( End, End ); + } +}; + +// rle compress format +/* + Transform a sequence into repeat mark, character and count +*/ +template<typename SeqT> +struct format_compressF +{ +private: + typedef SeqT result_type; + typedef typename SeqT::value_type value_type; + +public: + // Construction + format_compressF() {}; + + // Operation + template< typename ReplaceT > + result_type operator()( const ReplaceT& Replace ) const + { + SeqT r; + if(!Replace.empty()) + { + r.push_back( repeat_mark<value_type>() ); + r.push_back( *(Replace.begin()) ); + r.push_back( value_type( Replace.size() ) ); + } + + return r; + } +}; + +// Decompression ----------------------------------------------------------------------- + + +// find decompress-rle functor +/* + find a repetition block +*/ +struct find_decompressF +{ + // Construction + find_decompressF() {} + + // Operation + template<typename ForwardIteratorT> + iterator_range<ForwardIteratorT> operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + typedef ForwardIteratorT input_iterator_type; + typedef typename std::iterator_traits<input_iterator_type>::value_type value_type; + typedef iterator_range<input_iterator_type> result_type; + + for(input_iterator_type It=Begin; It!=End; It++) + { + if( *It==repeat_mark<value_type>() ) + { + // Repeat mark found, extract body + input_iterator_type It2=It++; + + if ( It==End ) break; + It++; + if ( It==End ) break; + It++; + + return result_type( It2, It ); + } + } + + return result_type( End, End ); + } +}; + +// rle decompress format +/* + transform a repetition block into a sequence of characters +*/ +template< typename SeqT > +struct format_decompressF +{ +private: + typedef SeqT result_type; + typedef typename SeqT::value_type value_type; + +public: + // Construction + format_decompressF() {}; + + // Operation + template< typename ReplaceT > + result_type operator()( const ReplaceT& Replace ) const + { + SeqT r; + + if(!Replace.empty()) + { + // extract info + typename ReplaceT::const_iterator It=Replace.begin(); + + value_type Value=*(++It); + value_type Repeat=*(++It); + + for( value_type Index=0; Index<Repeat; Index++ ) r.push_back( Value ); + } + + return r; + } +}; + + +int main() +{ + cout << "* RLE Compression Example *" << endl << endl; + + string original("123_AA_*ZZZZZZZZZZZZZZ*34"); + + // copy compression + string compress=find_format_all_copy( + original, + find_compressF(), + format_compressF<string>() ); + + cout << "Compressed string: " << compress << endl; + + // Copy decompression + string decompress=find_format_all_copy( + compress, + find_decompressF(), + format_decompressF<string>() ); + + cout << "Decompressed string: " << decompress << endl; + + // in-place compression + find_format_all( + original, + find_compressF(), + format_compressF<string>() ); + + cout << "Compressed string: " << original << endl; + + // in-place decompression + find_format_all( + original, + find_decompressF(), + format_decompressF<string>() ); + + cout << "Decompressed string: " << original << endl; + + cout << endl; + + return 0; +} diff --git a/src/boost/libs/algorithm/string/example/split_example.cpp b/src/boost/libs/algorithm/string/example/split_example.cpp new file mode 100644 index 000000000..27e261c93 --- /dev/null +++ b/src/boost/libs/algorithm/string/example/split_example.cpp @@ -0,0 +1,62 @@ +// Boost string_algo library example 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 <string> +#include <vector> +#include <iostream> +#include <iterator> +#include <functional> +#include <boost/algorithm/string/classification.hpp> +#include <boost/algorithm/string/split.hpp> +#include <boost/algorithm/string/find_iterator.hpp> + +using namespace std; +using namespace boost; + +int main() +{ + cout << "* Split Example *" << endl << endl; + + string str1("abc-*-ABC-*-aBc"); + + cout << "Before: " << str1 << endl; + + // Find all 'abc' substrings (ignoring the case) + // Create a find_iterator + typedef find_iterator<string::iterator> string_find_iterator; + for(string_find_iterator It= + make_find_iterator(str1, first_finder("abc", is_iequal())); + It!=string_find_iterator(); + ++It) + { + cout << copy_range<std::string>(*It) << endl; + // shift all chars in the match by one + transform( + It->begin(), It->end(), + It->begin(), + bind2nd( plus<char>(), 1 ) ); + } + + // Print the string now + cout << "After: " << str1 << endl; + + // Split the string into tokens ( use '-' and '*' as delimiters ) + // We need copies of the input only, and adjacent tokens are compressed + vector<std::string> ResultCopy; + split(ResultCopy, str1, is_any_of("-*"), token_compress_on); + + for(unsigned int nIndex=0; nIndex<ResultCopy.size(); nIndex++) + { + cout << nIndex << ":" << ResultCopy[nIndex] << endl; + }; + + cout << endl; + + return 0; +} diff --git a/src/boost/libs/algorithm/string/example/trim_example.cpp b/src/boost/libs/algorithm/string/example/trim_example.cpp new file mode 100644 index 000000000..7b1a0bd1e --- /dev/null +++ b/src/boost/libs/algorithm/string/example/trim_example.cpp @@ -0,0 +1,47 @@ +// Boost string_algo library example 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 <string> +#include <iostream> +#include <boost/algorithm/string/trim.hpp> +#include <boost/algorithm/string/classification.hpp> + +using namespace std; +using namespace boost; + +int main() +{ + cout << "* Trim Example *" << endl << endl; + + string str1(" 1x x x x1 "); + string str2("<>trim<>"); + string str3("123abs343"); + + // Simple left trim + cout << "trim_left copy of str1: " << "\"" << trim_left_copy( str1 ) << "\"" << endl; + + // Inplace right trim + trim_right( str1 ); + cout << "trim_right on str1: " << "\"" << str1 << "\"" << endl; + + // Parametric trim. 'Space' is defined using is_any_of predicate + cout + << "trimmed copy of str4 ( space='<>' ): " + << "\""<< trim_copy_if( str2, is_any_of("<>") ) << "\"" << endl; + + + // Parametric trim. 'Space' is defined using is_digit predicate + cout + << "trimmed copy of str5 ( space=digit ): " + << "\"" << trim_copy_if( str3, is_digit() ) << "\"" << endl; + + cout << endl; + + return 0; +} diff --git a/src/boost/libs/algorithm/string/index.html b/src/boost/libs/algorithm/string/index.html new file mode 100644 index 000000000..dc0e1b9c4 --- /dev/null +++ b/src/boost/libs/algorithm/string/index.html @@ -0,0 +1,14 @@ +<html> +<head> +<meta http-equiv="refresh" content="0; URL=../../../doc/html/string_algo.html"> +</head> +<body> +Automatic redirection failed, please go to +<a href="../../../doc/html/string_algo.html">../../doc/html/string_algo.html</a> + <hr> +<p>© Copyright Beman Dawes, 2001</p> +<p>Distributed under the Boost Software License, Version 1.0. (See accompanying +file <a href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy +at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p> +</body> +</html>
\ No newline at end of file diff --git a/src/boost/libs/algorithm/string/test/Jamfile.v2 b/src/boost/libs/algorithm/string/test/Jamfile.v2 new file mode 100644 index 000000000..7f60df703 --- /dev/null +++ b/src/boost/libs/algorithm/string/test/Jamfile.v2 @@ -0,0 +1,74 @@ +# Boost string_algo library test suite Jamfile ---------------------------- +# +# Copyright Pavol Droba 2002-2003. Use, modification and +# distribution is subject to the Boost Software License, Version +# 1.0. (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) +# +# See http://www.boost.org for updates, documentation, and revision history. + +import testing ; + +alias unit_test_framework + : # sources + /boost//unit_test_framework + ; + +test-suite algorithm/string + : [ run + trim_test.cpp unit_test_framework + : : + : + : trim + ] + [ run + conv_test.cpp unit_test_framework + : : + : + : conv + ] + [ run + predicate_test.cpp unit_test_framework + : : + : + : predicate + ] + [ run + find_test.cpp unit_test_framework + : : + : + : find + ] + [ run + split_test.cpp unit_test_framework + : : + : + : split + ] + [ run + join_test.cpp unit_test_framework + : : + : + : join + ] + [ run + replace_test.cpp unit_test_framework + : : + : + : replace + ] + [ run + regex_test.cpp unit_test_framework + ../../../regex/build//boost_regex + : : + : + : regex + ] + [ run + find_format_test.cpp unit_test_framework + : : + : + : find_format + ] + ; + diff --git a/src/boost/libs/algorithm/string/test/conv_test.cpp b/src/boost/libs/algorithm/string/test/conv_test.cpp new file mode 100644 index 000000000..c583d3efe --- /dev/null +++ b/src/boost/libs/algorithm/string/test/conv_test.cpp @@ -0,0 +1,94 @@ +// Boost string_algo library conv_test.cpp file ---------------------------// + +// Copyright Pavol Droba 2002-2003. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <boost/algorithm/string/case_conv.hpp> + +// Include unit test framework +#define BOOST_TEST_MAIN +#include <boost/test/unit_test.hpp> + +#include <string> +#include <iostream> +#include <algorithm> +#include <boost/test/test_tools.hpp> + +using namespace std; +using namespace boost; + +void conv_test() +{ + string str1("AbCdEfG 123 xxxYYYzZzZ"); + string str2("AbCdEfG 123 xxxYYYzZzZ"); + string str3(""); + const char pch[]="AbCdEfG 123 xxxYYYzZzZ"; + unsigned int pchlen=sizeof(pch); + + char* pch1=new char[pchlen]; + std::copy(pch, pch+pchlen, pch1); + char* pch2=new char[pchlen]; + std::copy(pch, pch+pchlen, pch2); + + // *** iterator tests *** // + + string strout; + to_lower_copy( back_inserter(strout), str1 ); + BOOST_CHECK( strout=="abcdefg 123 xxxyyyzzzz" ); + strout.clear(); + to_upper_copy( back_inserter(strout), str1 ); + BOOST_CHECK( strout=="ABCDEFG 123 XXXYYYZZZZ" ); + + strout.clear(); + to_lower_copy( back_inserter(strout), "AbCdEfG 123 xxxYYYzZzZ" ); + BOOST_CHECK( strout=="abcdefg 123 xxxyyyzzzz" ); + strout.clear(); + to_upper_copy( back_inserter(strout), "AbCdEfG 123 xxxYYYzZzZ" ); + BOOST_CHECK( strout=="ABCDEFG 123 XXXYYYZZZZ" ); + + strout.clear(); + to_lower_copy( back_inserter(strout), pch1 ); + BOOST_CHECK( strout=="abcdefg 123 xxxyyyzzzz" ); + strout.clear(); + to_upper_copy( back_inserter(strout), pch1 ); + BOOST_CHECK( strout=="ABCDEFG 123 XXXYYYZZZZ" ); + + // *** value passing tests *** // + + BOOST_CHECK( to_lower_copy( str1 )=="abcdefg 123 xxxyyyzzzz" ); + BOOST_CHECK( to_upper_copy( str1 )=="ABCDEFG 123 XXXYYYZZZZ" ); + + BOOST_CHECK( to_lower_copy( str3 )=="" ); + BOOST_CHECK( to_upper_copy( str3 )=="" ); + + // *** inplace tests *** // + + to_lower( str1 ); + BOOST_CHECK( str1=="abcdefg 123 xxxyyyzzzz" ); + to_upper( str2 ); + BOOST_CHECK( str2=="ABCDEFG 123 XXXYYYZZZZ" ); + + // c-string modification + to_lower( pch1 ); + BOOST_CHECK( string(pch1)=="abcdefg 123 xxxyyyzzzz" ); + to_upper( pch2 ); + BOOST_CHECK( string(pch2)=="ABCDEFG 123 XXXYYYZZZZ" ); + + to_lower( str3 ); + BOOST_CHECK( str3=="" ); + to_upper( str3 ); + BOOST_CHECK( str3=="" ); + + delete[] pch1; + delete[] pch2; +} + +// test main +BOOST_AUTO_TEST_CASE( test_main ) +{ + conv_test(); +} diff --git a/src/boost/libs/algorithm/string/test/find_format_test.cpp b/src/boost/libs/algorithm/string/test/find_format_test.cpp new file mode 100644 index 000000000..645cdba3a --- /dev/null +++ b/src/boost/libs/algorithm/string/test/find_format_test.cpp @@ -0,0 +1,162 @@ +// Boost string_algo library find_format_test.cpp file ------------------// + +// Copyright (c) 2009 Steven Watanabe +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <boost/algorithm/string/find_format.hpp> +#include <boost/algorithm/string/finder.hpp> +#include <boost/algorithm/string/formatter.hpp> + +// Include unit test framework +#define BOOST_TEST_MAIN +#include <boost/test/unit_test.hpp> + +#include <boost/test/test_tools.hpp> + +// We're only using const_formatter. +template<class Formatter> +struct formatter_result { + typedef boost::iterator_range<const char*> type; +}; + +template<class Formatter> +struct checked_formatter { +public: + checked_formatter(const Formatter& formatter) : formatter_(formatter) {} + template< typename T > + typename formatter_result<Formatter>::type operator()( const T & s ) const { + BOOST_CHECK( !s.empty() ); + return formatter_(s); + } +private: + Formatter formatter_; +}; + +template<class Formatter> +checked_formatter<Formatter> +make_checked_formatter(const Formatter& formatter) { + return checked_formatter<Formatter>(formatter); +} + +void find_format_test() +{ + const std::string source = "$replace $replace"; + std::string expected = "ok $replace"; + std::string output(80, '\0'); + + std::string::iterator pos = + boost::find_format_copy( + output.begin(), + source, + boost::first_finder("$replace"), + make_checked_formatter(boost::const_formatter("ok"))); + BOOST_CHECK(pos == output.begin() + expected.size()); + output.erase(std::remove(output.begin(), output.end(), '\0'), output.end()); + BOOST_CHECK_EQUAL(output, expected); + + output = + boost::find_format_copy( + source, + boost::first_finder("$replace"), + make_checked_formatter(boost::const_formatter("ok"))); + BOOST_CHECK_EQUAL(output, expected); + + // now try finding a string that doesn't exist + output.resize(80); + pos = + boost::find_format_copy( + output.begin(), + source, + boost::first_finder("$noreplace"), + make_checked_formatter(boost::const_formatter("bad"))); + BOOST_CHECK(pos == output.begin() + source.size()); + output.erase(std::remove(output.begin(), output.end(), '\0'), output.end()); + BOOST_CHECK_EQUAL(output, source); + + output = + boost::find_format_copy( + source, + boost::first_finder("$noreplace"), + make_checked_formatter(boost::const_formatter("bad"))); + BOOST_CHECK_EQUAL(output, source); + + // in place version + output = source; + boost::find_format( + output, + boost::first_finder("$replace"), + make_checked_formatter(boost::const_formatter("ok"))); + BOOST_CHECK_EQUAL(output, expected); + output = source; + boost::find_format( + output, + boost::first_finder("$noreplace"), + make_checked_formatter(boost::const_formatter("bad"))); + BOOST_CHECK_EQUAL(output, source); +} + +void find_format_all_test() +{ + const std::string source = "$replace $replace"; + std::string expected = "ok ok"; + std::string output(80, '\0'); + + std::string::iterator pos = + boost::find_format_all_copy(output.begin(), + source, + boost::first_finder("$replace"), + boost::const_formatter("ok")); + BOOST_CHECK(pos == output.begin() + expected.size()); + output.erase(std::remove(output.begin(), output.end(), '\0'), output.end()); + BOOST_CHECK_EQUAL(output, expected); + + output = + boost::find_format_all_copy( + source, + boost::first_finder("$replace"), + make_checked_formatter(boost::const_formatter("ok"))); + BOOST_CHECK_EQUAL(output, expected); + + // now try finding a string that doesn't exist + output.resize(80); + pos = + boost::find_format_all_copy( + output.begin(), + source, + boost::first_finder("$noreplace"), + make_checked_formatter(boost::const_formatter("bad"))); + BOOST_CHECK(pos == output.begin() + source.size()); + output.erase(std::remove(output.begin(), output.end(), '\0'), output.end()); + BOOST_CHECK_EQUAL(output, source); + + output = + boost::find_format_all_copy( + source, + boost::first_finder("$noreplace"), + make_checked_formatter(boost::const_formatter("bad"))); + BOOST_CHECK_EQUAL(output, source); + + // in place version + output = source; + boost::find_format_all( + output, + boost::first_finder("$replace"), + make_checked_formatter(boost::const_formatter("ok"))); + BOOST_CHECK_EQUAL(output, expected); + output = source; + boost::find_format_all( + output, + boost::first_finder("$noreplace"), + make_checked_formatter(boost::const_formatter("bad"))); + BOOST_CHECK_EQUAL(output, source); +} + +BOOST_AUTO_TEST_CASE( test_main ) +{ + find_format_test(); + find_format_all_test(); +} diff --git a/src/boost/libs/algorithm/string/test/find_test.cpp b/src/boost/libs/algorithm/string/test/find_test.cpp new file mode 100644 index 000000000..8439b3c10 --- /dev/null +++ b/src/boost/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(); +} diff --git a/src/boost/libs/algorithm/string/test/join_test.cpp b/src/boost/libs/algorithm/string/test/join_test.cpp new file mode 100644 index 000000000..9c5150baf --- /dev/null +++ b/src/boost/libs/algorithm/string/test/join_test.cpp @@ -0,0 +1,78 @@ +// Boost string_algo library iterator_test.cpp file ---------------------------// + +// Copyright Pavol Droba 2002-2003. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <boost/algorithm/string/join.hpp> +#include <boost/algorithm/string/classification.hpp> +// equals predicate is used for result comparison +#include <boost/algorithm/string/predicate.hpp> + +// Include unit test framework +#define BOOST_TEST_MAIN +#include <boost/test/unit_test.hpp> + +#include <string> +#include <vector> +#include <iostream> + +#include <boost/test/test_tools.hpp> + + +using namespace std; +using namespace boost; + +bool is_not_empty(const std::string& str) +{ + return !str.empty(); +} + +void join_test() +{ + // Prepare inputs + vector<string> tokens1; + tokens1.push_back("xx"); + tokens1.push_back("abc"); + tokens1.push_back("xx"); + + vector<string> tokens2; + tokens2.push_back(""); + tokens2.push_back("xx"); + tokens2.push_back("abc"); + tokens2.push_back(""); + tokens2.push_back("abc"); + tokens2.push_back("xx"); + tokens2.push_back(""); + + vector<string> tokens3; + tokens3.push_back(""); + tokens3.push_back(""); + tokens3.push_back(""); + + vector<string> empty_tokens; + + vector<vector<int> > vtokens; + for(unsigned int n=0; n<tokens2.size(); ++n) + { + vtokens.push_back(vector<int>(tokens2[n].begin(), tokens2[n].end())); + } + + BOOST_CHECK( equals(join(tokens1, "-"), "xx-abc-xx") ); + BOOST_CHECK( equals(join(tokens2, "-"), "-xx-abc--abc-xx-") ); + BOOST_CHECK( equals(join(vtokens, "-"), "-xx-abc--abc-xx-") ); + BOOST_CHECK( equals(join(empty_tokens, "-"), "") ); + + BOOST_CHECK( equals(join_if(tokens2, "-", is_not_empty), "xx-abc-abc-xx") ); + BOOST_CHECK( equals(join_if(empty_tokens, "-", is_not_empty), "") ); + BOOST_CHECK( equals(join_if(tokens3, "-", is_not_empty), "") ); +} + + +BOOST_AUTO_TEST_CASE( test_main ) +{ + join_test(); +} diff --git a/src/boost/libs/algorithm/string/test/predicate_test.cpp b/src/boost/libs/algorithm/string/test/predicate_test.cpp new file mode 100644 index 000000000..ba1564e53 --- /dev/null +++ b/src/boost/libs/algorithm/string/test/predicate_test.cpp @@ -0,0 +1,160 @@ +// Boost string_algo library predicate_test.cpp file ------------------// + +// Copyright Pavol Droba 2002-2003. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <boost/algorithm/string/predicate.hpp> +#include <boost/algorithm/string/classification.hpp> + +// Include unit test framework +#define BOOST_TEST_MAIN +#include <boost/test/unit_test.hpp> + +#include <string> +#include <vector> +#include <iostream> +#include <functional> +#include <boost/test/test_tools.hpp> + +using namespace std; +using namespace boost; + +void predicate_test() +{ + string str1("123xxx321"); + string str1_prefix("123"); + string str2("abc"); + string str3(""); + string str4("abc"); + vector<int> vec1( str1.begin(), str1.end() ); + + // Basic tests + BOOST_CHECK( starts_with( str1, string("123") ) ); + BOOST_CHECK( !starts_with( str1, string("1234") ) ); + + BOOST_CHECK( istarts_with( "aBCxxx", "abc" ) ); + BOOST_CHECK( !istarts_with( "aBCxxx", "abcd" ) ); + + BOOST_CHECK( ends_with( str1, string("321") ) ); + BOOST_CHECK( !ends_with( str1, string("123") ) ); + + BOOST_CHECK( iends_with( "aBCxXx", "XXX" ) ); + BOOST_CHECK( !iends_with( "aBCxxX", "xXXX" ) ); + + BOOST_CHECK( contains( str1, string("xxx") ) ); + BOOST_CHECK( !contains( str1, string("yyy") ) ); + + BOOST_CHECK( icontains( "123XxX321", "xxx" ) ); + BOOST_CHECK( !icontains( "123xXx321", "yyy" ) ); + + BOOST_CHECK( equals( str2, string("abc") ) ); + BOOST_CHECK( !equals( str1, string("yyy") ) ); + + BOOST_CHECK( iequals( "AbC", "abc" ) ); + BOOST_CHECK( !iequals( "aBc", "yyy" ) ); + + BOOST_CHECK( lexicographical_compare("abc", "abd") ); + BOOST_CHECK( !lexicographical_compare("abc", "abc") ); + BOOST_CHECK( lexicographical_compare("abc", "abd", is_less()) ); + + BOOST_CHECK( !ilexicographical_compare("aBD", "AbC") ); + BOOST_CHECK( ilexicographical_compare("aBc", "AbD") ); + BOOST_CHECK( lexicographical_compare("abC", "aBd", is_iless()) ); + + // multi-type comparison test + BOOST_CHECK( starts_with( vec1, string("123") ) ); + BOOST_CHECK( ends_with( vec1, string("321") ) ); + BOOST_CHECK( contains( vec1, string("xxx") ) ); + BOOST_CHECK( equals( vec1, str1 ) ); + + // overflow test + BOOST_CHECK( !starts_with( str2, string("abcd") ) ); + BOOST_CHECK( !ends_with( str2, string("abcd") ) ); + BOOST_CHECK( !contains( str2, string("abcd") ) ); + BOOST_CHECK( !equals( str2, string("abcd") ) ); + + // equal test + BOOST_CHECK( starts_with( str2, string("abc") ) ); + BOOST_CHECK( ends_with( str2, string("abc") ) ); + BOOST_CHECK( contains( str2, string("abc") ) ); + BOOST_CHECK( equals( str2, string("abc") ) ); + + //! Empty string test + BOOST_CHECK( starts_with( str2, string("") ) ); + BOOST_CHECK( ends_with( str2, string("") ) ); + BOOST_CHECK( contains( str2, string("") ) ); + BOOST_CHECK( equals( str3, string("") ) ); + + //! Container compatibility test + BOOST_CHECK( starts_with( "123xxx321", "123" ) ); + BOOST_CHECK( ends_with( "123xxx321", "321" ) ); + BOOST_CHECK( contains( "123xxx321", "xxx" ) ); + BOOST_CHECK( equals( "123xxx321", "123xxx321" ) ); + +} + +template<typename Pred, typename Input> +void test_pred(const Pred& pred, const Input& input, bool bYes) +{ + // test assignment operator + Pred pred1=pred; + pred1=pred; + pred1=pred1; + if(bYes) + { + BOOST_CHECK( all( input, pred ) ); + BOOST_CHECK( all( input, pred1 ) ); + } + else + { + BOOST_CHECK( !all( input, pred ) ); + BOOST_CHECK( !all( input, pred1 ) ); + } +} + +#define TEST_CLASS( Pred, YesInput, NoInput )\ +{\ + test_pred(Pred, YesInput, true); \ + test_pred(Pred, NoInput, false); \ +} + +void classification_test() +{ + TEST_CLASS( is_space(), "\n\r\t ", "..." ); + TEST_CLASS( is_alnum(), "ab129ABc", "_ab129ABc" ); + TEST_CLASS( is_alpha(), "abc", "abc1" ); + TEST_CLASS( is_cntrl(), "\n\t\r", "..." ); + TEST_CLASS( is_digit(), "1234567890", "abc" ); + TEST_CLASS( is_graph(), "123abc.,", " \t" ); + TEST_CLASS( is_lower(), "abc", "Aasdf" ); + TEST_CLASS( is_print(), "abs", "\003\004asdf" ); + TEST_CLASS( is_punct(), ".,;\"", "abc" ); + TEST_CLASS( is_upper(), "ABC", "aBc" ); + TEST_CLASS( is_xdigit(), "ABC123", "XFD" ); + TEST_CLASS( is_any_of( string("abc") ), "aaabbcc", "aaxb" ); + TEST_CLASS( is_any_of( "abc" ), "aaabbcc", "aaxb" ); + TEST_CLASS( is_from_range( 'a', 'c' ), "aaabbcc", "aaxb" ); + + TEST_CLASS( !is_classified(std::ctype_base::space), "...", "..\n\r\t " ); + TEST_CLASS( ( !is_any_of("abc") && is_from_range('a','e') ) || is_space(), "d e", "abcde" ); + + // is_any_of test +// TEST_CLASS( !is_any_of(""), "", "aaa" ) + TEST_CLASS( is_any_of("a"), "a", "ab" ) + TEST_CLASS( is_any_of("ba"), "ab", "abc" ) + TEST_CLASS( is_any_of("cba"), "abc", "abcd" ) + TEST_CLASS( is_any_of("hgfedcba"), "abcdefgh", "abcdefghi" ) + TEST_CLASS( is_any_of("qponmlkjihgfedcba"), "abcdefghijklmnopq", "zzz" ) +} + +#undef TEST_CLASS + +BOOST_AUTO_TEST_CASE( test_main ) +{ + predicate_test(); + classification_test(); +} diff --git a/src/boost/libs/algorithm/string/test/regex_test.cpp b/src/boost/libs/algorithm/string/test/regex_test.cpp new file mode 100644 index 000000000..f93c1d9d3 --- /dev/null +++ b/src/boost/libs/algorithm/string/test/regex_test.cpp @@ -0,0 +1,158 @@ +// Boost string_algo library substr_test.cpp file ------------------// + +// Copyright Pavol Droba 2002-2003. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <boost/algorithm/string/regex.hpp> +#include <boost/algorithm/string/join.hpp> +#include <boost/algorithm/string/sequence_traits.hpp> +// equals predicate is used for result comparison +#include <boost/algorithm/string/predicate.hpp> + + +// Include unit test framework +#define BOOST_TEST_MAIN +#include <boost/test/unit_test.hpp> + +#include <string> +#include <vector> +#include <iostream> +#include <boost/regex.hpp> +#include <boost/test/test_tools.hpp> + +using namespace std; +using namespace boost; + +static void find_test() +{ + string str1("123a1cxxxa23cXXXa456c321"); + const char* pch1="123a1cxxxa23cXXXa456c321"; + regex rx("a[0-9]+c"); + vector<int> vec1( str1.begin(), str1.end() ); + vector<string> tokens; + + // find results + iterator_range<string::iterator> nc_result; + iterator_range<string::const_iterator> cv_result; + + iterator_range<vector<int>::iterator> nc_vresult; + iterator_range<vector<int>::const_iterator> cv_vresult; + + iterator_range<const char*> ch_result; + + // basic tests + nc_result=find_regex( str1, rx ); + BOOST_CHECK( + ( (nc_result.begin()-str1.begin()) == 3) && + ( (nc_result.end()-str1.begin()) == 6) ); + + cv_result=find_regex( str1, rx ); + BOOST_CHECK( + ( (cv_result.begin()-str1.begin()) == 3) && + ( (cv_result.end()-str1.begin()) == 6) ); + + ch_result=find_regex( pch1, rx ); + BOOST_CHECK(( (ch_result.begin() - pch1 ) == 3) && ( (ch_result.end() - pch1 ) == 6 ) ); + + // multi-type comparison test + nc_vresult=find_regex( vec1, rx ); + BOOST_CHECK( + ( (nc_result.begin()-str1.begin()) == 3) && + ( (nc_result.end()-str1.begin()) == 6) ); + + cv_vresult=find_regex( vec1, rx ); + BOOST_CHECK( + ( (cv_result.begin()-str1.begin()) == 3) && + ( (cv_result.end()-str1.begin()) == 6) ); + + // find_all_regex test + find_all_regex( tokens, str1, rx ); + + BOOST_REQUIRE( tokens.size()==3 ); + BOOST_CHECK( tokens[0]==string("a1c") ); + BOOST_CHECK( tokens[1]==string("a23c") ); + BOOST_CHECK( tokens[2]==string("a456c") ); + + // split_regex test + split_regex( tokens, str1, rx ); + + BOOST_REQUIRE( tokens.size()==4 ); + BOOST_CHECK( tokens[0]==string("123") ); + BOOST_CHECK( tokens[1]==string("xxx") ); + BOOST_CHECK( tokens[2]==string("XXX") ); + BOOST_CHECK( tokens[3]==string("321") ); + +} + +static void join_test() +{ + // Prepare inputs + vector<string> tokens1; + tokens1.push_back("xx"); + tokens1.push_back("abc"); + tokens1.push_back("xx"); + +#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING + BOOST_CHECK( equals(join_if(tokens1, "-", regex("x+")), "xx-xx") ); + BOOST_CHECK( equals(join_if(tokens1, "-", regex("[abc]+")), "abc") ); +#else + BOOST_CHECK( equals(join_if_regex(tokens1, "-", regex("x+")), "xx-xx") ); + BOOST_CHECK( equals(join_if_regex(tokens1, "-", regex("[abc]+")), "abc") ); +#endif +} + +static void replace_test() +{ + string str1("123a1cxxxa23cXXXa456c321"); + regex rx1("a([0-9]+)c"); + regex rx2("([xX]+)"); + regex rx3("_[^_]*_"); + string fmt1("_A$1C_"); + string fmt2("_xXx_"); + vector<int> vec1( str1.begin(), str1.end() ); + + // immutable tests + + // basic tests + BOOST_CHECK( replace_regex_copy( str1, rx1, fmt1 )==string("123_A1C_xxxa23cXXXa456c321") ); + BOOST_CHECK( replace_all_regex_copy( str1, rx1, fmt1 )==string("123_A1C_xxx_A23C_XXX_A456C_321") ); + BOOST_CHECK( erase_regex_copy( str1, rx1 )==string("123xxxa23cXXXa456c321") ); + BOOST_CHECK( erase_all_regex_copy( str1, rx1 )==string(string("123xxxXXX321")) ); + + // output iterator variants test + string strout; + replace_regex_copy( back_inserter(strout), str1, rx1, fmt1 ); + BOOST_CHECK( strout==string("123_A1C_xxxa23cXXXa456c321") ); + strout.clear(); + replace_all_regex_copy( back_inserter(strout), str1, rx1, fmt1 ); + BOOST_CHECK( strout==string("123_A1C_xxx_A23C_XXX_A456C_321") ); + strout.clear(); + erase_regex_copy( back_inserter(strout), str1, rx1 ); + BOOST_CHECK( strout==string("123xxxa23cXXXa456c321") ); + strout.clear(); + erase_all_regex_copy( back_inserter(strout), str1, rx1 ); + BOOST_CHECK( strout==string("123xxxXXX321") ); + strout.clear(); + + // in-place test + replace_regex( str1, rx1, fmt2 ); + BOOST_CHECK( str1==string("123_xXx_xxxa23cXXXa456c321") ); + + replace_all_regex( str1, rx2, fmt1 ); + BOOST_CHECK( str1==string("123__AxXxC___AxxxC_a23c_AXXXC_a456c321") ); + erase_regex( str1, rx3 ); + BOOST_CHECK( str1==string("123AxXxC___AxxxC_a23c_AXXXC_a456c321") ); + erase_all_regex( str1, rx3 ); + BOOST_CHECK( str1==string("123AxXxCa23ca456c321") ); +} + +BOOST_AUTO_TEST_CASE( test_main ) +{ + find_test(); + join_test(); + replace_test(); +} diff --git a/src/boost/libs/algorithm/string/test/replace_test.cpp b/src/boost/libs/algorithm/string/test/replace_test.cpp new file mode 100644 index 000000000..789d8e482 --- /dev/null +++ b/src/boost/libs/algorithm/string/test/replace_test.cpp @@ -0,0 +1,321 @@ +// Boost string_algo library substr_test.cpp file ------------------// + +// Copyright Pavol Droba 2002-2003. Use, modification and +// distribution is subject to the Boost Software License, Version +// 1.0. (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include <boost/algorithm/string/replace.hpp> +#include <boost/algorithm/string/erase.hpp> +#include <boost/algorithm/string/std/list_traits.hpp> +#include <boost/algorithm/string/std/string_traits.hpp> +#include <boost/algorithm/string/finder.hpp> +#include <boost/algorithm/string/formatter.hpp> +#include <boost/algorithm/string/classification.hpp> + +// Include unit test framework +#define BOOST_TEST_MAIN +#include <boost/test/unit_test.hpp> + +#include <string> +#include <vector> +#include <list> +#include <iostream> + +// equals predicate is used for result comparison +#include <boost/algorithm/string/predicate.hpp> + +#include <boost/test/test_tools.hpp> + +using namespace std; +using namespace boost; + +void sequence_traits_test() +{ + // basic_string traits + BOOST_CHECK( boost::algorithm::has_native_replace<string>::value ); + BOOST_CHECK( !boost::algorithm::has_stable_iterators<string>::value ); + BOOST_CHECK( !boost::algorithm::has_const_time_insert<string>::value ); + BOOST_CHECK( !boost::algorithm::has_const_time_erase<string>::value ); + + // vector traits + BOOST_CHECK( !boost::algorithm::has_native_replace< vector<char> >::value ); + BOOST_CHECK( !boost::algorithm::has_stable_iterators< vector<char> >::value ); + BOOST_CHECK( !boost::algorithm::has_const_time_insert< vector<char> >::value ); + BOOST_CHECK( !boost::algorithm::has_const_time_erase< vector<char> >::value ); + + // list traits + BOOST_CHECK( !boost::algorithm::has_native_replace< list<char> >::value ); + BOOST_CHECK( boost::algorithm::has_stable_iterators< list<char> >::value ); + BOOST_CHECK( boost::algorithm::has_const_time_insert< list<char> >::value ); + BOOST_CHECK( boost::algorithm::has_const_time_erase< list<char> >::value ); +} + +// Combine tests for all variants of the algorithm +#define C_ , +#define TEST_ALGO( Algo, Input, Params, Output ) \ +{\ + BOOST_TEST_CHECKPOINT( #Algo " - Copy" );\ +\ + string str1(Input);\ +\ + /* Copy test */ \ + BOOST_CHECK( Algo##_copy( str1, Params )==Output );\ +\ + BOOST_TEST_CHECKPOINT( #Algo " - Iterator" );\ + /* Iterator test */\ + string strout;\ + Algo##_copy( back_inserter(strout), str1, Params );\ + BOOST_CHECK( strout==Output ); \ +\ + /* In-place test */\ + vector<char> vec1( str1.begin(), str1.end() );\ + list<char> list1( str1.begin(), str1.end() );\ +\ + BOOST_TEST_CHECKPOINT( #Algo " - Inplace(string)" );\ + Algo( str1, Params ); \ + BOOST_CHECK( equals( str1, Output ) ); \ +\ + BOOST_TEST_CHECKPOINT( #Algo " - Inplace(vector)" );\ + Algo( vec1, Params ); \ + BOOST_CHECK( equals( vec1, Output ) );\ +\ + BOOST_TEST_CHECKPOINT( #Algo " - Inplace(list)" );\ + Algo( list1, Params ); \ + BOOST_CHECK( equals( list1, Output ) );\ +} + +void replace_first_test() +{ + // replace first + TEST_ALGO( replace_first, "1abc3abc2", string("abc") C_ string("YYY"), string("1YYY3abc2") ); + TEST_ALGO( ireplace_first, "1AbC3abc2", "aBc" C_ "YYY", string("1YYY3abc2") ); + TEST_ALGO( replace_first, "1abc3abc2", string("abc") C_ string("Z"), string("1Z3abc2") ); + TEST_ALGO( replace_first, "1abc3abc2", string("abc") C_ string("XXXX"), string("1XXXX3abc2") ); + TEST_ALGO( replace_first, "1abc3abc2", string("") C_ string("XXXX"), string("1abc3abc2") ); + TEST_ALGO( replace_first, "1abc3abc2", "" C_ "XXXX", string("1abc3abc2") ); + TEST_ALGO( replace_first, "", string("") C_ string("XXXX"), string("") ); + TEST_ALGO( erase_first, "1abc3abc2", string("abc"), string("13abc2") ); + TEST_ALGO( ierase_first, "1aBc3abc2", "abC", "13abc2" ); + TEST_ALGO( erase_first, "1abc3abc2", "abc", "13abc2" ); + TEST_ALGO( erase_first, "1abc3abc2", string(""), string("1abc3abc2") ); + TEST_ALGO( erase_first, "", string("abc"), string("") ); +} + +void replace_last_test() +{ + // replace last + TEST_ALGO( replace_last, "1abc3abc2", string("abc") C_ string("YYY"), string("1abc3YYY2") ); + TEST_ALGO( ireplace_last, "1abc3AbC2", "aBc" C_ "YYY", string("1abc3YYY2") ); + TEST_ALGO( replace_last, "1abc3abc2", string("abc") C_ string("Z"), string("1abc3Z2") ); + TEST_ALGO( replace_last, "1abc3abc2", string("abc") C_ string("XXXX"), string("1abc3XXXX2") ); + TEST_ALGO( replace_last, "1abc3abc2", "abc" C_ "XXXX", string("1abc3XXXX2") ); + TEST_ALGO( replace_last, "", string("") C_ string("XXXX"), string("") ); + TEST_ALGO( erase_last, "1abc3abc2", string("abc"), string("1abc32") ); + TEST_ALGO( ierase_last, "1aBc3aBc2", "ABC", string("1aBc32") ); + TEST_ALGO( erase_last, "1abc3abc2", "abc", string("1abc32") ); + TEST_ALGO( erase_last, "1abc3abc2", string(""), string("1abc3abc2") ); + TEST_ALGO( erase_last, "", string("abc"), string("") ); +} + +void replace_all_test() +{ + // replace all + TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("YYY"), string("1YYY3YYY2") ); + TEST_ALGO( replace_all, string("1abc3abc2"), "/" C_ "\\", string("1abc3abc2") ); + TEST_ALGO( ireplace_all, "1aBc3AbC2", "abC" C_ "YYY", string("1YYY3YYY2") ); + TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("Z"), string("1Z3Z2") ); + TEST_ALGO( replace_all, "1abc3abc2", string("abc") C_ string("XXXX"), string("1XXXX3XXXX2") ); + TEST_ALGO( replace_all, "1abc3abc2", "abc" C_ "XXXX", string("1XXXX3XXXX2") ); + TEST_ALGO( replace_all, "", string("") C_ string("XXXX"), string("") ); + TEST_ALGO( erase_all, "1abc3abc2", string("abc"), string("132") ); + TEST_ALGO( ierase_all, "1aBc3aBc2", "aBC", string("132") ); + TEST_ALGO( erase_all, "1abc3abc2", "abc", string("132") ); + TEST_ALGO( erase_all, "1abc3abc2", string(""), string("1abc3abc2") ); + TEST_ALGO( erase_all, "", string("abc"), string("") ); +} + +void replace_nth_test() +{ + // replace nth + TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 0 C_ string("YYY"), string("1YYY3abc2") ); + TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ -1 C_ string("YYY"), string("1abc3YYY2") ); + TEST_ALGO( ireplace_nth, "1AbC3abc2", "aBc" C_ 0 C_ "YYY", string("1YYY3abc2") ); + TEST_ALGO( ireplace_nth, "1AbC3abc2", "aBc" C_ -1 C_ "YYY", string("1AbC3YYY2") ); + TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 0 C_ string("Z"), string("1Z3abc2") ); + TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 0 C_ string("XXXX"), string("1XXXX3abc2") ); + TEST_ALGO( replace_nth, "1abc3abc2", "abc" C_ 0 C_ "XXXX", string("1XXXX3abc2") ); + TEST_ALGO( replace_nth, "1abc3abc2", "abc" C_ 3 C_ "XXXX", string("1abc3abc2") ); + TEST_ALGO( replace_nth, "1abc3abc2", "abc" C_ -3 C_ "XXXX", string("1abc3abc2") ); + TEST_ALGO( replace_nth, "1abc3abc2", string("") C_ 0 C_ string("XXXX"), string("1abc3abc2") ); + TEST_ALGO( replace_nth, "", string("") C_ 0 C_ string("XXXX"), string("") ); + TEST_ALGO( replace_nth, "", string("") C_ -1 C_ string("XXXX"), string("") ); + TEST_ALGO( erase_nth, "1abc3abc2", string("abc") C_ 0, string("13abc2") ); + TEST_ALGO( erase_nth, "1abc3abc2", string("abc") C_ -1, string("1abc32") ); + TEST_ALGO( erase_nth, "1abc3abc2", string("abc") C_ -3, string("1abc3abc2") ); + TEST_ALGO( ierase_nth, "1aBc3aBc2", "ABC" C_ 0, string("13aBc2") ); + TEST_ALGO( ierase_nth, "1aBc3aBc2", "ABC" C_ -1, string("1aBc32") ); + TEST_ALGO( ierase_nth, "1aBc3aBc2", "ABC" C_ -3, string("1aBc3aBc2") ); + TEST_ALGO( erase_nth, "1abc3abc2", "abc" C_ 0, string("13abc2") ); + TEST_ALGO( erase_nth, "1abc3abc2", string("") C_ 0, string("1abc3abc2") ); + TEST_ALGO( erase_nth, "", string("abc") C_ 0, string("") ); + TEST_ALGO( erase_nth, "", string("abc") C_ -1, string("") ); + TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 1 C_ string("YYY"), string("1abc3YYY2") ); + TEST_ALGO( replace_nth, "1abc3abc2", string("abc") C_ 2 C_ string("YYY"), string("1abc3abc2") ); +} + +void replace_head_test() +{ + // replace head + TEST_ALGO( replace_head, "abc3abc2", 3 C_ string("YYY"), string("YYY3abc2") ); + TEST_ALGO( replace_head, "abc3abc2", -3 C_ string("YYY"), string("YYYbc2") ); + TEST_ALGO( replace_head, "abc3abc2", 3 C_ "YYY", string("YYY3abc2") ); + TEST_ALGO( replace_head, "abc", 3 C_ string("Z"), string("Z") ); + TEST_ALGO( replace_head, "abc", 6 C_ string("XXXX"), string("XXXX") ); + TEST_ALGO( replace_head, "abc", -6 C_ string("XXXX"), string("abc") ); + TEST_ALGO( replace_head, "abc3abc2", 0 C_ string("XXXX"), string("abc3abc2") ); + TEST_ALGO( replace_head, "", 4 C_ string("XXXX"), string("") ); + TEST_ALGO( replace_head, "", -4 C_ string("XXXX"), string("") ); + TEST_ALGO( erase_head, "abc3abc2", 3, string("3abc2") ); + TEST_ALGO( erase_head, "abc3abc2", -3, string("bc2") ); + TEST_ALGO( erase_head, "abc3abc2", 0, string("abc3abc2") ); + TEST_ALGO( erase_head, "", 4, string("") ); + TEST_ALGO( erase_head, "", -4, string("") ); +} + +void replace_tail_test() +{ + // replace tail + TEST_ALGO( replace_tail, "abc3abc", 3 C_ string("YYY"), string("abc3YYY") ); + TEST_ALGO( replace_tail, "abc3abc", -3 C_ "YYY", string("abcYYY") ); + TEST_ALGO( replace_tail, "abc", 3 C_ string("Z"), string("Z") ); + TEST_ALGO( replace_tail, "abc", 6 C_ string("XXXX"), string("XXXX") ); + TEST_ALGO( replace_tail, "abc", -6 C_ string("XXXX"), string("abc") ); + TEST_ALGO( replace_tail, "abc3abc", 0 C_ string("XXXX"), string("abc3abc") ); + TEST_ALGO( replace_tail, "", 4 C_ string("XXXX"), string("") ); + TEST_ALGO( replace_tail, "", -4 C_ string("XXXX"), string("") ); + TEST_ALGO( erase_tail, "abc3abc", 3, string("abc3") ); + TEST_ALGO( erase_tail, "abc3abc", -3, string("abc") ); + TEST_ALGO( erase_tail, "abc3abc", 0, string("abc3abc") ); + TEST_ALGO( erase_tail, "", 4, string("") ); + TEST_ALGO( erase_tail, "", -4, string("") ); +} + +void replace_range_test() +{ + // replace_range + { + BOOST_TEST_CHECKPOINT( "replace_range" ); + + string str1("1abc3abc2"); + BOOST_CHECK( + replace_range_copy( + str1, + make_iterator_range(str1.begin()+1, str1.begin()+4), + string("XXX") )==string("1XXX3abc2") ); + + string strout; + replace_range_copy( + back_inserter( strout ), + str1, + make_iterator_range(str1.begin()+1, str1.begin()+4), + string("XXX") ); + BOOST_CHECK( strout==string("1XXX3abc2") ); + + replace_range( + str1, + make_iterator_range(str1.begin()+1, str1.begin()+4), + string("XXX") ); + BOOST_CHECK( str1==string("1XXX3abc2") ); + } + // erase_range + { + BOOST_TEST_CHECKPOINT( "erase_range" ); + + string str1("1abc3abc2"); + BOOST_CHECK( + erase_range_copy( + str1, + make_iterator_range(str1.begin()+1, str1.begin()+4))==string("13abc2") ); + + string strout; + erase_range_copy( + back_inserter( strout ), + str1, + make_iterator_range(str1.begin()+1, str1.begin()+4)); + BOOST_CHECK( strout==string("13abc2") ); + + erase_range( + str1, + make_iterator_range(str1.begin()+1, str1.begin()+4)); + BOOST_CHECK( str1==string("13abc2") ); + } +} + +void collection_comp_test() +{ + // container traits compatibility tests + { + string strout; + replace_first_copy( back_inserter(strout), "1abc3abc2", "abc", "YYY" ); + BOOST_CHECK( strout==string("1YYY3abc2") ); + } + { + string strout; + replace_last_copy( back_inserter(strout), "1abc3abc2", "abc", "YYY" ); + BOOST_CHECK( strout==string("1abc3YYY2") ); + } + { + string strout; + replace_all_copy( back_inserter(strout), "1abc3abc2", "abc", "YYY" ); + BOOST_CHECK( strout==string("1YYY3YYY2") ); + } + { + string strout; + replace_nth_copy( back_inserter(strout), "1abc3abc2", "abc", 1, "YYY" ); + BOOST_CHECK( strout==string("1abc3YYY2") ); + } + { + string strout; + replace_head_copy( back_inserter(strout), "abc3abc2", 3 , "YYY" ); + BOOST_CHECK( strout==string("YYY3abc2") ); + } + { + string strout; + replace_tail_copy( back_inserter(strout), "abc3abc", 3 , "YYY" ); + BOOST_CHECK( strout==string("abc3YYY") ); + } +} + +void dissect_format_test() +{ + BOOST_CHECK( + find_format_all_copy( + string("aBc123Abc"), + first_finder("abc", is_iequal()), + dissect_formatter(token_finder(is_upper())))=="B123A"); + + + BOOST_CHECK( + find_format_all_copy( + string("abc 123 abc"), + token_finder(is_space(), token_compress_on), + dissect_formatter(head_finder(1)))=="abc 123 abc"); + +} + +BOOST_AUTO_TEST_CASE( test_main ) +{ + sequence_traits_test(); + replace_first_test(); + replace_last_test(); + replace_all_test(); + replace_nth_test(); + replace_head_test(); + replace_tail_test(); + replace_range_test(); + collection_comp_test(); + dissect_format_test(); +} diff --git a/src/boost/libs/algorithm/string/test/split_test.cpp b/src/boost/libs/algorithm/string/test/split_test.cpp new file mode 100644 index 000000000..3dbcfac22 --- /dev/null +++ b/src/boost/libs/algorithm/string/test/split_test.cpp @@ -0,0 +1,232 @@ +// 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/config.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> + +// 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 ); + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + // If using a compiler that supports forwarding references, we should be able to use rvalues, too + find_all( + tokens, + string("xx-abc--xx-abb"), + "xx" ); + + BOOST_REQUIRE( tokens.size()==2 ); + BOOST_CHECK( tokens[0]==string("xx") ); + BOOST_CHECK( tokens[1]==string("xx") ); + + ifind_all( + tokens, + string("Xx-abc--xX-abb-xx"), + "xx" ); + + BOOST_REQUIRE( tokens.size()==3 ); + BOOST_CHECK( tokens[0]==string("Xx") ); + BOOST_CHECK( tokens[1]==string("xX") ); + BOOST_CHECK( tokens[2]==string("xx") ); +#endif + + // 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("") ); + +#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) + // If using a compiler that supports forwarding references, we should be able to use rvalues, too + split( + tokens, + string("Xx-abc--xX-abb-xx"), + 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("") ); +#endif + + + find_iterator<string::iterator> fiter=make_find_iterator(str1, first_finder("xx")); + find_iterator<string::iterator> fiter2; + + BOOST_CHECK(equals(*fiter, "xx")); + ++fiter; + + fiter2 = fiter; + BOOST_CHECK(equals(*fiter, "xx")); + BOOST_CHECK(equals(*fiter2, "xx")); + + ++fiter; + BOOST_CHECK(fiter==find_iterator<string::iterator>()); + BOOST_CHECK(equals(*fiter2, "xx")); + + ++fiter2; + BOOST_CHECK(fiter2==find_iterator<string::iterator>()); + + split_iterator<string::iterator> siter=make_split_iterator(str1, token_finder(is_any_of("-"), token_compress_on)); + split_iterator<string::iterator> siter2; + BOOST_CHECK(equals(*siter, "xx")); + ++siter; + + siter2 = siter; + BOOST_CHECK(equals(*siter, "abc")); + BOOST_CHECK(equals(*siter2, "abc")); + + ++siter; + BOOST_CHECK(equals(*siter, "xx")); + BOOST_CHECK(equals(*siter2, "abc")); + + ++siter; + BOOST_CHECK(equals(*siter, "abb")); + ++siter; + BOOST_CHECK(siter==split_iterator<string::iterator>(siter)); + BOOST_CHECK(siter==split_iterator<string::iterator>()); + +// Make sure we work with forward iterators +// See bug #7989 + list<char> l1; + find_iterator<list<char>::iterator> liter=make_find_iterator(l1, first_finder("xx")); +} + +BOOST_AUTO_TEST_CASE( test_main ) +{ + iterator_test(); +} diff --git a/src/boost/libs/algorithm/string/test/trim_test.cpp b/src/boost/libs/algorithm/string/test/trim_test.cpp new file mode 100644 index 000000000..b254caaa4 --- /dev/null +++ b/src/boost/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(); +} |