#include "ZUnitTest.hpp" #include #include #include static const char* test_Append(); static const char* test_Append_Region(); static const char* test_BuildNumeric_Double(); static const char* test_BuildNumeric_Int(); static const char* test_BuildPrintf(); static const char* test_BuildRepeat(); static const char* test_Contains(); static const char* test_Contains_Region(); static const char* test_ContainsSub(); static const char* test_ContainsSub_Region(); static const char* test_Copy(); static const char* test_Copy_Region(); static const char* test_EndsWith(); static const char* test_EndsWith_Region(); static const char* test_Equal(); static const char* test_Equal_Region(); static const char* test_EqualIgnoreCase(); static const char* test_EqualIgnoreCase_Region(); static const char* test_Fill(); static const char* test_Fill_Region(); static const char* test_Find(); static const char* test_Find_Region(); static const char* test_FindAll(); static const char* test_FindAll_Region(); static const char* test_FindAllOf(); static const char* test_FindAllOf_Region(); static const char* test_FindFirst(); static const char* test_FindFirst_Region(); static const char* test_FindFirstOf(); static const char* test_FindFirstOf_Region(); static const char* test_FindFirstNot(); static const char* test_FindFirstNot_Region(); static const char* test_FindFirstNotOf(); static const char* test_FindFirstNotOf_Region(); static const char* test_FindLast(); static const char* test_FindLast_In_Region(); static const char* test_FindLastOf(); static const char* test_FindLastOf_In_Region(); static const char* test_FindLastNot(); static const char* test_FindLastNot_In_Region(); static const char* test_FindLastNotOf(); static const char* test_FindLastNotOf_In_Region(); static const char* test_FindSub(); static const char* test_FindSub_Region(); static const char* test_IsNumeric(); static const char* test_IsNumeric_Region(); static const char* test_Remove(); static const char* test_Remove_In_Region(); static const char* test_RemoveAll(); static const char* test_RemoveAll_In_Region(); static const char* test_RemoveUpTo(); static const char* test_RemoveUpTo_In_Region(); static const char* test_Replace(); #if 0 static const char* test_ReplaceSub(); #endif static const char* test_Replace_In_Region(); static const char* test_Reverse(); static const char* test_Reverse_Region(); static const char* test_Slice(); static const char* test_Split(); static const char* test_Split_Count(); static const char* test_Split_Count_Region(); static const char* test_StartsWith(); static const char* test_StartsWith_Region(); static const char* test_Strip(); static const char* test_Strip_Region(); static const char* test_Tokenize(); static const char* test_ToLower(); static const char* test_ToLower_Region(); static const char* test_ToUpper(); static const char* test_ToUpper_Region(); static const char* test_TrimLeft(); static const char* test_TrimLeft_Region(); static const char* test_TrimRight(); static const char* test_TrimRight_Region(); static const char* test_Trim(); static const char* test_Trim_Region(); ZUnitTest ZBasicStringAlgoUnitTests[] = { { "ZBasicStringAlgo: Append", test_Append }, { "ZBasicStringAlgo: Append in region", test_Append_Region }, { "ZBasicStringAlgo: BuildNumeric_Double", test_BuildNumeric_Double }, { "ZBasicStringAlgo: BuildNumeric_Int", test_BuildNumeric_Int }, { "ZBasicStringAlgo: BuildPrintf", test_BuildPrintf }, { "ZBasicStringAlgo: BuildRepeat", test_BuildRepeat }, { "ZBasicStringAlgo: Contains", test_Contains }, { "ZBasicStringAlgo: Contains region", test_Contains_Region }, { "ZBasicStringAlgo: ContainsSub", test_ContainsSub }, { "ZBasicStringAlgo: ContainsSub region", test_ContainsSub_Region }, { "ZBasicStringAlgo: Copy", test_Copy }, { "ZBasicStringAlgo: Copy region", test_Copy_Region }, { "ZBasicStringAlgo: EndsWith", test_EndsWith }, { "ZBasicStringAlgo: EndsWith region", test_EndsWith_Region }, { "ZBasicStringAlgo: Equal", test_Equal }, { "ZBasicStringAlgo: Equal region", test_Equal_Region }, { "ZBasicStringAlgo: EqualIgnoreCase", test_EqualIgnoreCase }, { "ZBasicStringAlgo: EqualIgnoreCase in region",test_EqualIgnoreCase_Region }, { "ZBasicStringAlgo: Fill", test_Fill }, { "ZBasicStringAlgo: Fill region", test_Fill_Region }, { "ZBasicStringAlgo: Find", test_Find }, { "ZBasicStringAlgo: Find in region", test_Find_Region }, { "ZBasicStringAlgo: FindAll", test_FindAll }, { "ZBasicStringAlgo: FindAll in region", test_FindAll_Region }, { "ZBasicStringAlgo: FindAllOf", test_FindAllOf }, { "ZBasicStringAlgo: FindAllOf region", test_FindAllOf_Region }, { "ZBasicStringAlgo: FindFirst", test_FindFirst }, { "ZBasicStringAlgo: FindFirst in region", test_FindFirst_Region }, { "ZBasicStringAlgo: FindFirstOf", test_FindFirstOf }, { "ZBasicStringAlgo: FindFirstOf in region", test_FindFirstOf_Region }, { "ZBasicStringAlgo: FindFirstNot", test_FindFirstNot }, { "ZBasicStringAlgo: FindFirstNot region", test_FindFirstNot_Region }, { "ZBasicStringAlgo: FindFirstNotof", test_FindFirstNotOf }, { "ZBasicStringAlgo: FindFirstNotOf region", test_FindFirstNotOf_Region }, { "ZBasicStringAlgo: FindLast", test_FindLast }, { "ZBasicStringAlgo: FindLast in region", test_FindLast_In_Region }, { "ZBasicStringAlgo: FindLastOf", test_FindLastOf }, { "ZBasicStringAlgo: FindLastOf in region", test_FindLastOf_In_Region }, { "ZBasicStringAlgo: FindLastNot", test_FindLastNot }, { "ZBasicStringAlgo: FindLastNot in region", test_FindLastNot_In_Region }, { "ZBasicStringAlgo: FindLastNotOf", test_FindLastNotOf }, { "ZBasicStringAlgo: FindLastNotOf in region", test_FindLastNotOf_In_Region }, { "ZBasicStringAlgo: FindSub", test_FindSub }, { "ZBasicStringAlgo: FindSub region", test_FindSub_Region }, { "ZBasicStringAlgo: IsNumeric", test_IsNumeric }, { "ZBasicStringAlgo: IsNumeric region", test_IsNumeric_Region }, { "ZBasicStringAlgo: Remove", test_Remove }, { "ZBasicStringAlgo: Remove in region", test_Remove_In_Region }, { "ZBasicStringAlgo: RemoveAll", test_RemoveAll }, { "ZBasicStringAlgo: RemoveAll in region", test_RemoveAll_In_Region }, { "ZBasicStringAlgo: RemoveUpTo", test_RemoveUpTo }, { "ZBasicStringAlgo: RemoveUpTo in region", test_RemoveUpTo_In_Region }, { "ZBasicStringAlgo: Replace", test_Replace }, #if 0 { "ZBasicStringAlgo: ReplaceSub", test_ReplaceSub }, #endif { "ZBasicStringAlgo: Replace in region", test_Replace_In_Region }, { "ZBasicStringAlgo: Reverse", test_Reverse }, { "ZBasicStringAlgo: Reverse region", test_Reverse_Region }, { "ZBasicStringAlgo: Slice", test_Slice }, { "ZBasicStringAlgo: Split", test_Split }, { "ZBasicStringAlgo: Split Count", test_Split_Count }, { "ZBasicStringAlgo: Split Count region", test_Split_Count_Region }, { "ZBasicStringAlgo: StartsWith", test_StartsWith }, { "ZBasicStringAlgo: StartsWith region", test_StartsWith_Region }, { "ZBasicStringAlgo: Strip", test_Strip }, { "ZBasicStringAlgo: Strip region", test_Strip_Region }, { "ZBasicStringAlgo: Tokenize", test_Tokenize }, { "ZBasicStringAlgo: ToLower", test_ToLower }, { "ZBasicStringAlgo: ToLower region", test_ToLower_Region }, { "ZBasicStringAlgo: ToUpper", test_ToUpper }, { "ZBasicStringAlgo: ToUpper region", test_ToUpper_Region }, { "ZBasicStringAlgo: Trim left", test_TrimLeft }, { "ZBasicStringAlgo: Trim left region", test_TrimLeft_Region }, { "ZBasicStringAlgo: Trim right", test_TrimRight }, { "ZBasicStringAlgo: Trim right region", test_TrimRight_Region }, { "ZBasicStringAlgo: Trim", test_Trim }, { "ZBasicStringAlgo: Trim region", test_Trim_Region }, }; DECLARE_ZTESTBLOCK(ZBasicStringAlgo); /*************************************************************************/ static const char* test_Append() { ZBasicString<> str; ZBasicStringAlgo::Append(str, "ABC"); TASSERT(str == "ABC", "Append() did not correctly append first string!"); ZBasicStringAlgo::Append(str, "DEF"); TASSERT(str == "ABCDEF", "Append() did not correctly append first string!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Append_Region() { ZBasicString<> str; ZBasicStringAlgo::Append(str, "ABC", 0, 1); TASSERT(str == "A", "Append() did not correctly append first string!"); ZBasicStringAlgo::Append(str, "DEF", 1, 3); TASSERT(str == "AEF", "Append() did not correctly append first string!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_BuildNumeric_Double() { ZBasicString<> str; ZBasicStringAlgo::BuildNumeric(str, 0.0); TASSERT(str == "0.000000", "BuildNumeric() failed to build correct string!"); ZBasicStringAlgo::BuildNumeric(str, "%.2f", 0.0); TASSERT(str == "0.00", "BuildNumeric(double) failed to build correct formatted string!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_BuildNumeric_Int() { ZBasicString<> str; ZBasicStringAlgo::BuildNumeric(str, 12345); TASSERT(str == "12345", "BuildNumeric() failed to build correct string!"); ZBasicStringAlgo::BuildNumeric(str, "%+i", 12345); TASSERT(str == "+12345", "BuildNumeric(int) failed to build correct formatted string!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_BuildPrintf() { ZBasicString<> str; ZBasicStringAlgo::BuildPrintf(str, " %3ist ", 1); TASSERT(str == " 1st ", "BuildPrintf() failed to produce correct formatted string!"); ZBasicStringAlgo::BuildPrintf(str, " %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f %3i %3.1f ", 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f, 1, 2.0f); TASSERT(str == " 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 1 2.0 ", "BuildPrintf() failed to produce correct formatted string 2!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_BuildRepeat() { ZBasicString<> str; ZBasicStringAlgo::BuildRepeat(str, "abc", 5); TASSERT(str == "abcabcabcabcabc", "BuildRepeat() failed to build abc * 5!"); ZBasicStringAlgo::BuildRepeat(str, "", 20); TASSERT(str.Empty(), "BuildRepeat() failed to build empty string with '' * 20!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Contains() { ZBasicString<> str("abcdef"); TASSERT(ZBasicStringAlgo::Contains(str, 'a'), "Contains('a') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::Contains(str, 'b'), "Contains('b') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::Contains(str, 'c'), "Contains('c') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::Contains(str, 'd'), "Contains('d') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::Contains(str, 'e'), "Contains('e') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::Contains(str, 'f'), "Contains('f') on 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::Contains(str, 'g'), "Contains('g') on 'abcdef' returns true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Contains_Region() { ZBasicString<> str("abcdef"); TASSERT(ZBasicStringAlgo::Contains(str, 'a', 0, 1), "Contains('a', 0, 1) on 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::Contains(str, 'b', 0, 1), "Contains('b', 0, 1) on 'abcdef' returns true!"); TASSERT(ZBasicStringAlgo::Contains(str, 'c', 1, 3), "Contains('c, 1, 3') on 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::Contains(str, 'd', 0, 2), "Contains('d', 0, 2) on 'abcdef' returns true!"); TASSERT(ZBasicStringAlgo::Contains(str, 'e', 4, 5), "Contains('e', 4, 5) on 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::Contains(str, 'f', 4, 5), "Contains('f', 4, 5) on 'abcdef' returns true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_ContainsSub() { ZBasicString<> str("abcdef"); TASSERT(ZBasicStringAlgo::ContainsSub(str, "a"), "ContainsSub('a') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, "ab"), "ContainsSub('ab') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, "abc"), "ContainsSub('abc') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, "abcd"), "ContainsSub('abcd') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, "abcde"), "ContainsSub('abcde') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, "abcdef"), "ContainsSub('abcdef') on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, "f"), "ContainsSub('f') on 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::ContainsSub(str, "ac"), "ContainsSub('ac') on 'abcdef' returns true!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, "bc"), "ContainsSub('abc') on 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::ContainsSub(str, "bde"), "ContainsSub('bde') on 'abcdef' returns true!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, "cdef"), "ContainsSub('cdef') on 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::ContainsSub(str, "cfed"), "ContainsSub('cfed') on 'abcdef' returns true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_ContainsSub_Region() { ZBasicString<> str("abcdef"); TASSERT(!ZBasicStringAlgo::ContainsSub(str, 1, 3, "a", 0, 1), "ContainsSub(1, 3, 'a', 0, 1) on 'abcdef' returns true!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, 0, 2, "ab", 0, 2), "ContainsSub(0, 2, 'ab', 0, 2) on 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, 1, 3, "abc", 1, 3), "ContainsSub(1, 3, 'abc', 1, 3) on 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::ContainsSub(str, 2, 6, "abcd", 0, 4), "ContainsSub(2, 6, 'abcd', 0, 4) on 'abcdef' returns true!"); TASSERT(ZBasicStringAlgo::ContainsSub(str, 4, 6, "abcde", 4, 5), "ContainsSub(4, 6, 'abcde', 4, 5) on 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::ContainsSub(str, 0, 3, "abcdef", 0, 6), "ContainsSub(0, 3, 'abcdef', 0, 6) on 'abcdef' returns true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Copy() { ZBasicString<> str; ZBasicStringAlgo::Copy(str, "abcdef"); TASSERT(str.Empty(), "Copy('abcdef') failed to keep string!"); str.Copy("abcdef"); ZBasicStringAlgo::Copy(str, ""); TASSERT(str == "abcdef", "Copy('') failed to keep 'abcdef'!"); ZBasicStringAlgo::Copy(str, "cba"); TASSERT(str == "cbadef", "Copy('cba') did not copy correctly!"); ZBasicStringAlgo::Copy(str, "abcdefghijklmnopqrstuvwxyz"); TASSERT(str == "abcdef", "Copy('abcdefghijklmnopqrstuvwxyz') failed to copy just 'abcdef'!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Copy_Region() { ZBasicString<> str("abcdef"); ZBasicStringAlgo::Copy(str, 2, 4, "dc", 0, 2); TASSERT(str == "abdcef", "Copy(2, 4, 'dc', 0, 2) region on string 'abcdef' failed to copy correct string!"); ZBasicStringAlgo::Copy(str, 1, 5, "wxyz", 1, 4); TASSERT(str == "axyzef", "Copy(1, 5, 'wxyz', 1, 4) region on string 'abdcef' failed to copy correct string!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_EndsWith() { ZBasicString<> str("abcdef"); TASSERT(ZBasicStringAlgo::EndsWith(str, "f"), "EndsWith('f') with string 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::EndsWith(str, "ef"), "EndsWith('ef') with string 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::EndsWith(str, "def"), "EndsWith('def') with string 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::EndsWith(str, "cdef"), "EndsWith('cdef') with string 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::EndsWith(str, "bcdef"), "EndsWith('bcdef') with string 'abcdef' returns false!"); TASSERT(ZBasicStringAlgo::EndsWith(str, "abcdef"), "EndsWith('abcdef') with string 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::EndsWith(str, "e"), "EndsWith('e') with string 'abcdef' returns true!"); TASSERT(!ZBasicStringAlgo::EndsWith(str, "df"), "EndsWith('e') with string 'abcdef' returns true!"); TASSERT(!ZBasicStringAlgo::EndsWith(str, "1bcdef"), "EndsWith('1bcdef') with string 'abcdef' returns true!"); TASSERT(!ZBasicStringAlgo::EndsWith(str, "123abcdef"), "EndsWith('123abcdef') with string 'abcdef' returns true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_EndsWith_Region() { ZBasicString<> str("abcdef"); TASSERT(ZBasicStringAlgo::EndsWith(str, 2, 4, "cd", 0, 2), "EndsWith(2, 4, 'cd', 0, 2) with string 'abcdef' returns false!"); TASSERT(!ZBasicStringAlgo::EndsWith(str, 2, 4, "cd", 0, 1), "EndsWith(2, 4, 'cd', 0, 1) with string 'abcdef' returns true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Equal() { ZBasicString<> str1("abc"); ZBasicString<> str2("abcd"); ZBasicString<> str3("ab"); ZBasicString<> str4("ace"); TASSERT(ZBasicStringAlgo::Equal(str1, str1), "Equal('abc', 'abc') did not return true!"); TASSERT(ZBasicStringAlgo::Equal(str1, str2), "Equal('abc', 'abcd') did not return true!"); TASSERT(ZBasicStringAlgo::Equal(str1, str3), "Equal('abc', 'ab') did not return true!"); TASSERT(!ZBasicStringAlgo::Equal(str1, str4), "Equal('abc', 'ace') did not return false!"); TASSERT(ZBasicStringAlgo::Equal(str2, str1), "Equal('abcd', 'abc') did not return true!"); TASSERT(ZBasicStringAlgo::Equal(str2, str2), "Equal('abcd', 'abcd') did not return true!"); TASSERT(ZBasicStringAlgo::Equal(str2, str3), "Equal('abcd', 'ab') did not return true!"); TASSERT(!ZBasicStringAlgo::Equal(str2, str4), "Equal('abcd', 'ace') did not return false!"); TASSERT(ZBasicStringAlgo::Equal(str3, str1), "Equal('ab', 'abc') did not return true!"); TASSERT(ZBasicStringAlgo::Equal(str3, str2), "Equal('ab', 'abcd') did not return true!"); TASSERT(ZBasicStringAlgo::Equal(str3, str3), "Equal('ab', 'ab') did not return true!"); TASSERT(!ZBasicStringAlgo::Equal(str3, str4), "Equal('ab', 'ace') did not return false!"); TASSERT(!ZBasicStringAlgo::Equal(str4, str1), "Equal('ace', 'abc') did not return false!"); TASSERT(!ZBasicStringAlgo::Equal(str4, str2), "Equal('ace', 'abcd') did not return false!"); TASSERT(!ZBasicStringAlgo::Equal(str4, str3), "Equal('ace', 'ab') did not return false!"); TASSERT(ZBasicStringAlgo::Equal(str4, str4), "Equal('ace', 'ace') did not return true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Equal_Region() { ZBasicString<> str1("abc"); ZBasicString<> str2("abcd"); ZBasicString<> str3("ab"); ZBasicString<> str4("ace"); TASSERT(ZBasicStringAlgo::Equal(str1, 1, 2, str2, 1, 2), "Equal('abc', 1, 2, 'abcd', 1, 2) did not return true!"); TASSERT(ZBasicStringAlgo::Equal(str1, 0, 2, str3, 0, 1), "Equal('abc', 0, 2, 'ab', 0, 1) did not return true!"); TASSERT(!ZBasicStringAlgo::Equal(str2, 1, 4, str1, 0, 3), "Equal('abcd', 1, 4, 'abc', 0, 3) returned true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_EqualIgnoreCase() { ZBasicString<> str1("abC"); ZBasicString<> str2("ABcd"); ZBasicString<> str3("aB"); ZBasicString<> str4("aCE"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str1, str1), "EqualIgnoreCase('abC', 'abc') did not return true!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str1, str2), "EqualIgnoreCase('abC', 'ABcd') did not return true!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str1, str3), "EqualIgnoreCase('abC', 'aB') did not return true!"); TASSERT(!ZBasicStringAlgo::EqualIgnoreCase(str1, str4), "EqualIgnoreCase('abC', 'aCE') did not return false!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str2, str1), "EqualIgnoreCase('ABcd', 'abC') did not return true!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str2, str2), "EqualIgnoreCase('ABcd', 'ABcd') did not return true!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str2, str3), "EqualIgnoreCase('ABcd', 'aB') did not return true!"); TASSERT(!ZBasicStringAlgo::EqualIgnoreCase(str2, str4), "EqualIgnoreCase('ABcd', 'aCE') did not return false!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str3, str1), "EqualIgnoreCase('aB', 'abC') did not return true!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str3, str2), "EqualIgnoreCase('aB', 'ABcd') did not return true!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str3, str3), "EqualIgnoreCase('aB', 'aB') did not return true!"); TASSERT(!ZBasicStringAlgo::EqualIgnoreCase(str3, str4), "EqualIgnoreCase('aB', 'aCE') did not return false!"); TASSERT(!ZBasicStringAlgo::EqualIgnoreCase(str4, str1), "EqualIgnoreCase('aCE', 'abC') did not return false!"); TASSERT(!ZBasicStringAlgo::EqualIgnoreCase(str4, str2), "EqualIgnoreCase('aCE', 'ABcd') did not return false!"); TASSERT(!ZBasicStringAlgo::EqualIgnoreCase(str4, str3), "EqualIgnoreCase('aCE', 'aB') did not return false!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str4, str4), "EqualIgnoreCase('aCE', 'aCE') did not return true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_EqualIgnoreCase_Region() { ZBasicString<> str1("abC"); ZBasicString<> str2("ABcd"); ZBasicString<> str3("aB"); ZBasicString<> str4("aCE"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str1, 1, 2, str2, 1, 2), "Equal('abc', 1, 2, 'abcd', 1, 2) did not return true!"); TASSERT(ZBasicStringAlgo::EqualIgnoreCase(str1, 0, 2, str3, 0, 1), "Equal('abc', 0, 2, 'ab', 0, 1) did not return true!"); TASSERT(!ZBasicStringAlgo::EqualIgnoreCase(str2, 1, 4, str1, 0, 3), "Equal('abcd', 1, 4, 'abc', 0, 3) returned true!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Fill() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicStringAlgo::Fill(str1, ' '); ZBasicStringAlgo::Fill(str2, 'a'); TASSERT(str1.Empty(), "Fill(' ') on empty string did not leave empty string!"); TASSERT(str2 == "aaaaaa", "Fill('a') on 'abcdef' did not create correct string!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Fill_Region() { ZBasicString<> str("abcdef"); ZBasicStringAlgo::Fill(str, 'a', 2, 5); TASSERT(str == "abaaaf", "Fill('a', 2, 5) on string 'abcdef' did not produce correct string!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Find() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); TASSERT(ZBasicStringAlgo::Find(str1, 'a', 0) == ZSTL::InvalidPos, "Find('a', 0) with empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::Find(str1, 'a', 1) == ZSTL::InvalidPos, "Find('a', 1) with empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::Find(str2, 'a', 0) == 0, "Find('a', 0) with 'abcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::Find(str2, 'a', 1) == ZSTL::InvalidPos, "Find('a', 1) with 'abcdef' did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::Find(str2, 'c', 0) == 2, "Find('c', 0) with 'abcdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::Find(str2, 'c', 1) == ZSTL::InvalidPos, "Find('a', 1) with 'abcdef' did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::Find(str2, 'f', 0) == 5, "Find('f', 0) with 'abcdef' did not return index 5!"); TASSERT(ZBasicStringAlgo::Find(str2, 'f', 1) == ZSTL::InvalidPos, "Find('a', 1) with 'abcdef' did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::Find(str3, 'a', 0) == 0, "Find('a', 0) with 'abcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::Find(str3, 'a', 1) == 6, "Find('a', 1) with 'abcdef' did not return index 6!"); TASSERT(ZBasicStringAlgo::Find(str3, 'c', 0) == 2, "Find('c', 0) with 'abcdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::Find(str3, 'c', 1) == 8, "Find('a', 1) with 'abcdef' did not return index 8!"); TASSERT(ZBasicStringAlgo::Find(str3, 'f', 0) == 5, "Find('f', 0) with 'abcdef' did not return index 5!"); TASSERT(ZBasicStringAlgo::Find(str3, 'f', 1) == 11, "Find('a', 1) with 'abcdef' did not return index 11!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Find_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); TASSERT(ZBasicStringAlgo::Find(str2, 'a', 0, 2, 4) == ZSTL::InvalidPos, "Find('a', 0, 2, 4) with 'abcdef' did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::Find(str2, 'a', 0, 0, 1) == 0, "Find('a', 0, 0, 1) with 'abcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::Find(str3, 'a', 1, 3, 7) == ZSTL::InvalidPos, "Find('a', 1, 3, 7) with string 'abcdefabcdef' did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::Find(str3, 'f', 1, 5, 12) == 11, "Find('f', 1, 5, 12) with string 'abcdefabcdef' did not return index 11!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindAll() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); ZArray results; results = ZBasicStringAlgo::FindAll(str1, 'a'); TASSERT(results.Empty(), "FindAll('a') on empty string returned values!"); results = ZBasicStringAlgo::FindAll(str2, 'a'); TASSERT(results.Size() == 1, "FindAll('a') on string 'abcdef' returned incorrect number of results!"); TASSERT(results[0] == 0, "FindAll('a') on string 'abcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str2, 'b'); TASSERT(results.Size() == 1, "FindAll('b') on string 'abcdef' returned incorrect number of results!"); TASSERT(results[0] == 1, "FindAll('b') on string 'abcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str2, 'c'); TASSERT(results.Size() == 1, "FindAll('c') on string 'abcdef' returned incorrect number of results!"); TASSERT(results[0] == 2, "FindAll('c') on string 'abcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str2, 'd'); TASSERT(results.Size() == 1, "FindAll('d') on string 'abcdef' returned incorrect number of results!"); TASSERT(results[0] == 3, "FindAll('d') on string 'abcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str2, 'e'); TASSERT(results.Size() == 1, "FindAll('e') on string 'abcdef' returned incorrect number of results!"); TASSERT(results[0] == 4, "FindAll('e') on string 'abcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str2, 'f'); TASSERT(results.Size() == 1, "FindAll('f') on string 'abcdef' returned incorrect number of results!"); TASSERT(results[0] == 5, "FindAll('f') on string 'abcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str2, 'g'); TASSERT(results.Empty(), "FindAll('g') on string 'abcdef' returned values!"); results = ZBasicStringAlgo::FindAll(str3, 'a'); TASSERT(results.Size() == 2, "FindAll('a') on string 'abcdefabcdef' returned incorrect number of results!"); TASSERT(results[0] == 0, "FindAll('a') on string 'abcdefabcdef' returned incorrect result!"); TASSERT(results[1] == 6, "FindAll('a') on string 'abcdefabcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str3, 'b'); TASSERT(results.Size() == 2, "FindAll('b') on string 'abcdefabcdef' returned incorrect number of results!"); TASSERT(results[0] == 1, "FindAll('b') on string 'abcdefabcdef' returned incorrect result!"); TASSERT(results[1] == 7, "FindAll('b') on string 'abcdefabcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str3, 'c'); TASSERT(results.Size() == 2, "FindAll('c') on string 'abcdefabcdef' returned incorrect number of results!"); TASSERT(results[0] == 2, "FindAll('c') on string 'abcdefabcdef' returned incorrect result!"); TASSERT(results[1] == 8, "FindAll('c') on string 'abcdefabcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str3, 'd'); TASSERT(results.Size() == 2, "FindAll('d') on string 'abcdefabcdef' returned incorrect number of results!"); TASSERT(results[0] == 3, "FindAll('d') on string 'abcdefabcdef' returned incorrect result!"); TASSERT(results[1] == 9, "FindAll('d') on string 'abcdefabcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str3, 'e'); TASSERT(results.Size() == 2, "FindAll('e') on string 'abcdefabcdef' returned incorrect number of results!"); TASSERT(results[0] == 4, "FindAll('e') on string 'abcdefabcdef' returned incorrect result!"); TASSERT(results[1] == 10, "FindAll('e') on string 'abcdefabcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str3, 'f'); TASSERT(results.Size() == 2, "FindAll('f') on string 'abcdefabcdef' incorrect number of results!"); TASSERT(results[0] == 5, "FindAll('f') on string 'abcdefabcdef' returned incorrect result!"); TASSERT(results[1] == 11, "FindAll('f') on string 'abcdefabcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAll(str3, 'g'); TASSERT(results.Empty(), "FindAll('g') on string 'abcdefabcdef' returned values!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindAll_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); ZArray results; results = ZBasicStringAlgo::FindAll(str2, 'a', 2, 4); TASSERT(results.Size() == 0, "FindAll('abcdef', 'a', 2, 4) returned too many results!"); results = ZBasicStringAlgo::FindAll(str2, 'c', 2, 4); TASSERT(results.Size() == 1, "FindAll('abcdef', 'c', 2, 4) returned incorrect number of results!"); TASSERT(results[0] == 2, "FindAll('abcdef', 'c', 2, 4) returned incorrect index!"); results = ZBasicStringAlgo::FindAll(str3, 'd', 2, 9); TASSERT(results.Size() == 1, "FindAll('abcdef', 'd', 2, 9) returned incorrect number of results!"); TASSERT(results[0] == 3, "FindAll('abcdef', 'd', 2, 9) returned incorrect index!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindAllOf() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); ZArray results; results = ZBasicStringAlgo::FindAllOf(str1, "acg"); TASSERT(results.Empty(), "FindAllOf('acg') on empty string returned values!"); results = ZBasicStringAlgo::FindAllOf(str2, "b"); TASSERT(results.Size() == 1, "FindAllOf('b') on string 'abcdef' returned wrong number of results!"); TASSERT(results[0] == 1, "FindAllOf('b') on string 'abcdef' returned incorrect results!"); results = ZBasicStringAlgo::FindAllOf(str2, "acg"); TASSERT(results.Size() == 2, "FindAllOf('acg') on string 'abcdef' returned wrong number of results!"); TASSERT(results[0] == 0, "FindAllOf('acg') on string 'abcdef' returned incorrect result!"); TASSERT(results[1] == 2, "FindAllOf('acg') on string 'abcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAllOf(str2, "acgab"); TASSERT(results.Size() == 3, "FindAllOf('acgab') on string 'abcdef' returned wrong number of results!"); TASSERT(results[0] == 0, "FindAllOf('acgab') on string 'abcdef' returned incorrect result!"); TASSERT(results[1] == 1, "FindAllOf('acgab') on string 'abcdef' returned incorrect result!"); TASSERT(results[2] == 2, "FindAllOf('acgab') on string 'abcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAllOf(str2, "sr g"); TASSERT(results.Empty(), "FindAllOf('sr g') on string 'abcdef' returned values!"); results = ZBasicStringAlgo::FindAllOf(str3, "e"); TASSERT(results.Size() == 2, "FindAllOf('e') on string 'abcdef' returned wrong number of results!"); TASSERT(results[0] == 4, "FindAllOf('e') on string 'abcdef' returned incorrect results!"); TASSERT(results[1] == 10, "FindAllOf('e') on string 'abcdef' returned incorrect results!"); results = ZBasicStringAlgo::FindAllOf(str3, "afk"); TASSERT(results.Size() == 4, "FindAllOf('afk') on string 'abcdefabcdef' returned wrong number of results!"); TASSERT(results[0] == 0, "FindAllOf('afk') on string 'abcdefabcdef' returned incorrect result!"); TASSERT(results[1] == 5, "FindAllOf('afk') on string 'abcdefabcdef' returned incorrect result!"); TASSERT(results[2] == 6, "FindAllOf('afk') on string 'abcdefabcdef' returned incorrect result!"); TASSERT(results[3] == 11, "FindAllOf('afk') on string 'abcdefabcdef' returned incorrect result!"); results = ZBasicStringAlgo::FindAllOf(str3, "qrg "); TASSERT(results.Empty(), "FindAllOf('qrg ') on string 'abcdefabcdef' returned values!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindAllOf_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); ZArray results; results = ZBasicStringAlgo::FindAllOf(str2, 2, 4, "ab", 0, 2); TASSERT(results.Size() == 0, "FindAll('abcdef', 2, 4, 'ab', 0, 2) returned too many results!"); results = ZBasicStringAlgo::FindAllOf(str2, 2, 4, "cde", 1, 3); TASSERT(results.Size() == 1, "FindAll('abcdef', 2, 4, 'cde', 1, 3) returned incorrect number of results!"); TASSERT(results[0] == 3, "FindAll('abcdef', 2, 4, 'cde', 1, 3) returned incorrect second index!"); results = ZBasicStringAlgo::FindAllOf(str3, 2, 9, "ade", 0, 2); TASSERT(results.Size() == 2, "FindAll('abcdefabcdef', 2, 9, 'ade', 0, 2) returned incorrect number of results!"); TASSERT(results[0] == 3, "FindAll('abcdefabcdef', 2, 9, 'ade', 0, 2) returned incorrect first index!"); TASSERT(results[1] == 6, "FindAll('abcdefabcdef', 2, 9, 'ade', 0, 2) return incorrect second index!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindFirst() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); TASSERT(ZBasicStringAlgo::FindFirst(str1, 'a') == ZSTL::InvalidPos, "FindFirst('a') on empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindFirst(str2, 'a') == 0, "FindFirst('a') on string 'abcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::FindFirst(str2, 'b') == 1, "FindFirst('b') on string 'abcdef' did not return index 1!"); TASSERT(ZBasicStringAlgo::FindFirst(str2, 'c') == 2, "FindFirst('c') on string 'abcdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::FindFirst(str2, 'd') == 3, "FindFirst('d') on string 'abcdef' did not return index 3!"); TASSERT(ZBasicStringAlgo::FindFirst(str2, 'e') == 4, "FindFirst('e') on string 'abcdef' did not return index 4!"); TASSERT(ZBasicStringAlgo::FindFirst(str2, 'f') == 5, "FindFirst('f') on string 'abcdef' did not return index 5!"); TASSERT(ZBasicStringAlgo::FindFirst(str2, 'g') == ZSTL::InvalidPos, "FindFirst('g') on string 'abcdef' did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindFirst(str3, 'a') == 0, "FindFirst('a') on string 'abcdefabcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::FindFirst(str3, 'b') == 1, "FindFirst('b') on string 'abcdefabcdef' did not return index 1!"); TASSERT(ZBasicStringAlgo::FindFirst(str3, 'c') == 2, "FindFirst('c') on string 'abcdefabcdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::FindFirst(str3, 'd') == 3, "FindFirst('d') on string 'abcdefabcdef' did not return index 3!"); TASSERT(ZBasicStringAlgo::FindFirst(str3, 'e') == 4, "FindFirst('e') on string 'abcdefabcdef' did not return index 4!"); TASSERT(ZBasicStringAlgo::FindFirst(str3, 'f') == 5, "FindFirst('f') on string 'abcdefabcdef' did not return index 5!"); TASSERT(ZBasicStringAlgo::FindFirst(str3, 'g') == ZSTL::InvalidPos, "FindFirst('g') on string 'abcdefabcdef' did not return InvalidPos!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindFirst_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); TASSERT(ZBasicStringAlgo::FindFirst(str2, 'a', 2, 5) == ZSTL::InvalidPos, "FindFirst('abcdef', 'a', 2, 5) did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindFirst(str2, 'd', 2, 5) == 3, "FindFirst('abcdef', 'd', 2, 5) did not return index 3!"); TASSERT(ZBasicStringAlgo::FindFirst(str3, 'c', 1, 11) == 2, "FindFirst('abcdefabcdef', 'c', 1, 11) did not return index 2!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindFirstOf() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); TASSERT(ZBasicStringAlgo::FindFirstOf(str1, "abc") == ZSTL::InvalidPos, "FindFirstOf('abc') on empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindFirstOf(str2, "ace") == 0, "FindFirstOf('ace') on string 'abcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::FindFirstOf(str2, "ce") == 2, "FindFirstOf('ce') on string 'abcdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::FindFirstOf(str2, "e") == 4, "FindFirstOf('e') on string 'abcdef' did not return index 4!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindFirstOf_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); TASSERT(ZBasicStringAlgo::FindFirstOf(str2, 2, 4, "ace", 0, 3) == 2, "FindFirstOf('abcdef', 2, 4, 'ace', 0, 3) did not return index 2!"); TASSERT(ZBasicStringAlgo::FindFirstOf(str2, 0, 2, "ce", 0, 2) == ZSTL::InvalidPos, "FindFirstOf('abcdef', 0, 2, 'ce', 0, 2) did not return index InvalidPos!"); TASSERT(ZBasicStringAlgo::FindFirstOf(str2, 1, 6, "e", 0, 1) == 4, "FindFirstOf('abcdef, 1, 6, 'e', 0, 1) did not return index 4!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindFirstNot() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("aacdef"); ZBasicString<> str4("aaadef"); ZBasicString<> str5("aaaaef"); ZBasicString<> str6("aaaaaf"); ZBasicString<> str7("aaaaaa"); TASSERT(ZBasicStringAlgo::FindFirstNot(str1, 'a') == ZSTL::InvalidPos, "FindFirstNot('a') on empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindFirstNot(str2, 'a') == 1, "FindFirstNot('a') on string 'abcdef' did not return index 1!"); TASSERT(ZBasicStringAlgo::FindFirstNot(str3, 'a') == 2, "FindFirstNot('a') on string 'aacdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::FindFirstNot(str4, 'a') == 3, "FindFirstNot('a') on string 'aaadef' did not return index 3!"); TASSERT(ZBasicStringAlgo::FindFirstNot(str5, 'a') == 4, "FindFirstNot('a') on string 'aaaaef' did not return index 4!"); TASSERT(ZBasicStringAlgo::FindFirstNot(str6, 'a') == 5, "FindFirstNot('a') on string 'aaaaaf' did not return index 5!"); TASSERT(ZBasicStringAlgo::FindFirstNot(str7, 'a') == ZSTL::InvalidPos, "FindFirstNot('a') on string 'aaaaaa' did not return InvalidPos!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindFirstNot_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("aacdef"); ZBasicString<> str4("aaadef"); TASSERT(ZBasicStringAlgo::FindFirstNot(str2, 'a', 0, 1) == ZSTL::InvalidPos, "FindFirstNot('abcdef', 'a', 0, 1) did not return index InvalidPos!"); TASSERT(ZBasicStringAlgo::FindFirstNot(str3, 'a', 1, 4) == 2, "FindFirstNot('abcdef', 'a', 1, 4) did not return index 2!"); TASSERT(ZBasicStringAlgo::FindFirstNot(str4, 'a', 0, 4) == 3, "FindFirstNot('a') on string 'aaadef' did not return index 3!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindFirstNotOf() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str1, "abc") == ZSTL::InvalidPos, "FindFirstNotOf('abc') on empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, " ") == 0, "FindFirstNotOf(' ') on string 'abcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, "a") == 1, "FindFirstNotOf('a') on string 'abcdef' did not return index 1!"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, "ab") == 2, "FindFirstNotOf('ab') on string 'abcdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, "abc") == 3, "FindFirstNotOf('abc') on string 'abcdef' did not return index 3!"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, "abcd") == 4, "FindFirstNotOf('abcd') on string 'abcdef' did not return index 4!"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, "abcde") == 5, "FindFirstNotOf('abcde') on string 'abcdef' did not return index 5!"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, "abcdef") == ZSTL::InvalidPos, "FindFirstNotOf('abcdef') on string 'abcdef' did not return InvalidPos!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindFirstNotOf_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, 2, 4, " ", 0, 1) == 2, "FindFirstNotOf('abcdef', 2, 4, ' ', 0 , 1) did not return index 2!"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, 2, 4, "a", 0, 1) == 2, "FindFirstNotOf('abcdef', 2, 4, 'a', 0, 1) did not return index 2!"); TASSERT(ZBasicStringAlgo::FindFirstNotOf(str2, 1, 6, "abcd", 1, 3) == 3, "FindFirstNotOf('abcdef', 1, 6, 'abcd', 1, 3) did not return index 3!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindLast() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); TASSERT(ZBasicStringAlgo::FindLast(str1, 'a') == ZSTL::InvalidPos, "FindLast('a') on empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindLast(str2, 'a') == 0, "FindLast('a') on string 'abcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::FindLast(str2, 'b') == 1, "FindLast('b') on string 'abcdef' did not return index 1!"); TASSERT(ZBasicStringAlgo::FindLast(str2, 'c') == 2, "FindLast('c') on string 'abcdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::FindLast(str2, 'd') == 3, "FindLast('d') on string 'abcdef' did not return index 3!"); TASSERT(ZBasicStringAlgo::FindLast(str2, 'e') == 4, "FindLast('e') on string 'abcdef' did not return index 4!"); TASSERT(ZBasicStringAlgo::FindLast(str2, 'f') == 5, "FindLast('f') on string 'abcdef' did not return index 5!"); TASSERT(ZBasicStringAlgo::FindLast(str2, 'g') == ZSTL::InvalidPos, "FindLast('g') on string 'abcdef' did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindLast(str3, 'a') == 6, "FindLast('a') on string 'abcdefabcdef' did not return index 6!"); TASSERT(ZBasicStringAlgo::FindLast(str3, 'b') == 7, "FindLast('b') on string 'abcdefabcdef' did not return index 7!"); TASSERT(ZBasicStringAlgo::FindLast(str3, 'c') == 8, "FindLast('c') on string 'abcdefabcdef' did not return index 8!"); TASSERT(ZBasicStringAlgo::FindLast(str3, 'd') == 9, "FindLast('d') on string 'abcdefabcdef' did not return index 9!"); TASSERT(ZBasicStringAlgo::FindLast(str3, 'e') == 10, "FindLast('e') on string 'abcdefabcdef' did not return index 10!"); TASSERT(ZBasicStringAlgo::FindLast(str3, 'f') == 11, "FindLast('f') on string 'abcdefabcdef' did not return index 11!"); TASSERT(ZBasicStringAlgo::FindLast(str3, 'g') == ZSTL::InvalidPos, "FindLast('g') on string 'abcdefabcdef' did not return InvalidPos!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindLast_In_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); TASSERT(ZBasicStringAlgo::FindLast(str2, 'a', 2, 5) == ZSTL::InvalidPos, "FindLast('abcdef', 'a', 2, 5) did not return index InvalidPos!"); TASSERT(ZBasicStringAlgo::FindLast(str2, 'b', 1, 3) == 1, "FindLast('abcdef', 'b', 1, 3) did not return index 1!"); TASSERT(ZBasicStringAlgo::FindLast(str3, 'a', 2, 9) == 6, "FindLast('abcdefabcdef', 'a', 2, 9) did not return index 6!"); TASSERT(ZBasicStringAlgo::FindLast(str3, 'b', 1, 6) == 1, "FindLast('abcdefabcdef', 'b', 1, 6) did not return index 1!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindLastOf() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); TASSERT(ZBasicStringAlgo::FindLastOf(str1, "abc") == ZSTL::InvalidPos, "FindLastOf('abc') on empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindLastOf(str2, "ace") == 4, "FindLastOf('ace') on string 'abcdef' did not return index 4!"); TASSERT(ZBasicStringAlgo::FindLastOf(str2, "ac") == 2, "FindLastOf('ac') on string 'abcdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::FindLastOf(str2, "a") == 0, "FindLastOf('a') on string 'abcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::FindLastOf(str2, "ghijklmnop") == ZSTL::InvalidPos, "FindLastOf('ghijklmnop') on string 'abcdef' did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindLastOf(str3, "ace") == 10, "FindLastOf('ace') on string 'abcdef' did not return index 10!"); TASSERT(ZBasicStringAlgo::FindLastOf(str3, "ac") == 8, "FindLastOf('ac') on string 'abcdef' did not return index 8!"); TASSERT(ZBasicStringAlgo::FindLastOf(str3, "a") == 6, "FindLastOf('a') on string 'abcdef' did not return index 6!"); TASSERT(ZBasicStringAlgo::FindLastOf(str3, "ghijklmnop") == ZSTL::InvalidPos, "FindLastOf('ghijklmnop') on string 'abcdefabcdef' did not return InvalidPos!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindLastOf_In_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdefabcdef"); TASSERT(ZBasicStringAlgo::FindLastOf(str2, 2, 6, "ace", 0, 2) == 2, "FindLastOf('abcdef', 2, 6, 'ace', 0, 2) did not return index 2!"); TASSERT(ZBasicStringAlgo::FindLastOf(str2, 0, 2, "ac", 0, 2) == 0, "FindLastOf('abcdef', 0, 2, 'ac', 0, 2) did not return index 0!"); TASSERT(ZBasicStringAlgo::FindLastOf(str3, 0, 6, "ace", 1, 3) == 4, "FindLastOf('abcdef', 0, 6, 'ace', 1, 3) did not return index 4!"); TASSERT(ZBasicStringAlgo::FindLastOf(str3, 2, 11, "ac", 0, 2) == 8, "FindLastOf('abcdef', 2, 11, 'ac', 0, 2) did not return index 8!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindLastNot() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdff"); ZBasicString<> str4("abcfff"); ZBasicString<> str5("abffff"); ZBasicString<> str6("afffff"); ZBasicString<> str7("ffffff"); TASSERT(ZBasicStringAlgo::FindLastNot(str1, 'f') == ZSTL::InvalidPos, "FindLastNot('f') on empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindLastNot(str2, 'f') == 4, "FindLastNot('f') on string 'abcdef' did not return index 4!"); TASSERT(ZBasicStringAlgo::FindLastNot(str3, 'f') == 3, "FindLastNot('f') on string 'abcdff' did not return index 3!"); TASSERT(ZBasicStringAlgo::FindLastNot(str4, 'f') == 2, "FindLastNot('f') on string 'abcfff' did not return index 2!"); TASSERT(ZBasicStringAlgo::FindLastNot(str5, 'f') == 1, "FindLastNot('f') on string 'abffff' did not return index 1!"); TASSERT(ZBasicStringAlgo::FindLastNot(str6, 'f') == 0, "FindLastNot('f') on string 'afffff' did not return index 0!"); TASSERT(ZBasicStringAlgo::FindLastNot(str7, 'f') == ZSTL::InvalidPos, "FindLastNot('f') on string 'ffffff' did not return InvalidPos!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindLastNot_In_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); ZBasicString<> str3("abcdff"); TASSERT(ZBasicStringAlgo::FindLastNot(str2, 'f', 2, 4) == 3, "FindLastNot('abcdef', 'f', 2, 4) did not return index 3!"); TASSERT(ZBasicStringAlgo::FindLastNot(str3, 'f', 2, 5) == 3, "FindLastNot('abcdef', 'f', 2, 5) did not return index 3!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindLastNotOf() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str1, "abc") == ZSTL::InvalidPos, "FindLastNotOf('abc') on empty string did not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, " ") == 5, "FindLastNotOf(' ') on string 'abcdef' did not return index 5!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, "f") == 4, "FindLastNotOf('f') on string 'abcdef' did not return index 4!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, "ef") == 3, "FindLastNotOf('ef') on string 'abcdef' did not return index 3!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, "def") == 2, "FindLastNotOf('def') on string 'abcdef' did not return index 2!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, "cdef") == 1, "FindLastNotOf('cdef') on string 'abcdef' did not return index 1!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, "bcdef") == 0, "FindLastNotOf('bcdef') on string 'abcdef' did not return index 0!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, "abcdef") == ZSTL::InvalidPos, "FindLastNotOf('abcdef') on string 'abcdef' did not return InvalidPos!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindLastNotOf_In_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, 2, 4, " ", 0, 1) == 3, "FindLastNotOf('abcdef', 2, 4, ' ', 0, 1) did not return index 3!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, 2, 6, "f", 0, 1) == 4, "FindLastNotOf('abcdef', 2, 6, 'f', 0, 1) did not return index 4!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, 3, 5, "ef", 0, 2) == 3, "FindLastNotOf('abcdef', 3, 5, 'ef', 0, 2) did not return index 3!"); TASSERT(ZBasicStringAlgo::FindLastNotOf(str2, 1, 5, "def", 1, 2) == 3, "FindLastNotOf('abcdef', 1, 5, 'def', 1, 2) did not return index 3!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindSub() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); TASSERT(ZBasicStringAlgo::FindSub(str1, "a") == ZSTL::InvalidPos, "FindSub('a') on empty string does not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindSub(str2, "a") == 0, "FindSub('a') on 'abcdef' does not return index 0!"); TASSERT(ZBasicStringAlgo::FindSub(str2, "abc") == 0, "FindSub('abc') on 'abcdef' does not return index 0!"); TASSERT(ZBasicStringAlgo::FindSub(str2, "abcdef") == 0, "FindSub('abcdef') on 'abcdef' does not return index 0!"); TASSERT(ZBasicStringAlgo::FindSub(str2, "abcdefg") == ZSTL::InvalidPos, "FindSub('abcdefg') on 'abcdef' does not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindSub(str2, "bc") == 1, "FindSub('bc') on 'abcdef' does not return index 1!"); TASSERT(ZBasicStringAlgo::FindSub(str2, "def") == 3, "FindSub('def') on 'abcdef' does not return index 3!"); TASSERT(ZBasicStringAlgo::FindSub(str2, "efg") == ZSTL::InvalidPos, "FindSub('efg') on 'abcdef' does not return InvalidPos!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_FindSub_Region() { ZBasicString<> str1; ZBasicString<> str2("abcdef"); TASSERT(ZBasicStringAlgo::FindSub(str2, 0, 2, "abc", 1, 3) == ZSTL::InvalidPos, "FindSub(\"abcdef\", 0, 2, 'abc, 1, 3) does not return InvalidPos!"); TASSERT(ZBasicStringAlgo::FindSub(str2, 0, 2, "abc", 0, 2) == 0, "FindSub('abcdef', 0, 2, 'abc', 0, 2) does not return index 0!"); TASSERT(ZBasicStringAlgo::FindSub(str2, 0, 4, "bc", 1, 2) == 2, "FindSub('abcdef, 0, 4, 'bc', 1, 2) does not return index 2!"); TASSERT(ZBasicStringAlgo::FindSub(str2, 4, 6, "def", 1, 3) == 4, "FindSub('abcdef', 4, 6, 'def', 1, 3) does not return index 3!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_IsNumeric() { ZBasicString<> str1; ZBasicString<> str2("0"); ZBasicString<> str3("12345"); ZBasicString<> str4("0.0"); ZBasicString<> str5("10.01"); ZBasicString<> str6("-1.5"); ZBasicString<> str7("123.456.789"); ZBasicString<> str8("NotANumber"); ZBasicString<> str9("-1.45 "); ZBasicString<> str10("50a00"); TASSERT(!ZBasicStringAlgo::IsNumeric(str1), "IsNumeric() returns true on empty string!"); TASSERT(ZBasicStringAlgo::IsNumeric(str2), "IsNumeric() returns false on '0'!"); TASSERT(ZBasicStringAlgo::IsNumeric(str3), "IsNumeric() returns false on '12345'!"); TASSERT(ZBasicStringAlgo::IsNumeric(str4), "IsNumeric() returns false on '0.0'!"); TASSERT(ZBasicStringAlgo::IsNumeric(str5), "IsNumeric() returns false on '10.01'!"); TASSERT(ZBasicStringAlgo::IsNumeric(str6), "IsNumeric() returns false on '-1.5'!"); TASSERT(!ZBasicStringAlgo::IsNumeric(str7), "IsNumeric() returns true on '123.456.789'!"); TASSERT(!ZBasicStringAlgo::IsNumeric(str8), "IsNumeric() returns true on 'NotANumber'!"); TASSERT(!ZBasicStringAlgo::IsNumeric(str9), "IsNumeric() returns true on '-1.45'!"); TASSERT(!ZBasicStringAlgo::IsNumeric(str10), "IsNumeric() returns true on '50a00'!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_IsNumeric_Region() { ZBasicString<> str7("123.456.789"); ZBasicString<> str10("50a00"); TASSERT(ZBasicStringAlgo::IsNumeric(str7, 0, 3), "IsNumeric('123.456.789', 0, 3) does not return true!"); TASSERT(ZBasicStringAlgo::IsNumeric(str7, 0, 6), "IsNumeric('123.456.789', 0, 6) does not return true!"); TASSERT(!ZBasicStringAlgo::IsNumeric(str7, 2, 8), "IsNumeric(123.456.789, 2, 8) does not return false!"); TASSERT(ZBasicStringAlgo::IsNumeric(str10, 0, 2), "IsNumeric('50a00', 3, 4) does not return true!"); TASSERT(ZBasicStringAlgo::IsNumeric(str10, 3, 4), "IsNumeric('50a00', 3, 4) does not return true!"); TASSERT(!ZBasicStringAlgo::IsNumeric(str10, 2, 4), "IsNumeric('50a00', 2, 4) does not return false!"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Remove() { ZString teststr("abcde"); // remove nonexistant character TASSERT( ZBasicStringAlgo::Remove(teststr, 'z') == ZSTL::InvalidPos, "Remove() claimed removal on nonpresent character!\n"); TASSERT(teststr.Length() == 5, "Remove() created wrong size string!\n"); // remove from front TASSERT( ZBasicStringAlgo::Remove(teststr, 'c') == 2, "Remove() claimed bad removal on existing character!\n"); TASSERT(teststr.Length() == 4, "Remove() created wrong size string!\n"); // remove from front TASSERT( ZBasicStringAlgo::Remove(teststr, 'a') == 0, "Remove() claimed bad removal on existing character\n"); TASSERT(teststr.Length() == 3, "Remove() created wrong size string!\n"); // remove from back TASSERT( ZBasicStringAlgo::Remove(teststr, 'e') == 2, "Remove() claimed bad removal on existing character\n"); TASSERT(teststr.Length() == 2, "Remove() created wrong size string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Remove_In_Region() { ZString teststr("abccddde"); // remove nonexistant character TASSERT( ZBasicStringAlgo::Remove(teststr, 'z',1,4) == ZSTL::InvalidPos, "Remove() claimed removal on nonpresent character!\n"); TASSERT(teststr.Length() == 8, "Remove() created wrong size string!\n"); // remove from back out of range TASSERT( ZBasicStringAlgo::Remove(teststr, 'd',1,4) == ZSTL::InvalidPos, "Remove() claimed removal on character not in region!\n"); TASSERT(teststr.Length() == 8, "Remove() created wrong size string!\n"); // remove from back TASSERT( ZBasicStringAlgo::Remove(teststr, 'c',1,4) == 2, "Remove() claimed bad removal on existing character!\n"); TASSERT(teststr.Length() == 7, "Remove() created wrong size string!\n"); // remove from front out of range TASSERT( ZBasicStringAlgo::Remove(teststr, 'a',1,4) == ZSTL::InvalidPos, "Remove() claimed removal on character not in region\n"); TASSERT(teststr.Length() == 7, "Remove() created wrong size string!\n"); // remove from front TASSERT( ZBasicStringAlgo::Remove(teststr, 'b', 1,4) == 1, "Remove() claimed bad removal on existing character\n"); TASSERT(teststr.Length() == 6, "Remove() created wrong size string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_RemoveAll() { ZString teststr("aaabcccdeeee"); // remove nonexistant character TASSERT( ZBasicStringAlgo::RemoveAll(teststr, 'z') == 0, "RemoveAll() claimed removal of nonpresent character!\n"); TASSERT(teststr.Length() == 12, "Remove() created wrong size string!\n"); // remove from front TASSERT( ZBasicStringAlgo::RemoveAll(teststr, 'c') == 3, "RemoveAll() claimed bad removal on existing character!\n"); TASSERT(teststr.Length() == 9, "Remove() created wrong size string!\n"); // remove from front TASSERT( ZBasicStringAlgo::RemoveAll(teststr, 'a') == 3, "RemoveAll() claimed bad removal on existing character\n"); TASSERT(teststr.Length() == 6, "Remove() created wrong size string!\n"); // remove from back TASSERT( ZBasicStringAlgo::RemoveAll(teststr, 'e') == 4, "RemoveAll() claimed bad removal on existing character\n"); TASSERT(teststr.Length() == 2, "Remove() created wrong size string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_RemoveAll_In_Region() { ZString teststr("aaabcccdeeee"); // remove nonexistant character TASSERT( ZBasicStringAlgo::RemoveAll(teststr, 'z', 1, 8) == 0, "RemoveAll() claimed removal of nonpresent character!\n"); TASSERT( teststr.Equals("aaabcccdeeee"), "RemoveAll() produced incorrect string!\n"); // remove from middle TASSERT( ZBasicStringAlgo::RemoveAll(teststr, 'c', 1, 8) == 3, "RemoveAll() claimed bad removal on existing character!\n"); TASSERT( teststr.Equals("aaabdeeee"), "RemoveAll() produced incorrect string!\n"); // remove from front TASSERT( ZBasicStringAlgo::RemoveAll(teststr, 'a', 1, 8) == 2, "RemoveAll() claimed bad removal on existing character\n"); TASSERT( teststr.Equals("abdeeee"), "RemoveAll() produced incorrect string!\n"); // remove from back TASSERT( ZBasicStringAlgo::RemoveAll(teststr, 'e', 1, 6) == 3, "RemoveAll() claimed bad removal on existing character\n"); TASSERT( teststr.Equals("abde"), "RemoveAll() produced incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_RemoveUpTo() { ZString teststr("aaabcccdeeee"); // remove nonexistent character TASSERT(ZBasicStringAlgo::RemoveUpTo(teststr, 'z', 1) == 0,"RemoveUpTo() removed nonexistent character!\n"); TASSERT( teststr.Equals("aaabcccdeeee"), "RemoveUpTo() produced incorrect string!\n"); // remove from middle TASSERT(ZBasicStringAlgo::RemoveUpTo(teststr, 'c', 2) == 2,"RemoveUpTo() removed incorrect amounts of character!\n"); TASSERT( teststr.Equals("aaabcdeeee"), "RemoveUpTo() produced incorrect string!\n"); // remove from front TASSERT(ZBasicStringAlgo::RemoveUpTo(teststr, 'a', 2) == 2,"RemoveUpTo() removed incorrect amounts of character!\n"); TASSERT( teststr.Equals("abcdeeee"), "RemoveUpTo() produced incorrect string!\n"); // remove from back TASSERT(ZBasicStringAlgo::RemoveUpTo(teststr, 'e', 4) == 4,"RemoveUpTo() removed incorrect amounts of character!\n"); TASSERT( teststr.Equals("abcd"), "RemoveUpTo() produced incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_RemoveUpTo_In_Region() { ZString teststr("aaabcccdeeee"); // remove nonexistent character TASSERT(ZBasicStringAlgo::RemoveUpTo(teststr, 'z', 1, 1, 8) == 0,"RemoveUpTo() removed nonexistent character!\n"); TASSERT( teststr.Equals("aaabcccdeeee"), "RemoveUpTo() produced incorrect string!\n"); // remove from outside region TASSERT(ZBasicStringAlgo::RemoveUpTo(teststr, 'e', 1, 1, 8) == 0,"RemoveUpTo() removed character from outside region!\n"); TASSERT( teststr.Equals("aaabcccdeeee"), "RemoveUpTo() produced incorrect string!\n"); // remove from middle TASSERT(ZBasicStringAlgo::RemoveUpTo(teststr, 'c', 2, 1, 8) == 2,"RemoveUpTo() removed incorrect amounts of character!\n"); TASSERT( teststr.Equals("aaabcdeeee"), "RemoveUpTo() produced incorrect string!\n"); // remove from front TASSERT(ZBasicStringAlgo::RemoveUpTo(teststr, 'a', 2, 1,8) == 2,"RemoveUpTo() removed incorrect amounts of character!\n"); TASSERT( teststr.Equals("abcdeeee"), "RemoveUpTo() produced incorrect string!\n"); // remove from back TASSERT(ZBasicStringAlgo::RemoveUpTo(teststr, 'e', 4,1,6) == 2,"RemoveUpTo() removed incorrect amounts of character!\n"); TASSERT( teststr.Equals("abcdee"), "RemoveUpTo() produced incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Replace() { ZString teststr("aabbcc"); // replace nothing ZBasicStringAlgo::Replace(teststr,'d','e'); TASSERT(teststr.Equals("aabbcc"), "Replace() failed to leave string with no replacements alone!\n"); // replace in middle ZBasicStringAlgo::Replace(teststr,'b','2'); TASSERT(teststr.Equals("aa22cc"),"Replace() failed to correctly replace chars in middle of string!\n"); // replace in back ZBasicStringAlgo::Replace(teststr,'a','1'); TASSERT(teststr.Equals("1122cc"),"Replace() failed to correctly replace chars in front of string!\n"); // replace in front ZBasicStringAlgo::Replace(teststr,'c','3'); TASSERT(teststr.Equals("112233"),"Replace() failed to correctly replace chars in middle of string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ #if 0 static const char* test_ReplaceSub() { // This function may need to be renamed. What it does is replace a substring of the hoststring with the substring of substr // marked by start and end size_t ZString hoststr("aabbcc"); ZString substr("abc"); // replace in front ZBasicStringAlgo::ReplaceSub(hoststr,0,3,substr,0,3); TASSERT(hoststr.Equals("abcbcc"), "Replace() failed to correctly replace chars in front of string!\n"); // replace in middle ZBasicStringAlgo::ReplaceSub(hoststr,1,4,substr,0,3); TASSERT(hoststr.Equals("aabccc"), "Replace() failed to correctly replace chars in middle of string!\n"); // replace in back ZBasicStringAlgo::ReplaceSub(hoststr,3,6,substr,0,3); TASSERT(hoststr.Equals("aababc"), "Replace() failed to correctly replace chars in end of string!\n"); // replace entire string ZString dullstring("zzzzzz"); ZBasicStringAlgo::ReplaceSub(hoststr,0,6,dullstring,0,6); TASSERT(hoststr.Equals("zzzzzz"), "Replace() failed to replace entire string with same length string!\n"); // replace entire string with shorter string hoststr = "abcabc"; ZBasicStringAlgo::ReplaceSub(hoststr,0,6,dullstring,0,3); TASSERT(hoststr.Equals("zzz"), "Replace() failed to replace entire string with shorter string!\n"); // replace entire string with longer string ZBasicStringAlgo::ReplaceSub(hoststr,0,3,dullstring,0,6); TASSERT(hoststr.Equals("zzzzzz"), "Replace() failed to replace entire string with longer string!\n"); return ZTEST_SUCCESS; } #endif /*************************************************************************/ static const char* test_Replace_In_Region() { ZString teststr("aabbcc"); // replace nothing ZBasicStringAlgo::Replace(teststr,'d','e',1,5); TASSERT(teststr.Equals("aabbcc"), "Replace() failed to leave string with no replacements alone!\n"); // replace in middle ZBasicStringAlgo::Replace(teststr,'b','2',1,5); TASSERT(teststr.Equals("aa22cc"),"Replace() failed to correctly replace chars in middle of string!\n"); // replace in back ZBasicStringAlgo::Replace(teststr,'a','1',1,5); TASSERT(teststr.Equals("a122cc"),"Replace() failed to correctly replace chars in front of string!\n"); // replace in front ZBasicStringAlgo::Replace(teststr,'c','3',1,5); TASSERT(teststr.Equals("a1223c"),"Replace() failed to correctly replace chars in middle of string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Reverse() { ZString testempty; ZString teststr("aabbcc"); // test reverse empty string ZBasicStringAlgo::Reverse(testempty); TASSERT(testempty.Equals(""), "Reverse() on empty string resulted in broken string!\n"); // test on normal string ZBasicStringAlgo::Reverse(teststr); TASSERT(teststr.Equals("ccbbaa"), "Reverse() created incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Reverse_Region() { ZString testempty; ZString teststr("aabbcc"); // test on normal string ZBasicStringAlgo::Reverse(teststr,1,5); TASSERT(teststr.Equals("acbbac"), "Reverse() created incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Slice() { ZString emptystr; ZString teststr("aaabbbccc"); ZString slice; // slice an empty string slice = ZBasicStringAlgo::Slice(emptystr,0,0); TASSERT(slice.Empty(), "Slice() on empty string returned nonempty slice!\n"); TASSERT(emptystr.Empty(), "Slice() on empy string returned nonempty remainder!\n"); // make an empty slice slice = ZBasicStringAlgo::Slice(teststr,0,0); TASSERT(slice.Empty(), "Zero-length Slice() on string returned wrong slice!\n"); TASSERT(teststr.Equals("aaabbbccc"), "Slice() on string returned wrong remainder!\n"); // make a whole-length slice slice = ZBasicStringAlgo::Slice(teststr,0,teststr.Length()); TASSERT(slice.Equals("aaabbbccc"), "Full-length Slice() on string returned wrong slice!\n"); TASSERT(teststr.Empty(), "Slice() on string returned wrong remainder!\n"); // slice off the back teststr = ZString("aaabbbccc"); slice = ZBasicStringAlgo::Slice(teststr,3,teststr.Length()); TASSERT(slice.Equals("bbbccc"), "Slice() on string returned wrong slice!\n"); TASSERT(teststr.Equals("aaa"), "Slice() on string returned wrong remainder!\n"); // slice off the front teststr = ZString("aaabbbccc"); slice = ZBasicStringAlgo::Slice(teststr, 0, 3); TASSERT(slice.Equals("aaa"), "Slice() on string returned wrong slice!\n"); TASSERT(teststr.Equals("bbbccc"), "Slice() on string returned wrong remainder!\n"); // slice off the middle teststr = ZString("aaabbbccc"); slice = ZBasicStringAlgo::Slice(teststr, 3, 6); TASSERT(slice.Equals("bbb"), "Slice() on string returned wrong slice!\n"); TASSERT(teststr.Equals("aaaccc"), "Slice() on string returned wrong remainder!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Split() { ZString emptystr; ZString teststr; ZArray< ZString > ret; // test on empty string ret = ZBasicStringAlgo::Split(emptystr, ",;"); TASSERT(ret.Empty(), "Split() created nonempty array for empty string!\n"); // test on legit string with no delimiters on ends teststr = ZString("aaa,bbb;ccc;ddd,eee"); ret = ZBasicStringAlgo::Split(teststr, ",;"); TASSERT(teststr.Equals("aaa,bbb;ccc;ddd,eee"), "Split() harmed underlying string!\n"); TASSERT(ret.Size() == 5, "Split() created array of wrong size for string!\n"); TASSERT(ret.At(0).Equals("aaa"), "Split() created wrong string for section!\n"); TASSERT(ret.At(1).Equals("bbb"), "Split() created wrong string for section!\n"); TASSERT(ret.At(2).Equals("ccc"), "Split() created wrong string for section!\n"); TASSERT(ret.At(3).Equals("ddd"), "Split() created wrong string for section!\n"); TASSERT(ret.At(4).Equals("eee"), "Split() created wrong string for section!\n"); // test on legit string with extra delimiters teststr = ZString(",aaa,bbb;ccc;"); ret = ZBasicStringAlgo::Split(teststr, ",;"); TASSERT(teststr.Equals(",aaa,bbb;ccc;"), "Split() harmed underlying string!\n"); TASSERT(ret.Size() == 3, "Split() created array of wrong size for string!\n"); TASSERT(ret.At(0).Equals("aaa"), "Split() created wrong string for section!\n"); TASSERT(ret.At(1).Equals("bbb"), "Split() created wrong string for section!\n"); TASSERT(ret.At(2).Equals("ccc"), "Split() created wrong string for section!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Split_Count() { ZString emptystr; ZString teststr; ZArray< ZString > ret; // test on legit string with no delimiters on ends teststr = ZString("aaa,bbb;ccc;ddd,eee"); ret = ZBasicStringAlgo::Split(teststr, ",;", 2); TASSERT(teststr.Equals("aaa,bbb;ccc;ddd,eee"), "Split() harmed underlying string!\n"); TASSERT(ret.Size() == 3, "Split() created array of wrong size for string!\n"); TASSERT(ret.At(0).Equals("aaa"), "Split() created wrong string for section!\n"); TASSERT(ret.At(1).Equals("bbb"), "Split() created wrong string for section!\n"); TASSERT(ret.At(2).Equals("ccc;ddd,eee"), "Split() created wrong string for section!\n"); // test on legit string with extra delimiters teststr = ZString(",aaa,bbb;;;ccc;"); ret = ZBasicStringAlgo::Split(teststr, ",;", 2); TASSERT(teststr.Equals(",aaa,bbb;;;ccc;"), "Split() harmed underlying string!\n"); TASSERT(ret.Size() == 3, "Split() created array of wrong size for string given count!\n"); TASSERT(ret.At(0).Equals("aaa"), "Split() created wrong string for section!\n"); TASSERT(ret.At(1).Equals("bbb"), "Split() created wrong string for section!\n"); // note that the below is expected because we had finished our two splits and stopped looking for delimiters TASSERT(ret.At(2).Equals(";;ccc;"), "Split() created wrong string for section!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Split_Count_Region() { ZString emptystr; ZString teststr; ZArray< ZString > ret; // test on legit string with no delimiters on ends teststr = ZString("aaa,bbb;ccc;ddd,eee"); ret = ZBasicStringAlgo::Split(teststr, ",;", 2, 5, teststr.Length() - 1); TASSERT(teststr.Equals("aaa,bbb;ccc;ddd,eee"), "Split() harmed underlying string!\n"); TASSERT(ret.Size() == 3, "Split() created array of wrong size for string!\n"); TASSERT(ret.At(0).Equals("bb"), "Split() created wrong string for section!\n"); TASSERT(ret.At(1).Equals("ccc"), "Split() created wrong string for section!\n"); TASSERT(ret.At(2).Equals("ddd,ee"), "Split() created wrong string for section!\n"); // test on legit string with extra delimiters teststr = ZString(",aaa,bbb;ccc;"); ret = ZBasicStringAlgo::Split(teststr, ",;", 2, 3, teststr.Length()-2); TASSERT(teststr.Equals(",aaa,bbb;ccc;"), "Split() harmed underlying string!\n"); TASSERT(ret.Size() == 3, "Split() created array of wrong size for string given count!\n"); TASSERT(ret.At(0).Equals("a"), "Split() created wrong string for section!\n"); TASSERT(ret.At(1).Equals("bbb"), "Split() created wrong string for section!\n"); TASSERT(ret.At(2).Equals("cc"), "Split() created wrong string for section!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_StartsWith() { ZString testempty; ZString teststr("aaabbbccc"); // empty string with empty startstring TASSERT( ZBasicStringAlgo::StartsWith(testempty, "") == false, "StartsWith() claimed empty string started with empty string!"); // empty string with empty startstring TASSERT( ZBasicStringAlgo::StartsWith(testempty, "aaa") == false, "StartsWith() claimed empty string started with nonempty string!"); // string with empty startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr, "") == false, "StartsWith() claimed string started with empty string!\n"); // string with wrong startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr, "bbbb") == false, "StartsWith() claimed string started with empty string!\n"); // string with truncated startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr, "aa") == true, "StartsWith() claimed string not started with truncated string!\n"); // string with overlong startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr, "aaaa") == false, "StartsWith() claimed string started with overlong string!\n"); // string with correct startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr,"aaa") == true, "StartsWith() failed to match start string correctly!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_StartsWith_Region() { ZString testempty; ZString teststr("aaabbbccc"); // empty string with empty startstring TASSERT( ZBasicStringAlgo::StartsWith(testempty, 0, testempty.Length(), "", 0, 0) == false, "StartsWith() claimed empty string started with empty string!"); // empty string with empty startstring TASSERT( ZBasicStringAlgo::StartsWith(testempty, 0, testempty.Length(), "aaaa", 1, 3) == false, "StartsWith() claimed empty string started with nonempty string!"); // string with empty startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr, 1, teststr.Length(), "", 0, 0) == false, "StartsWith() claimed string started with empty string!\n"); // string with wrong startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr, 1, teststr.Length(), "bbbb", 1, 3) == false, "StartsWith() claimed string started with empty string!\n"); // string with truncated startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr, 1, teststr.Length(), "aaaa", 1, 2) == true, "StartsWith() claimed string not started with truncated string!\n"); // string with overlong startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr, 1, teststr.Length(), "aaaa", 1, 4) == false, "StartsWith() claimed string started with overlong string!\n"); // string with correct startstring TASSERT( ZBasicStringAlgo::StartsWith(teststr, 1, teststr.Length(), "aaaa", 1, 3) == true, "StartsWith() failed to match start string correctly!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Strip() { ZString testempty; ZString teststr(" ab\t\t c d "); TASSERT(ZBasicStringAlgo::Strip(testempty) == 0, "Strip() attempted to remove characters from empty string!\n"); TASSERT(testempty.Equals(""), "Strip() broke empty string!\n"); TASSERT(ZBasicStringAlgo::Strip(teststr) == 7, "Strip() removed wrong number of characters!\n"); TASSERT(teststr.Equals("abcd"), "Strip() created wrong string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Strip_Region() { ZString testempty; ZString teststr(" ab\t\t c d "); TASSERT(ZBasicStringAlgo::Strip(testempty ,0 ,0) == 0, "Strip() attempted to remove characters from empty string!\n"); TASSERT(testempty.Equals(""), "Strip() broke empty string!\n"); TASSERT(ZBasicStringAlgo::Strip(teststr, 1, 10) == 5, "Strip() removed wrong number of characters!\n"); TASSERT(teststr.Equals(" abcd "), "Strip() created wrong string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Tokenize() { ZString testempty; ZString testcsv(",a,b,c,d,"); ZString tok; // check empty string tok = ZBasicStringAlgo::Tokenize(testempty,","); TASSERT(tok.Empty(),"Tokenize() on empty string returned nonempty string!\n"); // check empty delimiter string tok = ZBasicStringAlgo::Tokenize(testcsv, ""); TASSERT( tok.Equals(",a,b,c,d,"), "Tokenize() with empty delimiters returned wrong string!\n"); TASSERT( testcsv.Empty(), "Tokenize() with empty delimiters did not consume whole string!\n"); // check delimited string testcsv = ZString(",a,b,c,d,"); tok = ZBasicStringAlgo::Tokenize(testcsv,","); TASSERT(tok.Equals(""),"Tokenize() produced wrong token!\n"); TASSERT(testcsv.Equals("a,b,c,d,"),"Tokenize() produced wrong remainder!\n"); tok = ZBasicStringAlgo::Tokenize(testcsv,","); TASSERT(tok.Equals("a"),"Tokenize() produced wrong token!\n"); TASSERT(testcsv.Equals("b,c,d,"),"Tokenize() produced wrong remainder!\n"); tok = ZBasicStringAlgo::Tokenize(testcsv,","); TASSERT(tok.Equals("b"),"Tokenize() produced wrong token!\n"); TASSERT(testcsv.Equals("c,d,"),"Tokenize() produced wrong remainder!\n"); tok = ZBasicStringAlgo::Tokenize(testcsv,","); TASSERT(tok.Equals("c"),"Tokenize() produced wrong token!\n"); TASSERT(testcsv.Equals("d,"),"Tokenize() produced wrong remainder!\n"); tok = ZBasicStringAlgo::Tokenize(testcsv,","); TASSERT(tok.Equals("d"),"Tokenize() produced wrong token!\n"); TASSERT(testcsv.Equals(""),"Tokenize() produced wrong remainder!\n"); // check delimited empty strings testcsv = ZString(",,;;"); tok = ZBasicStringAlgo::Tokenize(testcsv,",;"); TASSERT(tok.Equals(""),"Tokenize() produced wrong token!\n"); TASSERT(testcsv.Equals(",;;"),"Tokenize() produced wrong remainder!\n"); tok = ZBasicStringAlgo::Tokenize(testcsv,",;"); TASSERT(tok.Equals(""),"Tokenize() produced wrong token!\n"); TASSERT(testcsv.Equals(";;"),"Tokenize() produced wrong remainder!\n"); tok = ZBasicStringAlgo::Tokenize(testcsv,",;"); TASSERT(tok.Equals(""),"Tokenize() produced wrong token!\n"); TASSERT(testcsv.Equals(";"),"Tokenize() produced wrong remainder!\n"); tok = ZBasicStringAlgo::Tokenize(testcsv,",;"); TASSERT(tok.Equals(""),"Tokenize() produced wrong token!\n"); TASSERT(testcsv.Equals(""),"Tokenize() produced wrong remainder!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_ToLower() { ZString testempty; ZString teststr("AaBbCc"); ZBasicStringAlgo::ToLower(testempty); TASSERT(testempty.Equals(""), "ToLower() produced bad result on empty string!\n"); ZBasicStringAlgo::ToLower(teststr); TASSERT(teststr.Equals("aabbcc"), "ToLower() produced bad result on mixed string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_ToLower_Region() { ZString testempty; ZString teststr("AaBbCcDdEe"); ZBasicStringAlgo::ToLower(testempty,0,0); TASSERT(testempty.Equals(""), "ToLower() produced bad result on empty string!\n"); ZBasicStringAlgo::ToLower(teststr,2,8); TASSERT(teststr.Equals("AabbccddEe"), "ToLower() produced bad result on mixed string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_ToUpper() { ZString testempty; ZString teststr("AaBbCc"); ZBasicStringAlgo::ToUpper(testempty); TASSERT(testempty.Equals(""), "ToUpper() produced bad result on empty string!\n"); ZBasicStringAlgo::ToUpper(teststr); TASSERT(teststr.Equals("AABBCC"), "ToUpper() produced bad result on mixed string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_ToUpper_Region() { ZString testempty; ZString teststr("AaBbCcDdEe"); ZBasicStringAlgo::ToUpper(testempty,0,0); TASSERT(testempty.Equals(""), "ToUpper() produced bad result on empty string!\n"); ZBasicStringAlgo::ToUpper(teststr,2,8); TASSERT(teststr.Equals("AaBBCCDDEe"), "ToUpper() produced bad result on mixed string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_TrimLeft() { ZString testempty; ZString teststr(" test "); TASSERT(ZBasicStringAlgo::TrimLeft(testempty) == 0, "TrimLeft() removed nonzero characters from empty string!"); TASSERT(testempty.Empty(), "TrimLeft() broke empty string!\n"); TASSERT(ZBasicStringAlgo::TrimLeft(teststr) == 2, "TrimLeft() removed wrong number of characters!\n"); TASSERT(teststr.Equals("test "), "TrimLeft() produced incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_TrimLeft_Region() { ZString testempty; ZString teststr(" test "); TASSERT(ZBasicStringAlgo::TrimLeft(testempty,0,0) == 0, "TrimLeft() removed nonzero characters from empty string!"); TASSERT(testempty.Empty(), "TrimLeft() broke empty string!\n"); TASSERT(ZBasicStringAlgo::TrimLeft(teststr,1,7) == 1, "TrimLeft() removed wrong number of characters!\n"); TASSERT(teststr.Equals(" test "), "TrimLeft() produced incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_TrimRight() { ZString testempty; ZString teststr(" test "); TASSERT(ZBasicStringAlgo::TrimRight(testempty) == 0, "TrimRight() removed nonzero characters from empty string!"); TASSERT(testempty.Empty(), "TrimRight() broke empty string!\n"); TASSERT(ZBasicStringAlgo::TrimRight(teststr) == 2, "TrimRight() removed wrong number of characters!\n"); TASSERT(teststr.Equals(" test"), "TrimRight() produced incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_TrimRight_Region() { ZString testempty; ZString teststr(" test "); TASSERT(ZBasicStringAlgo::TrimRight(testempty,0,0) == 0, "TrimRight() removed nonzero characters from empty string!"); TASSERT(testempty.Empty(), "TrimRight() broke empty string!\n"); TASSERT(ZBasicStringAlgo::TrimRight(teststr,1,7) == 1, "TrimRight() removed wrong number of characters!\n"); TASSERT(teststr.Equals(" test "), "TrimRight() produced incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Trim() { ZString testempty; ZString teststr(" test "); TASSERT(ZBasicStringAlgo::Trim(testempty) == 0, "Trim() removed nonzero characters from empty string!"); TASSERT(testempty.Empty(), "Trim() broke empty string!\n"); TASSERT(ZBasicStringAlgo::Trim(teststr) == 4, "Trim() removed wrong number of characters!\n"); TASSERT(teststr.Equals("test"), "Trim() produced incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/ static const char* test_Trim_Region() { ZString testempty; ZString teststr(" test "); TASSERT(ZBasicStringAlgo::Trim(testempty,0,0) == 0, "Trim() removed nonzero characters from empty string!"); TASSERT(testempty.Empty(), "Trim() broke empty string!\n"); TASSERT(ZBasicStringAlgo::Trim(teststr,1,7) == 2, "Trim() removed wrong number of characters!\n"); TASSERT(teststr.Equals(" test "), "Trim() produced incorrect string!\n"); return ZTEST_SUCCESS; } /*************************************************************************/