Menu
▾
▴
[Loki-lib-cvs] SF.net SVN: loki-lib:[1002] trunk/test/flex_string/main.cpp
|
From: <jfb...@us...> - 2009-03-10 18:36:55
|
Revision: 1002
http://loki-lib.svn.sourceforge.net/loki-lib/?rev=1002&view=rev
Author: jfbastien
Date: 2009-03-10 18:36:42 +0000 (Tue, 10 Mar 2009)
Log Message:
-----------
Refactor some more, and add a bunch of tests. These new tests led me to find bug #2679853.
Modified Paths:
--------------
trunk/test/flex_string/main.cpp
Modified: trunk/test/flex_string/main.cpp
===================================================================
--- trunk/test/flex_string/main.cpp 2009-03-05 22:04:56 UTC (rev 1001)
+++ trunk/test/flex_string/main.cpp 2009-03-10 18:36:42 UTC (rev 1002)
@@ -133,19 +133,73 @@
return result;
}
-// Specialize this method for different String types.
+// Specialize these method for different String types.
template<class String>
-String Npos()
+typename String::value_type NullTerminator()
{
+ return '\0';
+}
+
+template<class String>
+String LengthErrorExceptionString()
+{
+ return "length_error exception thrown";
+}
+
+template<class String>
+String OutOfRangeExceptionString()
+{
+ return "out_of_range exception thrown";
+}
+
+template<class String>
+String UnknownExceptionString()
+{
+ return "Unknown exception thrown";
+}
+
+template<class String>
+String NposString()
+{
return "{npos}";
}
+template<class String>
+String OpenCurlyString()
+{
+ return "{";
+}
+
+template<class String>
+String CloseCurlyString()
+{
+ return "}";
+}
+
+template<class String>
+String SeparatorString()
+{
+ return "--";
+}
+
+template<class String>
+String TrueString()
+{
+ return "{true}";
+}
+
+template<class String>
+String FalseString()
+{
+ return "{false}";
+}
+
template<class String, class Integral>
String Num2String(Integral value)
{
typedef typename String::value_type CharType;
std::basic_ostringstream<CharType, std::char_traits<CharType>, std::allocator<CharType> > stream;
- stream << value;
+ stream << OpenCurlyString<String>() << value << CloseCurlyString<String>();
return stream.str().c_str();
}
@@ -156,17 +210,23 @@
{
typedef typename String::value_type CharType;
std::basic_ostringstream<CharType, std::char_traits<CharType>, std::allocator<CharType> > stream;
- stream << value;
+ stream << OpenCurlyString<String>() << value << CloseCurlyString<String>();
return stream.str().c_str();
}
else
{
// Not all strings will have the same value for npos.
// Since methods like find return npos on failure we want to represent npos in an implementation-independent manner.
- return Npos<String>();
+ return NposString<String>();
}
}
+template<class String>
+String Num2String(bool value)
+{
+ return value ? TrueString<String>() : FalseString<String>();
+}
+
// Some comparison functions return 0 or a value greater/smaller than zero.
// This function makes the greater/smaller than zero specification implementation-independent.
template<class String>
@@ -184,13 +244,13 @@
std::list<typename String::value_type> RandomList(typename String::size_type maxSize)
{
const typename String::size_type size = random(0, maxSize);
- std::list<typename String::value_type> lst(size);
- std::list<typename String::value_type>::iterator i = lst.begin();
- for (; i != lst.end(); ++i)
+ std::list<typename String::value_type> list(size);
+ std::list<typename String::value_type>::iterator i = list.begin();
+ for (; i != list.end(); ++i)
{
*i = random('a', 'z');
}
- return lst;
+ return list;
}
namespace Tests
@@ -201,1274 +261,2424 @@
static const typename String::size_type value = 1050;
};
+ template<class String>
+ String operator_plus_string_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = random1 + random2;
+ return result;
+ }
template<class String>
- String default_constructor(String &)
+ String operator_plus_cstr_string()
{
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = random1.c_str() + random2;
+ return result;
+ }
+
+ template<class String>
+ String operator_plus_char_string()
+ {
+ // 21.3
+ const typename String::value_type value = random('a', 'z');
+ String random1(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = value + random1;
+ return result;
+ }
+
+ template<class String>
+ String operator_plus_string_cstr()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = random1 + random2.c_str();
+ return result;
+ }
+
+ template<class String>
+ String operator_plus_string_char()
+ {
+ // 21.3
+ const typename String::value_type value = random('a', 'z');
+ String random1(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = random1 + value;
+ return result;
+ }
+
+ template<class String>
+ String operator_equal_equal_string_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 == random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_equal_equal_cstr_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1.c_str() == random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_equal_equal_string_cstr()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 == random2.c_str());
+ return result;
+ }
+
+ template<class String>
+ String operator_not_equal_string_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 != random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_not_equal_cstr_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1.c_str() != random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_not_equal_string_cstr()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 != random2.c_str());
+ return result;
+ }
+
+ template<class String>
+ String operator_smaller_string_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 < random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_smaller_cstr_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1.c_str() < random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_smaller_string_cstr()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 < random2.c_str());
+ return result;
+ }
+
+ template<class String>
+ String operator_greater_string_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 > random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_greater_cstr_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1.c_str() > random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_greater_string_cstr()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 > random2.c_str());
+ return result;
+ }
+
+ template<class String>
+ String operator_smaller_equal_string_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 <= random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_smaller_equal_cstr_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1.c_str() <= random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_smaller_equal_string_cstr()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 <= random2.c_str());
+ return result;
+ }
+
+ template<class String>
+ String operator_greater_equal_string_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 >= random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_greater_equal_cstr_string()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1.c_str() >= random2);
+ return result;
+ }
+
+ template<class String>
+ String operator_greater_equal_string_cstr()
+ {
+ // 21.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ result = Num2String<String>(random1 >= random2.c_str());
+ return result;
+ }
+
+ template<class String>
+ String swap_string_string()
+ {
+ using std::swap;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ swap(random1, random2);
+ return random1 + SeparatorString<String>() + random2;
+ }
+
+ template<class String>
+ String swap_string_string__self()
+ {
+ using std::swap;
+ String random1(RandomString<String>(MaxString<String>::value));
+ swap(random1, random1);
+ return random1;
+ }
+
+ template<class String>
+ String swap_string_string__selfcopy()
+ {
+ using std::swap;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ swap(random1, copy);
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String swap_string_string__selfcopy2()
+ {
+ using std::swap;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ swap(copy, random1);
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ // TODO: operator>>(istream, string)
+ // TODO: operator<<(ostream, string)
+ // TODO: getline(istream, string, char delimiter)
+ // TODO: getline(istream, string)
+
+ template<class String>
+ String constructor()
+ {
// 21.3.1
return String();
}
template<class String>
- String copy_constructor(String & test)
+ String constructor_string()
{
// 21.3.1
- String s(test);
- return s;
+ String random1(RandomString<String>(MaxString<String>::value));
+ return random1;
}
template<class String>
- String copy_constructor_with_size_and_range(String & test)
+ String constructor_string_position_number()
{
// 21.3.1
- const typename String::size_type pos = random(0, test.size());
- const typename String::size_type length = random(0, test.size() - pos);
- String s(test, pos, length);
- return s;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, random1.size() - position);
+ String result(random1, position, number);
+ return result;
}
template<class String>
- String constructor_with_cstr_and_size(String & test)
+ String constructor_string_position_number__bigNumber()
{
// 21.3.1
- const typename String::size_type pos = random(0, test.size());
- const typename String::size_type n = random(0, test.size() - pos);
- String s(test.c_str() + pos, n);
- return s;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, String::npos);
+ String result(random1, position, number);
+ return result;
}
template<class String>
- String constructor_with_cstr(String & test)
+ String constructor_cstr_number()
{
// 21.3.1
- const typename String::size_type pos = random(0, test.size());
- String s(test.c_str() + pos);
- return s;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, random1.size());
+ String result(random1.c_str(), number);
+ return result;
}
template<class String>
- String assignment(String & test)
+ String constructor_number_char()
{
// 21.3.1
- const typename String::size_type size = random(0, MaxString<String>::value);
- String s(size, '\0');
- typename String::size_type i = 0;
- for (; i != s.size(); ++i)
- {
- s[i] = random('a', 'z');
- }
- test = s;
- return test;
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ const typename String::size_type value = random('a', 'z');
+ String result(number, value);
+ return result;
}
template<class String>
- String assignment_with_cstr(String & test)
+ String constructor_iterator_iterator()
{
+ // 21.3.5
+ std::list<typename String::value_type> list(RandomList<String>(MaxString<String>::value));
+ String result(list.begin(), list.end());
+ return result;
+ }
+
+ // TODO: destructor
+
+ template<class String>
+ String operator_equal_string()
+ {
// 21.3.1
- const typename String::size_type size = random(0, MaxString<String>::value);
- String s(size, '\0');
- typename String::size_type i = 0;
- for (; i != s.size(); ++i)
- {
- s[i] = random('a', 'z');
- }
- test = s.c_str();
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ random1 = random2;
+ return random1 + SeparatorString<String>() + random2;
}
template<class String>
- String assignment_aliased(String & test)
+ String operator_equal_string__self()
{
// 21.3.1
- const size_t pos = random(0, test.size());
- test = test.c_str() + pos;
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1 = random1;
+ return random1;
}
template<class String>
- String assignment_non_aliased(String & test)
+ String operator_equal_string__selfCopy()
{
// 21.3.1
- const size_t pos = random(0, test.size());
- test = String(test.c_str() + pos);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(random1);
+ random1 = random2;
+ return random1 + SeparatorString<String>() + random2;
}
template<class String>
- String assignment_from_char(String & test)
+ String operator_equal_cstr()
{
// 21.3.1
- test = random('a', 'z');
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ random1 = random2.c_str();
+ return random1 + SeparatorString<String>() + random2;
}
template<class String>
- String iterators_call(String & test)
+ String operator_equal_cstr__self()
{
+ // 21.3.1
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1 = random1.c_str();
+ return random1;
+ }
+
+ template<class String>
+ String operator_equal_cstr__selfCopy()
+ {
+ // 21.3.1
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(random1);
+ random1 = random2.c_str();
+ return random1 + SeparatorString<String>() + random2;
+ }
+
+ template<class String>
+ String iterators()
+ {
// 21.3.2
+ String random1(RandomString<String>(MaxString<String>::value));
+ const String random2(RandomString<String>(MaxString<String>::value));
String result;
- result += Num2String<String>(test.end() - test.begin()) + " -- ";
- result += Num2String<String>(test.rend() - test.rbegin()) + " -- ";
+ result += Num2String<String>(random1.end() - random1.begin())
+ + Num2String<String>(random1.rend() - random1.rbegin())
+ + Num2String<String>(random2.end() - random2.begin())
+ + Num2String<String>(random2.rend() - random2.rbegin())
+ + Num2String<String>(random1.end() == random1.begin())
+ + Num2String<String>(random1.rend() == random1.rbegin())
+ + Num2String<String>(random2.end() == random2.begin())
+ + Num2String<String>(random2.rend() == random2.rbegin())
+ + Num2String<String>(random1.end() != random1.begin())
+ + Num2String<String>(random1.rend() != random1.rbegin())
+ + Num2String<String>(random2.end() != random2.begin())
+ + Num2String<String>(random2.rend() != random2.rbegin());
return result;
}
template<class String>
- String iterators_equality(String & test)
+ String capacity()
{
- // 21.3.2
+ // 21.3.3
+ String random1(RandomString<String>(MaxString<String>::value));
String result;
- result += Num2String<String>(test.size()) + " -- ";
- if(0 != test.size())
+ result += Num2String<String>(random1.size())
+ + Num2String<String>(random1.length())
+ + Num2String<String>(random1.size() == random1.length())
+ + Num2String<String>(random1.capacity() >= random1.size())
+ + Num2String<String>(random1.max_size() >= random1.size())
+ + Num2String<String>(random1.max_size() >= random1.capacity());
+ return result;
+ }
+
+ template<class String>
+ String resize_number_char()
+ {
+ // 21.3.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ const typename String::value_type value = random('a', 'z');
+ random1.resize(number, value);
+ return random1;
+ }
+
+ template<class String>
+ String resize_number()
+ {
+ // 21.3.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.resize(number);
+ return random1;
+ }
+
+ template<class String>
+ String reserve_number()
+ {
+ // 21.3.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.reserve(number);
+ random1 += Num2String<String>(random1.capacity() >= number);
+ return random1;
+ }
+
+ template<class String>
+ String clear()
+ {
+ // 21.3.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1.clear();
+ return random1;
+ }
+
+ template<class String>
+ String empty()
+ {
+ // 21.3.3
+ String random1(RandomString<String>(MaxString<String>::value));
+ return Num2String<String>(random1.empty());
+ }
+
+ template<class String>
+ String element_access()
+ {
+ // 21.3.4
+ String random1(RandomString<String>(MaxString<String>::value));
+ const String random2(RandomString<String>(MaxString<String>::value));
+ String result;
+ if(!random1.empty())
{
- result += Num2String<String>(test.begin() != test.end()) + " -- ";
- result += Num2String<String>(test.rbegin() != test.rend()) + " -- ";
+ {
+ const typename String::size_type index = random(0, random1.size() - 1);
+ result += random1[index] + SeparatorString<String>();
+ }
+ {
+ const typename String::size_type index = random(0, random1.size() - 1);
+ result += random1.at(index) + SeparatorString<String>();
+ }
}
- else
+ if(!random2.empty())
{
- result += Num2String<String>(test.begin() == test.end()) + " -- ";
- result += Num2String<String>(test.rbegin() == test.rend()) + " -- ";
+ {
+ const typename String::size_type index = random(0, random2.size() - 1);
+ result += random2[index] + SeparatorString<String>();
+ }
+ {
+ const typename String::size_type index = random(0, random2.size() - 1);
+ result += random2.at(index) + SeparatorString<String>();
+ }
}
return result;
}
template<class String>
- String capacity(String & test)
+ String operator_plus_equal_string()
{
- // 21.3.2
- String result;
- result += Num2String<String>(test.size()) + " -- ";
- result += Num2String<String>(test.length()) + " -- ";
- test.max_size();
- test.capacity();
- result += test;
- return result;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ random1 += random2;
+ return random1 + SeparatorString<String>() + random2;
}
template<class String>
- String capacity_values(String & test)
+ String operator_plus_equal_string__self()
{
- // 21.3.2
- String result;
- result += Num2String<String>(test.size() == test.length()) + " -- ";
- result += Num2String<String>(test.capacity() >= test.size()) + " -- ";
- result += Num2String<String>(test.max_size() >= test.size()) + " -- ";
- result += Num2String<String>(test.max_size() >= test.capacity()) + " -- ";
- return result;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1 += random1;
+ return random1;
}
template<class String>
- String resize(String & test)
+ String operator_plus_equal_string__selfcopy()
{
- const typename String::size_type newSize = random(0, test.size());
- const typename String::value_type value = random('a', 'z');
- test.resize(newSize, value);
- return test;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ random1 += copy;
+ return random1 + SeparatorString<String>() + copy;
}
template<class String>
- String resize_with_1_argument(String & test)
+ String operator_plus_equal_cstr()
{
- const typename String::size_type newSize = random(0, test.size());
- test.resize(newSize);
- return test;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ random1 += random2.c_str();
+ return random1 + SeparatorString<String>() + random2;
}
template<class String>
- String reserve(String & test)
+ String operator_plus_equal_cstr__self()
{
- const typename String::size_type reserveSize = random(0, MaxString<String>::value);
- test.reserve(reserveSize);
- return test;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1 += random1.c_str();
+ return random1;
}
template<class String>
- String clear(String & test)
+ String operator_plus_equal_cstr__selfcopy()
{
- test.clear();
- return test;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ random1 += copy.c_str();
+ return random1 + SeparatorString<String>() + copy;
}
template<class String>
- String empty1(String & test)
+ String operator_plus_equal_char()
{
- if (test.empty()) test = "empty";
- else test = "not empty";
- return test;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::value_type value = random('a', 'z');
+ random1 += value;
+ return random1;
}
template<class String>
- String empty2(String & test)
+ String append_string()
{
- const char* kEmptyString = "empty";
- const char* kNonEmptyString = "not empty";
- if (test.empty()) test = String(kEmptyString, kEmptyString + strlen(kEmptyString));
- else test = String(kNonEmptyString, kNonEmptyString + strlen(kNonEmptyString));
- return test;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ random1.append(random2);
+ return random1 + SeparatorString<String>() + random2;
}
template<class String>
- String element_access(String & test)
+ String append_string__self()
{
- // 21.3.4
- if(!test.empty())
- {
- const typename String::size_type index1 = random(0, test.size() - 1);
- test += test[index1];
- const typename String::size_type index2 = random(0, test.size() - 1);
- test += test.at(index2);
- }
- return test;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1.append(random1);
+ return random1;
}
template<class String>
- String operator_plus_equal(String & test)
+ String append_string__selfcopy()
{
- String str(RandomString<String>(MaxString<String>::value));
- test += str;
- return test;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ random1.append(copy);
+ return random1 + SeparatorString<String>() + copy;
}
template<class String>
- String operator_plus_equal_aliasing(String & test)
+ String append_string_position_number()
{
- test += test;
- return test;
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random2.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.append(random2, position, number);
+ return random1 + SeparatorString<String>() + random2;
}
template<class String>
- String operator_plus_equal_with_cstr(String & test)
+ String append_string_position_number__self()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- test += str.c_str();
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.append(random1, position, number);
+ return random1;
}
template<class String>
- String operator_plus_equal_no_aliasing(String & test)
+ String append_string_position_number__selfcopy()
{
// 21.3.5
- const typename String::size_type offset = random(0, test.size());
- test += String(test.c_str() + offset);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.append(copy, position, number);
+ return random1 + SeparatorString<String>() + copy;
}
template<class String>
- String operator_plus_equal_aliasing_cstr(String & test)
+ String append_cstr_number()
{
// 21.3.5
- const typename String::size_type offset = random(0, test.size());
- test += test.c_str() + offset;
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, random2.size());
+ random1.append(random2.c_str(), number);
+ return random1;
}
template<class String>
- String operator_plus_equal_char(String & test)
+ String append_cstr_number__self()
{
// 21.3.5
- test += random('a', 'z');
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, random1.size());
+ random1.append(random1.c_str(), number);
+ return random1;
}
template<class String>
- String append_string(String & test)
+ String append_cstr_number__selfcopy()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- test.append(str);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type number = random(0, random1.size());
+ random1.append(copy.c_str(), number);
+ return random1 + SeparatorString<String>() + copy;
}
template<class String>
- String append_string_start_range(String & test)
+ String append_cstr()
{
// 21.3.5
- String s(RandomString<String>(MaxString<String>::value));
- const typename String::size_type start = random(0, s.size());
- const typename String::size_type range = random(0, MaxString<String>::value);
- test.append(s, start, range);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ random1.append(random2.c_str());
+ return random1;
}
template<class String>
- String append_cstr_size(String & test)
+ String append_cstr__self()
{
// 21.3.5
- String s(RandomString<String>(MaxString<String>::value));
- const typename String::size_type size = random(0, s.size());
- test.append(s.c_str(), size);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1.append(random1.c_str());
+ return random1;
}
template<class String>
- String append_cstr(String & test)
+ String append_cstr__selfcopy()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- test.append(str.c_str());
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ random1.append(copy.c_str());
+ return random1 + SeparatorString<String>() + copy;
}
template<class String>
- String append_count_char(String & test)
+ String append_number_char()
{
// 21.3.5
- const typename String::size_type count = random(0, MaxString<String>::value);
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, MaxString<String>::value);
const typename String::value_type value = random('a', 'z');
- test.append(count, value);
- return test;
+ random1.append(number, value);
+ return random1;
}
template<class String>
- String append_iterators(String & test)
+ String append_iterator_iterator()
{
// 21.3.5
- std::list<typename String::value_type> lst(RandomList<String>(MaxString<String>::value));
- test.append(lst.begin(), lst.end());
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ std::list<typename String::value_type> list(RandomList<String>(MaxString<String>::value));
+ random1.append(list.begin(), list.end());
+ return random1;
}
template<class String>
- String push_back_char(String & test)
+ String append_iterator_iterator__self()
{
// 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1.append(random1.begin(), random1.end());
+ return random1;
+ }
+
+ template<class String>
+ String append_iterator_iterator__selfcopy()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ random1.append(copy.begin(), copy.end());
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String append_iterator_iterator__self_reverse()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1.append(random1.rbegin(), random1.rend());
+ return random1;
+ }
+
+ template<class String>
+ String append_iterator_iterator__selfcopy_reverse()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ random1.append(copy.rbegin(), copy.rend());
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String push_back_char()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
const typename String::value_type value = random('a', 'z');
- test.push_back(value);
- return test;
+ random1.push_back(value);
+ return random1;
}
template<class String>
- String assign_string(String & test)
+ String assign_string()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- test.assign(str);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ random1.assign(random2);
+ return random1 + SeparatorString<String>() + random2;
}
template<class String>
- String assign_string_start_size(String & test)
+ String assign_string__self()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- const typename String::size_type start = random(0, str.size());
- const typename String::size_type size = random(0, MaxString<String>::value);
- test.assign(str, start, size);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1.assign(random1);
+ return random1;
}
template<class String>
- String assign_cstr_size(String & test)
+ String assign_string__selfcopy()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- const typename String::size_type size = random(0, str.size());
- test.assign(str.c_str(), size);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ random1.assign(copy);
+ return random1 + SeparatorString<String>() + copy;
}
template<class String>
- String assign_cstr(String & test)
+ String assign_string_position_number()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- test.assign(str.c_str());
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random2.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.assign(random2, position, number);
+ return random1 + SeparatorString<String>() + random2;
}
template<class String>
- String assign_number_char(String & test)
+ String assign_string_position_number__self()
{
// 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.assign(random1, position, number);
+ return random1;
+ }
+
+ template<class String>
+ String assign_string_position_number__selfcopy()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const String copy(random1);
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.assign(copy, position, number);
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String assign_cstr_number()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, random2.size());
+ random1.assign(random2.c_str(), number);
+ return random1;
+ }
+
+ template<class String>
+ String assign_cstr_number__self()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, random1.size());
+ random1.assign(random1.c_str(), number);
+ return random1;
+ }
+
+ template<class String>
+ String assign_cstr_number__selfcopy()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const String copy(random1);
+ const typename String::size_type number = random(0, copy.size());
+ random1.assign(copy.c_str(), number);
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String assign_cstr()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const String random2(RandomString<String>(MaxString<String>::value));
+ random1.assign(random2.c_str());
+ return random1 + SeparatorString<String>() + random2;
+ }
+
+ template<class String>
+ String assign_cstr__self()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1.assign(random1.c_str());
+ return random1;
+ }
+
+ template<class String>
+ String assign_cstr__selfcopy()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const String copy(random1);
+ random1.assign(copy.c_str());
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String assign_number_char()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type number = random(0, MaxString<String>::value);
const typename String::value_type value = random('a', 'z');
- test.assign(number, value);
- return test;
+ random1.assign(number, value);
+ return random1;
}
template<class String>
- String assign_iterators(String & test)
+ String assign_iterator_iterator()
{
// 21.3.5
- std::list<typename String::value_type> lst(RandomList<String>(MaxString<String>::value));
- test.assign(lst.begin(), lst.end());
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ std::list<typename String::value_type> list(RandomList<String>(MaxString<String>::value));
+ random1.assign(list.begin(), list.end());
+ return random1;
}
template<class String>
- String insert_position_string(String & test)
+ String assign_iterator_iterator__self()
{
// 21.3.5
- const typename String::size_type position = random(0, test.size());
- String str(RandomString<String>(MaxString<String>::value));
- test.insert(position, str);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1.assign(random1.begin(), random1.end());
+ return random1;
}
template<class String>
- String insert_position_string_start_end(String & test)
+ String assign_iterator_iterator__selfcopy()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- const typename String::size_type position = random(0, test.size());
- const typename String::size_type start = random(0, str.size());
- const typename String::size_type end = random(0, MaxString<String>::value);
- test.insert(position, str, start, end);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ random1.assign(copy.begin(), copy.end());
+ return random1 + SeparatorString<String>() + copy;
}
template<class String>
- String insert_position_cstr_size(String & test)
+ String assign_iterator_iterator__self_reverse()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- const typename String::size_type position = random(0, test.size());
- const typename String::size_type size = random(0, str.size());
- test.insert(position, str.c_str(), size);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ random1.assign(random1.rbegin(), random1.rend());
+ return random1;
}
template<class String>
- String insert_position_cstr(String & test)
+ String assign_iterator_iterator__selfcopy_reverse()
{
// 21.3.5
- const typename String::size_type position = random(0, test.size());
- String str(RandomString<String>(MaxString<String>::value));
- test.insert(position, str.c_str());
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ random1.assign(copy.rbegin(), copy.rend());
+ return random1 + SeparatorString<String>() + copy;
}
template<class String>
- String insert_position_number_char(String & test)
+ String insert_position_string()
{
// 21.3.5
- const typename String::size_type position = random(0, test.size());
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(position, random2);
+ return random1 + SeparatorString<String>() + random2;
+ }
+
+ template<class String>
+ String insert_position_string__self()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(position, random1);
+ return random1;
+ }
+
+ template<class String>
+ String insert_position_string__selfcopy()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(position, copy);
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String insert_position_string_position_number()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type position2 = random(0, random2.size());
const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.insert(position1, random2, position2, number);
+ return random1 + SeparatorString<String>() + random2;
+ }
+
+ template<class String>
+ String insert_position_string_position_number__self()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type position2 = random(0, random1.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.insert(position1, random1, position2, number);
+ return random1;
+ }
+
+ template<class String>
+ String insert_position_string_position_number__selfcopy()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type position2 = random(0, copy.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.insert(position1, copy, position2, number);
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String insert_position_cstr_number()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, random2.size());
+ random1.insert(position, random2.c_str(), number);
+ return random1 + SeparatorString<String>() + random2;
+ }
+
+ template<class String>
+ String insert_position_cstr_number__self()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, random1.size());
+ random1.insert(position, random1.c_str(), number);
+ return random1;
+ }
+
+ template<class String>
+ String insert_position_cstr_number__selfcopy()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, copy.size());
+ random1.insert(position, copy.c_str(), number);
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String insert_position_cstr()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(position, random2.c_str());
+ return random1 + SeparatorString<String>() + random2;
+ }
+
+ template<class String>
+ String insert_position_cstr__self()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(position, random1.c_str());
+ return random1;
+ }
+
+ template<class String>
+ String insert_position_cstr__selfcopy()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(position, copy.c_str());
+ return random1 + SeparatorString<String>() + copy;
+ }
+
+ template<class String>
+ String insert_iterator_char()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
const typename String::value_type value = random('a', 'z');
- test.insert(position, number, value);
- return test;
+ random1.insert(random1.begin() + position, value);
+ return random1;
}
template<class String>
- String insert_iterator_char(String & test)
+ String insert_position_number_char()
{
// 21.3.5
- const typename String::size_type offset = random(0, test.size());
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
const typename String::value_type value = random('a', 'z');
- test.insert(test.begin() + offset, value);
- return test;
+ random1.insert(position, number, value);
+ return random1;
}
template<class String>
- String insert_iterator_iterator_range(String & test)
+ String insert_iterator_iterator()
{
// 21.3.5
- std::list<typename String::value_type> lst(RandomList<String>(MaxString<String>::value));
- const typename String::size_type offset = random(0, test.size());
- test.insert(test.begin() + offset, lst.begin(), lst.end());
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ std::list<typename String::value_type> list(RandomList<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(random1.begin() + position, list.begin(), list.end());
+ return random1;
}
template<class String>
- String erase_position_position(String & test)
+ String insert_iterator_iterator__self()
{
// 21.3.5
- const typename String::size_type start = random(0, test.size());
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(random1.begin() + position, random1.begin(), random1.end());
+ return random1;
+ }
+
+ template<class String>
+ String insert_iterator_iterator__selfcopy()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(random1.begin() + position, copy.begin(), copy.end());
+ return random1;
+ }
+
+ template<class String>
+ String insert_iterator_iterator__self_reverse()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(random1.begin() + position, random1.rbegin(), random1.rend());
+ return random1;
+ }
+
+ template<class String>
+ String insert_iterator_iterator__selfcopy_reverse()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position = random(0, random1.size());
+ random1.insert(random1.begin() + position, copy.rbegin(), copy.rend());
+ return random1;
+ }
+
+ template<class String>
+ String erase_position_number()
+ {
+ // 21.3.5
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type start = random(0, random1.size());
const typename String::size_type end = random(0, MaxString<String>::value);
- test.erase(start, end);
- return test;
+ random1.erase(start, end);
+ return random1;
}
template<class String>
- String erase_iterator(String & test)
+ String erase_iterator()
{
// 21.3.5
- if(!test.empty())
+ String random1(RandomString<String>(MaxString<String>::value));
+ if(!random1.empty())
{
- const typename String::size_type offset = random(0, test.size());
- test.erase(test.begin() + offset);
+ const typename String::size_type position = random(0, random1.size());
+ random1.erase(random1.begin() + position);
}
- return test;
+ return random1;
}
template<class String>
- String erase_iterator_iterator(String & test)
+ String erase_iterator_iterator()
{
// 21.3.5
- const typename String::size_type offset = random(0, test.size());
- const typename String::iterator i = test.begin() + offset;
- const typename String::size_type endOffset = random(0, test.end() - i);
- test.erase(i, i + endOffset);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type position2 = random(position1, random1.size());
+ random1.erase(random1.begin() + position1, random1.begin() + position2);
+ return random1;
}
template<class String>
- String replace_start_end_copyself(String & test)
+ String replace_position_number_string()
{
// 21.3.5
- const typename String::size_type pos = random(0, test.size());
- const typename String::size_type end = random(0, test.size() - pos);
- test.replace(pos, end, String(test));
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.replace(position, number, random2);
+ return random1;
}
template<class String>
- String replace_start_end_self(String & test)
+ String replace_position_number_string__self()
{
// 21.3.5
- const typename String::size_type pos = random(0, test.size());
- const typename String::size_type end = random(0, test.size() - pos);
- test.replace(pos, end, test);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.replace(position, number, random1);
+ return random1;
}
template<class String>
- String replace_start_end_string(String & test)
+ String replace_position_number_string__selfcopy()
{
// 21.3.5
- const typename String::size_type pos = random(0, test.size());
- const typename String::size_type end = random(0, test.size() - pos);
- String str(RandomString<String>(MaxString<String>::value));
- test.replace(pos, pos + end, str);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position = random(0, random1.size());
+ const typename String::size_type number = random(0, MaxString<String>::value);
+ random1.replace(position, number, copy);
+ return random1;
}
template<class String>
- String replace_start_end_selfcopy_start_end(String & test)
+ String replace_position_number_string_position_number()
{
// 21.3.5
- const typename String::size_type pos1 = random(0, test.size());
- const typename String::size_type pos2 = random(0, test.size());
- const typename String::size_type offset1 = random(0, test.size() - pos1);
- const typename String::size_type offset2 = random(0, test.size() - pos2);
- test.replace(pos1, pos1 + offset1, String(test), pos2, pos2 + offset2);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type number1 = random(0, MaxString<String>::value);
+ const typename String::size_type position2 = random(0, random2.size());
+ const typename String::size_type number2 = random(0, MaxString<String>::value);
+ random1.replace(position1, number1, random2, position2, number2);
+ return random1;
}
template<class String>
- String replace_start_end_self_start_end(String & test)
+ String replace_position_number_string_position_number__self()
{
// 21.3.5
- const typename String::size_type pos1 = random(0, test.size());
- const typename String::size_type pos2 = random(0, test.size());
- const typename String::size_type offset1 = random(0, test.size() - pos1);
- const typename String::size_type offset2 = random(0, test.size() - pos2);
- test.replace(pos1, pos1 + offset1, test, pos2, pos2 + offset2);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type number1 = random(0, MaxString<String>::value);
+ const typename String::size_type position2 = random(0, random1.size());
+ const typename String::size_type number2 = random(0, MaxString<String>::value);
+ random1.replace(position1, number1, random1, position2, number2);
+ return random1;
}
template<class String>
- String replace_start_end_string_start_end(String & test)
+ String replace_position_number_string_position_number__selfcopy()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- const typename String::size_type pos1 = random(0, test.size());
- const typename String::size_type pos2 = random(0, str.size());
- const typename String::size_type offset1 = random(0, test.size() - pos1);
- const typename String::size_type offset2 = random(0, str.size() - pos2);
- test.replace(pos1, pos1 + offset1, str, pos2, pos2 + offset2);
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type number1 = random(0, MaxString<String>::value);
+ const typename String::size_type position2 = random(0, random1.size());
+ const typename String::size_type number2 = random(0, MaxString<String>::value);
+ random1.replace(position1, number1, copy, position2, number2);
+ return random1;
}
template<class String>
- String replace_start_end_selfcopycstr_size(String & test)
+ String replace_position_number_cstr_number()
{
// 21.3.5
- const typename String::size_type pos = random(0, test.size());
- const typename String::size_type pos2 = random(0, test.size() - pos);
- test.replace(pos, pos2, String(test).c_str(), test.size());
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String random2(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type number1 = random(0, MaxString<String>::value);
+ const typename String::size_type number2 = random(0, random2.size());
+ random1.replace(position1, number1, random2.c_str(), number2);
+ return random1;
}
template<class String>
- String replace_start_end_selfcstr_size(String & test)
+ String replace_position_number_cstr_number__self()
{
// 21.3.5
- const typename String::size_type pos = random(0, test.size());
- const typename String::size_type pos2 = random(0, test.size() - pos);
- test.replace(pos, pos2, test.c_str(), test.size());
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type number1 = random(0, MaxString<String>::value);
+ const typename String::size_type number2 = random(0, random1.size());
+ random1.replace(position1, number1, random1.c_str(), number2);
+ return random1;
}
template<class String>
- String replace_start_end_stringcstr_size(String & test)
+ String replace_position_number_cstr_number__selfcopy()
{
// 21.3.5
- String str(RandomString<String>(MaxString<String>::value));
- const typename String::size_type pos = random(0, test.size());
- const typename String::size_type offset = random(0, test.size() - pos);
- test.replace(pos, pos + offset, str.c_str(), str.size());
- return test;
+ String random1(RandomString<String>(MaxString<String>::value));
+ String copy(random1);
+ const typename String::size_type position1 = random(0, random1.size());
+ const typename String::size_type number1 = random(0, MaxString<String>::value);
+ const typename String::size_type number2 = random(0, copy.size());
+ random1.replace(position1, number1, copy.c_str(), ...
[truncated message content] |
