summaryrefslogtreecommitdiffstats
path: root/src/boost/libs/utility/test/string_ref_test2.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/boost/libs/utility/test/string_ref_test2.cpp')
-rw-r--r--src/boost/libs/utility/test/string_ref_test2.cpp323
1 files changed, 323 insertions, 0 deletions
diff --git a/src/boost/libs/utility/test/string_ref_test2.cpp b/src/boost/libs/utility/test/string_ref_test2.cpp
new file mode 100644
index 00000000..d7337751
--- /dev/null
+++ b/src/boost/libs/utility/test/string_ref_test2.cpp
@@ -0,0 +1,323 @@
+/*
+ Copyright (c) Marshall Clow 2012-2012.
+
+ 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)
+
+ For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+#include <cstring> // for std::strchr
+
+#include <boost/utility/string_ref.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+
+typedef boost::string_ref string_ref;
+
+void ends_with ( const char *arg ) {
+ const size_t sz = std::strlen ( arg );
+ string_ref sr ( arg );
+ string_ref sr2 ( arg );
+ const char *p = arg;
+
+ while ( *p ) {
+ BOOST_TEST ( sr.ends_with ( p ));
+ ++p;
+ }
+
+ while ( !sr2.empty ()) {
+ BOOST_TEST ( sr.ends_with ( sr2 ));
+ sr2.remove_prefix (1);
+ }
+
+ sr2 = arg;
+ while ( !sr2.empty ()) {
+ BOOST_TEST ( sr.ends_with ( sr2 ));
+ sr2.remove_prefix (1);
+ }
+
+ char ch = sz == 0 ? '\0' : arg [ sz - 1 ];
+ sr2 = arg;
+ if ( sz > 0 )
+ BOOST_TEST ( sr2.ends_with ( ch ));
+ BOOST_TEST ( !sr2.ends_with ( ++ch ));
+ BOOST_TEST ( sr2.ends_with ( string_ref ()));
+ }
+
+void starts_with ( const char *arg ) {
+ const size_t sz = std::strlen ( arg );
+ string_ref sr ( arg );
+ string_ref sr2 ( arg );
+ const char *p = arg + std::strlen ( arg ) - 1;
+ while ( p >= arg ) {
+ std::string foo ( arg, p + 1 );
+ BOOST_TEST ( sr.starts_with ( foo ));
+ --p;
+ }
+
+ while ( !sr2.empty ()) {
+ BOOST_TEST ( sr.starts_with ( sr2 ));
+ sr2.remove_suffix (1);
+ }
+
+ char ch = *arg;
+ sr2 = arg;
+ if ( sz > 0 )
+ BOOST_TEST ( sr2.starts_with ( ch ));
+ BOOST_TEST ( !sr2.starts_with ( ++ch ));
+ BOOST_TEST ( sr2.starts_with ( string_ref ()));
+ }
+
+void reverse ( const char *arg ) {
+// Round trip
+ string_ref sr1 ( arg );
+ std::string string1 ( sr1.rbegin (), sr1.rend ());
+ string_ref sr2 ( string1 );
+ std::string string2 ( sr2.rbegin (), sr2.rend ());
+
+ BOOST_TEST ( std::equal ( sr2.rbegin (), sr2.rend (), arg ));
+ BOOST_TEST ( string2 == arg );
+ BOOST_TEST ( std::equal ( sr1.begin (), sr1.end (), string2.begin ()));
+ }
+
+// This helper function eliminates signed vs. unsigned warnings
+string_ref::size_type ptr_diff ( const char *res, const char *base ) {
+ BOOST_TEST ( res >= base );
+ return static_cast<string_ref::size_type> ( res - base );
+ }
+
+void find ( const char *arg ) {
+ string_ref sr1;
+ string_ref sr2;
+ const char *p;
+
+// When we search for the empty string, we find it at position 0
+ BOOST_TEST ( sr1.find (sr2) == 0 );
+ BOOST_TEST ( sr1.rfind(sr2) == 0 );
+
+// Look for each character in the string(searching from the start)
+ p = arg;
+ sr1 = arg;
+ while ( *p ) {
+ string_ref::size_type pos = sr1.find(*p);
+ BOOST_TEST ( pos != string_ref::npos && ( pos <= ptr_diff ( p, arg )));
+ ++p;
+ }
+
+// Look for each character in the string (searching from the end)
+ p = arg;
+ sr1 = arg;
+ while ( *p ) {
+ string_ref::size_type pos = sr1.rfind(*p);
+ BOOST_TEST ( pos != string_ref::npos && pos < sr1.size () && ( pos >= ptr_diff ( p, arg )));
+ ++p;
+ }
+
+// Look for pairs on characters (searching from the start)
+ sr1 = arg;
+ p = arg;
+ while ( *p && *(p+1)) {
+ string_ref sr3 ( p, 2 );
+ string_ref::size_type pos = sr1.find ( sr3 );
+ BOOST_TEST ( pos != string_ref::npos && pos <= static_cast<string_ref::size_type>( p - arg ));
+ p++;
+ }
+
+ sr1 = arg;
+ p = arg;
+// for all possible chars, see if we find them in the right place.
+// Note that strchr will/might do the _wrong_ thing if we search for NULL
+ for ( int ch = 1; ch < 256; ++ch ) {
+ string_ref::size_type pos = sr1.find(ch);
+ const char *strp = std::strchr ( arg, ch );
+ BOOST_TEST (( strp == NULL ) == ( pos == string_ref::npos ));
+ if ( strp != NULL )
+ BOOST_TEST ( ptr_diff ( strp, arg ) == pos );
+ }
+
+ sr1 = arg;
+ p = arg;
+// for all possible chars, see if we find them in the right place.
+// Note that strchr will/might do the _wrong_ thing if we search for NULL
+ for ( int ch = 1; ch < 256; ++ch ) {
+ string_ref::size_type pos = sr1.rfind(ch);
+ const char *strp = std::strrchr ( arg, ch );
+ BOOST_TEST (( strp == NULL ) == ( pos == string_ref::npos ));
+ if ( strp != NULL )
+ BOOST_TEST ( ptr_diff ( strp, arg ) == pos );
+ }
+
+
+// Find everything at the start
+ p = arg;
+ sr1 = arg;
+ while ( !sr1.empty ()) {
+ string_ref::size_type pos = sr1.find(*p);
+ BOOST_TEST ( pos == 0 );
+ sr1.remove_prefix (1);
+ ++p;
+ }
+
+// Find everything at the end
+ sr1 = arg;
+ p = arg + std::strlen ( arg ) - 1;
+ while ( !sr1.empty ()) {
+ string_ref::size_type pos = sr1.rfind(*p);
+ BOOST_TEST ( pos == sr1.size () - 1 );
+ sr1.remove_suffix (1);
+ --p;
+ }
+
+// Find everything at the start
+ sr1 = arg;
+ p = arg;
+ while ( !sr1.empty ()) {
+ string_ref::size_type pos = sr1.find_first_of(*p);
+ BOOST_TEST ( pos == 0 );
+ sr1.remove_prefix (1);
+ ++p;
+ }
+
+
+// Find everything at the end
+ sr1 = arg;
+ p = arg + std::strlen ( arg ) - 1;
+ while ( !sr1.empty ()) {
+ string_ref::size_type pos = sr1.find_last_of(*p);
+ BOOST_TEST ( pos == sr1.size () - 1 );
+ sr1.remove_suffix (1);
+ --p;
+ }
+
+// Basic sanity checking for "find_first_of / find_first_not_of"
+ sr1 = arg;
+ sr2 = arg;
+ while ( !sr1.empty() ) {
+ BOOST_TEST ( sr1.find_first_of ( sr2 ) == 0 );
+ BOOST_TEST ( sr1.find_first_not_of ( sr2 ) == string_ref::npos );
+ sr1.remove_prefix ( 1 );
+ }
+
+ p = arg;
+ sr1 = arg;
+ while ( *p ) {
+ string_ref::size_type pos1 = sr1.find_first_of(*p);
+ string_ref::size_type pos2 = sr1.find_first_not_of(*p);
+ BOOST_TEST ( pos1 != string_ref::npos && pos1 < sr1.size () && pos1 <= ptr_diff ( p, arg ));
+ if ( pos2 != string_ref::npos ) {
+ for ( size_t i = 0 ; i < pos2; ++i )
+ BOOST_TEST ( sr1[i] == *p );
+ BOOST_TEST ( sr1 [ pos2 ] != *p );
+ }
+
+ BOOST_TEST ( pos2 != pos1 );
+ ++p;
+ }
+
+// Basic sanity checking for "find_last_of / find_last_not_of"
+ sr1 = arg;
+ sr2 = arg;
+ while ( !sr1.empty() ) {
+ BOOST_TEST ( sr1.find_last_of ( sr2 ) == ( sr1.size () - 1 ));
+ BOOST_TEST ( sr1.find_last_not_of ( sr2 ) == string_ref::npos );
+ sr1.remove_suffix ( 1 );
+ }
+
+ p = arg;
+ sr1 = arg;
+ while ( *p ) {
+ string_ref::size_type pos1 = sr1.find_last_of(*p);
+ string_ref::size_type pos2 = sr1.find_last_not_of(*p);
+ BOOST_TEST ( pos1 != string_ref::npos && pos1 < sr1.size () && pos1 >= ptr_diff ( p, arg ));
+ BOOST_TEST ( pos2 == string_ref::npos || pos1 < sr1.size ());
+ if ( pos2 != string_ref::npos ) {
+ for ( size_t i = sr1.size () -1 ; i > pos2; --i )
+ BOOST_TEST ( sr1[i] == *p );
+ BOOST_TEST ( sr1 [ pos2 ] != *p );
+ }
+
+ BOOST_TEST ( pos2 != pos1 );
+ ++p;
+ }
+
+ }
+
+
+void to_string ( const char *arg ) {
+ string_ref sr1;
+ std::string str1;
+ std::string str2;
+
+ str1.assign ( arg );
+ sr1 = arg;
+// str2 = sr1.to_string<std::allocator<char> > ();
+ str2 = sr1.to_string ();
+ BOOST_TEST ( str1 == str2 );
+
+#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+ std::string str3 = static_cast<std::string> ( sr1 );
+ BOOST_TEST ( str1 == str3 );
+#endif
+ }
+
+void compare ( const char *arg ) {
+ string_ref sr1;
+ std::string str1;
+ std::string str2 = str1;
+
+ str1.assign ( arg );
+ sr1 = arg;
+ BOOST_TEST ( sr1 == sr1); // compare string_ref and string_ref
+ BOOST_TEST ( sr1 == str1); // compare string and string_ref
+ BOOST_TEST ( str1 == sr1 ); // compare string_ref and string
+ BOOST_TEST ( sr1 == arg ); // compare string_ref and pointer
+ BOOST_TEST ( arg == sr1 ); // compare pointer and string_ref
+
+ if ( sr1.size () > 0 ) {
+ (*str1.rbegin())++;
+ BOOST_TEST ( sr1 != str1 );
+ BOOST_TEST ( str1 != sr1 );
+ BOOST_TEST ( sr1 < str1 );
+ BOOST_TEST ( sr1 <= str1 );
+ BOOST_TEST ( str1 > sr1 );
+ BOOST_TEST ( str1 >= sr1 );
+
+ (*str1.rbegin()) -= 2;
+ BOOST_TEST ( sr1 != str1 );
+ BOOST_TEST ( str1 != sr1 );
+ BOOST_TEST ( sr1 > str1 );
+ BOOST_TEST ( sr1 >= str1 );
+ BOOST_TEST ( str1 < sr1 );
+ BOOST_TEST ( str1 <= sr1 );
+ }
+ }
+
+const char *test_strings [] = {
+ "",
+ "0",
+ "abc",
+ "AAA", // all the same
+ "adsfadadiaef;alkdg;aljt;j agl;sjrl;tjs;lga;lretj;srg[w349u5209dsfadfasdfasdfadsf",
+ "abc\0asdfadsfasf",
+ NULL
+ };
+
+int main()
+{
+ const char **p = &test_strings[0];
+
+ while ( *p != NULL ) {
+ starts_with ( *p );
+ ends_with ( *p );
+ reverse ( *p );
+ find ( *p );
+ to_string ( *p );
+ compare ( *p );
+
+ p++;
+ }
+
+ return boost::report_errors();
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-22 12:29:12 +0000