From 3cdfcb19d4a79201ded24d232ad08159389efe08 Mon Sep 17 00:00:00 2001 From: Daniel Buckmaster Date: Tue, 15 Jul 2014 14:46:27 +0200 Subject: [PATCH] Ported string tests. --- Engine/source/core/util/test/strTest.cpp | 332 ++++++++++++++++++ Engine/source/core/util/test/testString.cpp | 358 -------------------- 2 files changed, 332 insertions(+), 358 deletions(-) create mode 100644 Engine/source/core/util/test/strTest.cpp delete mode 100644 Engine/source/core/util/test/testString.cpp diff --git a/Engine/source/core/util/test/strTest.cpp b/Engine/source/core/util/test/strTest.cpp new file mode 100644 index 000000000..3bb381d56 --- /dev/null +++ b/Engine/source/core/util/test/strTest.cpp @@ -0,0 +1,332 @@ +//----------------------------------------------------------------------------- +// Copyright (c) 2014 GarageGames, LLC +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +// IN THE SOFTWARE. +//----------------------------------------------------------------------------- + +#ifdef TORQUE_TESTS_ENABLED +#include "testing/unitTesting.h" +#include "core/util/str.h" +#include "core/util/tVector.h" +#include "core/strings/stringFunctions.h" +#include "core/strings/unicode.h" + +/// This is called Str, not String, because googletest doesn't let you use both +/// TEST(x) and TEST_FIX(x). So this fixture is called Str, to match the StrTest +/// struct, and the remaining fixture-les tests are named String. +FIXTURE(Str) +{ +protected: + struct StrTest + { + const UTF8* mData; + const UTF16* mUTF16; + U32 mLength; + + StrTest() : mData( 0 ), mUTF16( 0 ) {} + StrTest( const char* str ) + : mData( str ), mLength( str ? dStrlen( str ) : 0 ), mUTF16( NULL ) + { + if( str ) + mUTF16 = convertUTF8toUTF16( mData ); + } + ~StrTest() + { + if( mUTF16 ) + delete [] mUTF16; + } + }; + + Vector< StrTest* > mStrings; + + virtual void SetUp() + { + mStrings.push_back( new StrTest( NULL ) ); + mStrings.push_back( new StrTest( "" ) ); + mStrings.push_back( new StrTest( "Torque" ) ); + mStrings.push_back( new StrTest( "TGEA" ) ); + mStrings.push_back( new StrTest( "GarageGames" ) ); + mStrings.push_back( new StrTest( "TGB" ) ); + mStrings.push_back( new StrTest( "games" ) ); + mStrings.push_back( new StrTest( "engine" ) ); + mStrings.push_back( new StrTest( "rocks" ) ); + mStrings.push_back( new StrTest( "technology" ) ); + mStrings.push_back( new StrTest( "Torque 3D" ) ); + mStrings.push_back( new StrTest( "Torque 2D" ) ); + } + + virtual void TearDown() + { + for( U32 i = 0; i < mStrings.size(); ++ i ) + delete mStrings[ i ]; + mStrings.clear(); + } +}; + +#define EACH_STRING(i) \ + for( U32 i = 0; i < mStrings.size(); ++ i ) +#define EACH_PAIR(i, j) \ + for( U32 i = 0; i < mStrings.size(); ++ i ) \ + for( U32 j = 0; j < mStrings.size(); ++ j ) + +TEST_FIX(Str, Test1) +{ + EACH_STRING(i) + { + StrTest& data = *mStrings[i]; + String str( data.mData ); + String str16( data.mUTF16 ); + + EXPECT_TRUE( str.length() == data.mLength ); + EXPECT_TRUE( str.size() == data.mLength + 1 ); + EXPECT_TRUE( str.isEmpty() || str.length() > 0 ); + EXPECT_TRUE( str.length() == str16.length() ); + EXPECT_TRUE( str.size() == str16.size() ); + + EXPECT_TRUE( dMemcmp( str.utf16(), str16.utf16(), str.length() * sizeof( UTF16 ) ) == 0 ); + EXPECT_TRUE( !data.mData || dMemcmp( str.utf16(), data.mUTF16, str.length() * sizeof( UTF16 ) ) == 0 ); + EXPECT_TRUE( !data.mData || dMemcmp( str16.utf8(), data.mData, str.length() ) == 0 ); + + EXPECT_TRUE( !data.mData || dStrcmp( str.utf8(), data.mData ) == 0 ); + EXPECT_TRUE( !data.mData || dStrcmp( str.utf16(), data.mUTF16 ) == 0 ); + } +} + +TEST_FIX(Str, Test2) +{ + EACH_STRING(i) + { + StrTest& data = *mStrings[i]; + String str( data.mData ); + + EXPECT_TRUE( str == str ); + EXPECT_FALSE( str != str ); + EXPECT_FALSE( str < str ); + EXPECT_FALSE( str > str ); + EXPECT_TRUE( str.equal( str ) ); + EXPECT_TRUE( str.equal( str, String::NoCase ) ); + } +} + +TEST_FIX(Str, Test3) +{ + EACH_PAIR(i, j) + { + StrTest& d1 = *mStrings[i]; + StrTest& d2 = *mStrings[j]; + + if( &d1 != &d2 ) + EXPECT_TRUE( String( d1.mData ) != String( d2.mData ) + || ( String( d1.mData ).isEmpty() && String( d2.mData ).isEmpty() ) ); + else + EXPECT_TRUE( String( d1.mData ) == String( d2.mData ) ); + } +} + +TEST(String, Empty) +{ + EXPECT_TRUE( String().length() == 0 ); + EXPECT_TRUE( String( "" ).length() == 0 ); + EXPECT_TRUE( String().size() == 1 ); + EXPECT_TRUE( String( "" ).size() == 1 ); + EXPECT_TRUE( String().isEmpty() ); + EXPECT_TRUE( String( "" ).isEmpty() ); +} + +TEST(String, Trim) +{ + EXPECT_TRUE( String( " Foobar Barfoo \n\t " ).trim() == String( "Foobar Barfoo" ) ); + EXPECT_TRUE( String( "Foobar" ).trim() == String( "Foobar" ) ); + EXPECT_TRUE( String( " " ).trim().isEmpty() ); +} + +TEST(String, Compare) +{ + String str( "Foobar" ); + + EXPECT_TRUE( str.compare( "Foo", 3 ) == 0 ); + EXPECT_TRUE( str.compare( "bar", 3, String::NoCase | String::Right ) == 0 ); + EXPECT_TRUE( str.compare( "foo", 3, String::NoCase ) == 0 ); + EXPECT_TRUE( str.compare( "BAR", 3, String::NoCase | String::Right ) == 0 ); + EXPECT_TRUE( str.compare( "Foobar" ) == 0 ); + EXPECT_TRUE( str.compare( "Foo" ) != 0 ); + EXPECT_TRUE( str.compare( "foobar", 0, String::NoCase ) == 0 ); + EXPECT_TRUE( str.compare( "FOOBAR", 0, String::NoCase ) == 0 ); + EXPECT_TRUE( str.compare( "Foobar", 0, String::Right ) == 0 ); + EXPECT_TRUE( str.compare( "foobar", 0, String::NoCase | String::Right ) == 0 ); +} + +TEST(String, Order) +{ + Vector< String > strs; + + strs.push_back( "a" ); + strs.push_back( "a0" ); + strs.push_back( "a1" ); + strs.push_back( "a1a" ); + strs.push_back( "a1b" ); + strs.push_back( "a2" ); + strs.push_back( "a10" ); + strs.push_back( "a20" ); + + for( U32 i = 0; i < strs.size(); ++ i ) + { + for( U32 j = 0; j < i; ++ j ) + { + EXPECT_TRUE( strs[ j ] < strs[ i ] ); + EXPECT_TRUE( strs[ i ] > strs[ j ] ); + + EXPECT_TRUE( !( strs[ j ] > strs[ i ] ) ); + EXPECT_TRUE( !( strs[ i ] < strs[ i ] ) ); + + EXPECT_TRUE( strs[ j ] <= strs[ i ] ); + EXPECT_TRUE( strs[ i ] >= strs[ j ] ); + } + + EXPECT_TRUE( !( strs[ i ] < strs[ i ] ) ); + EXPECT_TRUE( !( strs[ i ] > strs[ i ] ) ); + EXPECT_TRUE( strs[ i ] <= strs[ i ] ); + EXPECT_TRUE( strs[ i ] >= strs[ i ] ); + + for( U32 j = i + 1; j < strs.size(); ++ j ) + { + EXPECT_TRUE( strs[ j ] > strs[ i ] ); + EXPECT_TRUE( strs[ i ] < strs[ j ] ); + + EXPECT_TRUE( !( strs[ j ] < strs[ i ] ) ); + EXPECT_TRUE( !( strs[ i ] > strs[ j ] ) ); + + EXPECT_TRUE( strs[ j ] >= strs[ i ] ); + EXPECT_TRUE( strs[ i ] <= strs[ j ] ); + } + } +} + +/// TODO +TEST(String, Find) +{ +} + +TEST(String, Insert) +{ + // String.insert( Pos, Char ) + EXPECT_TRUE( String( "aa" ).insert( 1, 'c' ) == String( "aca" ) ); + + // String.insert( Pos, String ) + EXPECT_TRUE( String( "aa" ).insert( 1, "cc" ) == String( "acca" ) ); + EXPECT_TRUE( String( "aa" ).insert( 1, String( "cc" ) ) == String( "acca" ) ); + + // String.insert( Pos, String, Len ) + EXPECT_TRUE( String( "aa" ).insert( 1, "ccdddd", 2 ) == String( "acca" ) ); +} + +TEST(String, Erase) +{ + EXPECT_TRUE( String( "abba" ).erase( 1, 2 ) == String( "aa" ) ); + EXPECT_TRUE( String( "abba" ).erase( 0, 4 ).isEmpty() ); +} + +TEST(String, Replace) +{ + // String.replace( Pos, Len, String ) + EXPECT_TRUE( String( "abba" ).replace( 1, 2, "ccc" ) == String( "accca" ) ); + EXPECT_TRUE( String( "abba" ).replace( 1, 2, String( "ccc" ) ) == String( "accca" ) ); + EXPECT_TRUE( String( "abba" ).replace( 0, 4, "" ).isEmpty() ); + EXPECT_TRUE( String( "abba" ).replace( 2, 2, "c" ) == String( "abc" ) ); + + // String.replace( Char, Char ) + EXPECT_TRUE( String().replace( 'a', 'b' ).isEmpty() ); + EXPECT_TRUE( String( "ababc" ).replace( 'a', 'b' ) == String( "bbbbc" ) ); + EXPECT_TRUE( String( "ababc" ).replace( 'd', 'e' ) == String( "ababc" ) ); + + // String.replace( String, String ) + EXPECT_TRUE( String().replace( "foo", "bar" ).isEmpty() ); + EXPECT_TRUE( String( "foobarfoo" ).replace( "foo", "bar" ) == String( "barbarbar" ) ); + EXPECT_TRUE( String( "foobar" ).replace( "xx", "yy" ) == String( "foobar" ) ); + EXPECT_TRUE( String( "foofoofoo" ).replace( "foo", "" ).isEmpty() ); +} + +TEST(String, SubStr) +{ + EXPECT_TRUE( String( "foobar" ).substr( 0, 3 ) == String( "foo" ) ); + EXPECT_TRUE( String( "foobar" ).substr( 3 ) == String( "bar" ) ); + EXPECT_TRUE( String( "foobar" ).substr( 2, 2 ) == String( "ob" ) ); + EXPECT_TRUE( String( "foobar" ).substr( 2, 0 ).isEmpty() ); + EXPECT_TRUE( String( "foobar" ).substr( 0, 6 ) == String( "foobar" ) ); +} + +TEST(String, ToString) +{ + EXPECT_TRUE( String::ToString( U32( 1 ) ) == String( "1" ) ); + EXPECT_TRUE( String::ToString( S32( -1 ) ) == String( "-1" ) ); + EXPECT_TRUE( String::ToString( F32( 1.01 ) ) == String( "1.01" ) ); + EXPECT_TRUE( String::ToString( "%s%i", "foo", 1 ) == String( "foo1" ) ); +} + +TEST(String, CaseConversion) +{ + EXPECT_TRUE( String::ToLower( "foobar123." ) == String( "foobar123." ) ); + EXPECT_TRUE( String::ToLower( "FOOBAR123." ) == String( "foobar123." ) ); + EXPECT_TRUE( String::ToUpper( "barfoo123." ) == String( "BARFOO123." ) ); + EXPECT_TRUE( String::ToUpper( "BARFOO123." ) == String( "BARFOO123." ) ); +} + +TEST(String, Concat) +{ + EXPECT_TRUE( String( "foo" ) + String( "bar" ) == String( "foobar" ) ); + EXPECT_TRUE( String() + String( "bar" ) == String( "bar" ) ); + EXPECT_TRUE( String( "foo" ) + String() == String( "foo" ) ); + EXPECT_TRUE( String() + String() == String() ); + EXPECT_TRUE( String( "fo" ) + 'o' == String( "foo" ) ); + EXPECT_TRUE( 'f' + String( "oo" ) == String( "foo" ) ); + EXPECT_TRUE( String( "foo" ) + "bar" == String( "foobar" ) ); + EXPECT_TRUE( "foo" + String( "bar" ) == String( "foobar" ) ); +} + +TEST(String, Hash) +{ + EXPECT_TRUE( String( "foo" ).getHashCaseSensitive() == String( "foo" ).getHashCaseSensitive() ); + EXPECT_TRUE( String( "foo" ).getHashCaseSensitive() != String( "bar" ).getHashCaseSensitive() ); + EXPECT_TRUE( String( "foo" ).getHashCaseInsensitive() == String( "FOO" ).getHashCaseInsensitive() ); +} + +TEST(String, Intern) +{ + EXPECT_TRUE( String( "foo" ).intern().isSame( String( "foo" ).intern() ) ); + EXPECT_TRUE( !String( "foo" ).intern().isSame( String( "bar" ).intern() ) ); + EXPECT_TRUE( !String( "foo" ).intern().isSame( String( "Foo" ).intern() ) ); + EXPECT_TRUE( String( "foo" ).intern() == String( "foo" ).intern() ); + EXPECT_TRUE( String( "foo" ).intern() != String( "bar" ).intern() ); + EXPECT_TRUE( String( "foo" ).intern().isInterned() ); +} + +TEST(StringBuilder, StringBuilder) +{ + StringBuilder str; + + str.append( 'f' ); + str.append( "oo" ); + str.append( String( "ba" ) ); + str.append( "rfajskfdj", 1 ); + str.format( "%s", "barfoo" ); + + EXPECT_TRUE( str.end() == String( "foobarbarfoo" ) ); +} + +#endif diff --git a/Engine/source/core/util/test/testString.cpp b/Engine/source/core/util/test/testString.cpp deleted file mode 100644 index 33c6ea6d4..000000000 --- a/Engine/source/core/util/test/testString.cpp +++ /dev/null @@ -1,358 +0,0 @@ -//----------------------------------------------------------------------------- -// Copyright (c) 2012 GarageGames, LLC -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to -// deal in the Software without restriction, including without limitation the -// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -// sell copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -// IN THE SOFTWARE. -//----------------------------------------------------------------------------- - -#include "unit/test.h" -#include "core/util/str.h" -#include "core/util/tVector.h" -#include "core/strings/stringFunctions.h" -#include "core/strings/unicode.h" - - -#ifndef TORQUE_SHIPPING - -using namespace UnitTesting; - -#define TEST( x ) test( ( x ), "FAIL: " #x ) -#define XTEST( t, x ) t->test( ( x ), "FAIL: " #x ) - -CreateUnitTest( TestString, "Util/String" ) -{ - struct StrTest - { - const UTF8* mData; - const UTF16* mUTF16; - U32 mLength; - - StrTest() : mData( 0 ), mUTF16( 0 ) {} - StrTest( const char* str ) - : mData( str ), mLength( str ? dStrlen( str ) : 0 ), mUTF16( NULL ) - { - if( str ) - mUTF16 = convertUTF8toUTF16( mData ); - } - ~StrTest() - { - if( mUTF16 ) - delete [] mUTF16; - } - }; - - Vector< StrTest* > mStrings; - - template< class T > - void runTestOnStrings() - { - for( U32 i = 0; i < mStrings.size(); ++ i ) - T::run( this, *mStrings[ i ] ); - } - template< class T > - void runPairwiseTestOnStrings() - { - for( U32 i = 0; i < mStrings.size(); ++ i ) - for( U32 j = 0; j < mStrings.size(); ++ j ) - T::run( this, *mStrings[ i ], *mStrings[ j ] ); - } - - struct Test1 - { - static void run( TestString* test, StrTest& data ) - { - String str( data.mData ); - String str16( data.mUTF16 ); - - XTEST( test, str.length() == data.mLength ); - XTEST( test, str.size() == data.mLength + 1 ); - XTEST( test, str.isEmpty() || str.length() > 0 ); - XTEST( test, str.length() == str16.length() ); - XTEST( test, str.size() == str16.size() ); - - XTEST( test, dMemcmp( str.utf16(), str16.utf16(), str.length() * sizeof( UTF16 ) ) == 0 ); - XTEST( test, !data.mData || dMemcmp( str.utf16(), data.mUTF16, str.length() * sizeof( UTF16 ) ) == 0 ); - XTEST( test, !data.mData || dMemcmp( str16.utf8(), data.mData, str.length() ) == 0 ); - - XTEST( test, !data.mData || dStrcmp( str.utf8(), data.mData ) == 0 ); - XTEST( test, !data.mData || dStrcmp( str.utf16(), data.mUTF16 ) == 0 ); - } - }; - - struct Test2 - { - static void run( TestString* test, StrTest& data ) - { - String str( data.mData ); - - XTEST( test, str == str ); - XTEST( test, !( str != str ) ); - XTEST( test, !( str < str ) ); - XTEST( test, !( str > str ) ); - XTEST( test, str.equal( str ) ); - XTEST( test, str.equal( str, String::NoCase ) ); - } - }; - - struct Test3 - { - static void run( TestString* test, StrTest& d1, StrTest& d2 ) - { - if( &d1 != &d2 ) - XTEST( test, String( d1.mData ) != String( d2.mData ) - || ( String( d1.mData ).isEmpty() && String( d2.mData ).isEmpty() ) ); - else - XTEST( test, String( d1.mData ) == String( d2.mData ) ); - } - }; - - void testEmpty() - { - TEST( String().length() == 0 ); - TEST( String( "" ).length() == 0 ); - TEST( String().size() == 1 ); - TEST( String( "" ).size() == 1 ); - TEST( String().isEmpty() ); - TEST( String( "" ).isEmpty() ); - } - - void testTrim() - { - TEST( String( " Foobar Barfoo \n\t " ).trim() == String( "Foobar Barfoo" ) ); - TEST( String( "Foobar" ).trim() == String( "Foobar" ) ); - TEST( String( " " ).trim().isEmpty() ); - } - - void testCompare() - { - String str( "Foobar" ); - - TEST( str.compare( "Foo", 3 ) == 0 ); - TEST( str.compare( "bar", 3, String::NoCase | String::Right ) == 0 ); - TEST( str.compare( "foo", 3, String::NoCase ) == 0 ); - TEST( str.compare( "BAR", 3, String::NoCase | String::Right ) == 0 ); - TEST( str.compare( "Foobar" ) == 0 ); - TEST( str.compare( "Foo" ) != 0 ); - TEST( str.compare( "foobar", 0, String::NoCase ) == 0 ); - TEST( str.compare( "FOOBAR", 0, String::NoCase ) == 0 ); - TEST( str.compare( "Foobar", 0, String::Right ) == 0 ); - TEST( str.compare( "foobar", 0, String::NoCase | String::Right ) == 0 ); - } - - void testOrder() - { - Vector< String > strs; - - strs.push_back( "a" ); - strs.push_back( "a0" ); - strs.push_back( "a1" ); - strs.push_back( "a1a" ); - strs.push_back( "a1b" ); - strs.push_back( "a2" ); - strs.push_back( "a10" ); - strs.push_back( "a20" ); - - for( U32 i = 0; i < strs.size(); ++ i ) - { - for( U32 j = 0; j < i; ++ j ) - { - TEST( strs[ j ] < strs[ i ] ); - TEST( strs[ i ] > strs[ j ] ); - - TEST( !( strs[ j ] > strs[ i ] ) ); - TEST( !( strs[ i ] < strs[ i ] ) ); - - TEST( strs[ j ] <= strs[ i ] ); - TEST( strs[ i ] >= strs[ j ] ); - } - - TEST( !( strs[ i ] < strs[ i ] ) ); - TEST( !( strs[ i ] > strs[ i ] ) ); - TEST( strs[ i ] <= strs[ i ] ); - TEST( strs[ i ] >= strs[ i ] ); - - for( U32 j = i + 1; j < strs.size(); ++ j ) - { - TEST( strs[ j ] > strs[ i ] ); - TEST( strs[ i ] < strs[ j ] ); - - TEST( !( strs[ j ] < strs[ i ] ) ); - TEST( !( strs[ i ] > strs[ j ] ) ); - - TEST( strs[ j ] >= strs[ i ] ); - TEST( strs[ i ] <= strs[ j ] ); - } - } - } - - void testFind() - { - //TODO - } - - void testInsert() - { - // String.insert( Pos, Char ) - TEST( String( "aa" ).insert( 1, 'c' ) == String( "aca" ) ); - - // String.insert( Pos, String ) - TEST( String( "aa" ).insert( 1, "cc" ) == String( "acca" ) ); - TEST( String( "aa" ).insert( 1, String( "cc" ) ) == String( "acca" ) ); - - // String.insert( Pos, String, Len ) - TEST( String( "aa" ).insert( 1, "ccdddd", 2 ) == String( "acca" ) ); - } - - void testErase() - { - TEST( String( "abba" ).erase( 1, 2 ) == String( "aa" ) ); - TEST( String( "abba" ).erase( 0, 4 ).isEmpty() ); - } - - void testReplace() - { - // String.replace( Pos, Len, String ) - TEST( String( "abba" ).replace( 1, 2, "ccc" ) == String( "accca" ) ); - TEST( String( "abba" ).replace( 1, 2, String( "ccc" ) ) == String( "accca" ) ); - TEST( String( "abba" ).replace( 0, 4, "" ).isEmpty() ); - TEST( String( "abba" ).replace( 2, 2, "c" ) == String( "abc" ) ); - - // String.replace( Char, Char ) - TEST( String().replace( 'a', 'b' ).isEmpty() ); - TEST( String( "ababc" ).replace( 'a', 'b' ) == String( "bbbbc" ) ); - TEST( String( "ababc" ).replace( 'd', 'e' ) == String( "ababc" ) ); - - // String.replace( String, String ) - TEST( String().replace( "foo", "bar" ).isEmpty() ); - TEST( String( "foobarfoo" ).replace( "foo", "bar" ) == String( "barbarbar" ) ); - TEST( String( "foobar" ).replace( "xx", "yy" ) == String( "foobar" ) ); - TEST( String( "foofoofoo" ).replace( "foo", "" ).isEmpty() ); - } - - void testSubstr() - { - TEST( String( "foobar" ).substr( 0, 3 ) == String( "foo" ) ); - TEST( String( "foobar" ).substr( 3 ) == String( "bar" ) ); - TEST( String( "foobar" ).substr( 2, 2 ) == String( "ob" ) ); - TEST( String( "foobar" ).substr( 2, 0 ).isEmpty() ); - TEST( String( "foobar" ).substr( 0, 6 ) == String( "foobar" ) ); - } - - void testToString() - { - TEST( String::ToString( U32( 1 ) ) == String( "1" ) ); - TEST( String::ToString( S32( -1 ) ) == String( "-1" ) ); - TEST( String::ToString( F32( 1.01 ) ) == String( "1.01" ) ); - TEST( String::ToString( "%s%i", "foo", 1 ) == String( "foo1" ) ); - } - - void testCaseConversion() - { - TEST( String::ToLower( "foobar123." ) == String( "foobar123." ) ); - TEST( String::ToLower( "FOOBAR123." ) == String( "foobar123." ) ); - TEST( String::ToUpper( "barfoo123." ) == String( "BARFOO123." ) ); - TEST( String::ToUpper( "BARFOO123." ) == String( "BARFOO123." ) ); - } - - void testConcat() - { - TEST( String( "foo" ) + String( "bar" ) == String( "foobar" ) ); - TEST( String() + String( "bar" ) == String( "bar" ) ); - TEST( String( "foo" ) + String() == String( "foo" ) ); - TEST( String() + String() == String() ); - TEST( String( "fo" ) + 'o' == String( "foo" ) ); - TEST( 'f' + String( "oo" ) == String( "foo" ) ); - TEST( String( "foo" ) + "bar" == String( "foobar" ) ); - TEST( "foo" + String( "bar" ) == String( "foobar" ) ); - } - - void testHash() - { - TEST( String( "foo" ).getHashCaseSensitive() == String( "foo" ).getHashCaseSensitive() ); - TEST( String( "foo" ).getHashCaseSensitive() != String( "bar" ).getHashCaseSensitive() ); - TEST( String( "foo" ).getHashCaseInsensitive() == String( "FOO" ).getHashCaseInsensitive() ); - } - - void testIntern() - { - TEST( String( "foo" ).intern().isSame( String( "foo" ).intern() ) ); - TEST( !String( "foo" ).intern().isSame( String( "bar" ).intern() ) ); - TEST( !String( "foo" ).intern().isSame( String( "Foo" ).intern() ) ); - TEST( String( "foo" ).intern() == String( "foo" ).intern() ); - TEST( String( "foo" ).intern() != String( "bar" ).intern() ); - TEST( String( "foo" ).intern().isInterned() ); - } - - void run() - { - mStrings.push_back( new StrTest( NULL ) ); - mStrings.push_back( new StrTest( "" ) ); - mStrings.push_back( new StrTest( "Torque" ) ); - mStrings.push_back( new StrTest( "TGEA" ) ); - mStrings.push_back( new StrTest( "GarageGames" ) ); - mStrings.push_back( new StrTest( "TGB" ) ); - mStrings.push_back( new StrTest( "games" ) ); - mStrings.push_back( new StrTest( "engine" ) ); - mStrings.push_back( new StrTest( "rocks" ) ); - mStrings.push_back( new StrTest( "technology" ) ); - mStrings.push_back( new StrTest( "Torque 3D" ) ); - mStrings.push_back( new StrTest( "Torque 2D" ) ); - - runTestOnStrings< Test1 >(); - runTestOnStrings< Test2 >(); - - runPairwiseTestOnStrings< Test3 >(); - - testEmpty(); - testTrim(); - testCompare(); - testOrder(); - testFind(); - testInsert(); - testReplace(); - testErase(); - testSubstr(); - testToString(); - testCaseConversion(); - testConcat(); - testHash(); - testIntern(); - - for( U32 i = 0; i < mStrings.size(); ++ i ) - delete mStrings[ i ]; - mStrings.clear(); - } -}; - -CreateUnitTest( TestStringBuilder, "Util/StringBuilder" ) -{ - void run() - { - StringBuilder str; - - str.append( 'f' ); - str.append( "oo" ); - str.append( String( "ba" ) ); - str.append( "rfajskfdj", 1 ); - str.format( "%s", "barfoo" ); - - TEST( str.end() == String( "foobarbarfoo" ) ); - } -}; - -#endif // !TORQUE_SHIPPING