strTest.cpp
Engine/source/core/util/test/strTest.cpp
Detailed Description
1 2//----------------------------------------------------------------------------- 3// Copyright (c) 2014 GarageGames, LLC 4// 5// Permission is hereby granted, free of charge, to any person obtaining a copy 6// of this software and associated documentation files (the "Software"), to 7// deal in the Software without restriction, including without limitation the 8// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 9// sell copies of the Software, and to permit persons to whom the Software is 10// furnished to do so, subject to the following conditions: 11// 12// The above copyright notice and this permission notice shall be included in 13// all copies or substantial portions of the Software. 14// 15// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21// IN THE SOFTWARE. 22//----------------------------------------------------------------------------- 23 24#ifdef TORQUE_TESTS_ENABLED 25#include "testing/unitTesting.h" 26#include "core/util/str.h" 27#include "core/util/tVector.h" 28#include "core/strings/stringFunctions.h" 29#include "core/strings/unicode.h" 30 31/// This is called Str, not String, because googletest doesn't let you use both 32/// TEST(x) and TEST_FIX(x). So this fixture is called Str, to match the StrTest 33/// struct, and the remaining fixture-les tests are named String. 34FIXTURE(Str) 35{ 36protected: 37 struct StrTest 38 { 39 const UTF8* mData; 40 const UTF16* mUTF16; 41 U32 mLength; 42 43 StrTest() : mData( 0 ), mUTF16( 0 ), mLength( 0 ) {} 44 StrTest( const char* str ) 45 : mData( str ), mUTF16( NULL ), mLength( str ? dStrlen( str ) : 0 ) 46 { 47 if( str ) 48 mUTF16 = createUTF16string( mData ); 49 } 50 ~StrTest() 51 { 52 if( mUTF16 ) 53 delete [] mUTF16; 54 } 55 }; 56 57 Vector< StrTest*> mStrings; 58 59 virtual void SetUp() 60 { 61 mStrings.push_back( new StrTest( NULL ) ); 62 mStrings.push_back( new StrTest( "" ) ); 63 mStrings.push_back( new StrTest( "Torque" ) ); 64 mStrings.push_back( new StrTest( "TGEA" ) ); 65 mStrings.push_back( new StrTest( "GarageGames" ) ); 66 mStrings.push_back( new StrTest( "TGB" ) ); 67 mStrings.push_back( new StrTest( "games" ) ); 68 mStrings.push_back( new StrTest( "engine" ) ); 69 mStrings.push_back( new StrTest( "rocks" ) ); 70 mStrings.push_back( new StrTest( "technology" ) ); 71 mStrings.push_back( new StrTest( "Torque 3D" ) ); 72 mStrings.push_back( new StrTest( "Torque 2D" ) ); 73 } 74 75 virtual void TearDown() 76 { 77 for( U32 i = 0; i < mStrings.size(); ++ i ) 78 delete mStrings[ i ]; 79 mStrings.clear(); 80 } 81}; 82 83#define EACH_STRING(i) \ 84 for( U32 i = 0; i < mStrings.size(); ++ i ) 85#define EACH_PAIR(i, j) \ 86 for( U32 i = 0; i < mStrings.size(); ++ i ) \ 87 for( U32 j = 0; j < mStrings.size(); ++ j ) 88 89TEST_FIX(Str, Test1) 90{ 91 EACH_STRING(i) 92 { 93 StrTest& data = *mStrings[i]; 94 String str( data.mData ); 95 String str16( data.mUTF16 ); 96 97 EXPECT_TRUE( str.length() == data.mLength ); 98 EXPECT_TRUE( str.size() == data.mLength + 1 ); 99 EXPECT_TRUE( str.isEmpty() || str.length() > 0 ); 100 EXPECT_TRUE( str.length() == str16.length() ); 101 EXPECT_TRUE( str.size() == str16.size() ); 102 103 EXPECT_TRUE( dMemcmp( str.utf16(), str16.utf16(), str.length() * sizeof( UTF16 ) ) == 0 ); 104 EXPECT_TRUE( !data.mData || dMemcmp( str.utf16(), data.mUTF16, str.length() * sizeof( UTF16 ) ) == 0 ); 105 EXPECT_TRUE( !data.mData || dMemcmp( str16.utf8(), data.mData, str.length() ) == 0 ); 106 107 EXPECT_TRUE( !data.mData || String::compare( str.utf8(), data.mData ) == 0 ); 108 EXPECT_TRUE( !data.mData || String::compare( str.utf16(), data.mUTF16 ) == 0 ); 109 } 110} 111 112TEST_FIX(Str, Test2) 113{ 114 EACH_STRING(i) 115 { 116 StrTest& data = *mStrings[i]; 117 String str( data.mData ); 118 119 EXPECT_TRUE( str == str ); 120 EXPECT_FALSE( str != str ); 121 EXPECT_FALSE( str < str ); 122 EXPECT_FALSE( str > str ); 123 EXPECT_TRUE( str.equal( str ) ); 124 EXPECT_TRUE( str.equal( str, String::NoCase ) ); 125 } 126} 127 128TEST_FIX(Str, Test3) 129{ 130 EACH_PAIR(i, j) 131 { 132 StrTest& d1 = *mStrings[i]; 133 StrTest& d2 = *mStrings[j]; 134 135 if( &d1 != &d2 ) 136 EXPECT_TRUE( String( d1.mData ) != String( d2.mData ) 137 || ( String( d1.mData ).isEmpty() && String( d2.mData ).isEmpty() ) ); 138 else 139 EXPECT_TRUE( String( d1.mData ) == String( d2.mData ) ); 140 } 141} 142 143TEST(String, Empty) 144{ 145 EXPECT_TRUE( String().length() == 0 ); 146 EXPECT_TRUE( String( "" ).length() == 0 ); 147 EXPECT_TRUE( String().size() == 1 ); 148 EXPECT_TRUE( String( "" ).size() == 1 ); 149 EXPECT_TRUE( String().isEmpty() ); 150 EXPECT_TRUE( String( "" ).isEmpty() ); 151} 152 153TEST(String, Trim) 154{ 155 EXPECT_TRUE( String( " Foobar Barfoo \n\t " ).trim() == String( "Foobar Barfoo" ) ); 156 EXPECT_TRUE( String( "Foobar" ).trim() == String( "Foobar" ) ); 157 EXPECT_TRUE( String( " " ).trim().isEmpty() ); 158} 159 160TEST(String, Compare) 161{ 162 String str( "Foobar" ); 163 164 EXPECT_TRUE( str.compare( "Foo", 3 ) == 0 ); 165 EXPECT_TRUE( str.compare( "bar", 3, String::NoCase | String::Right ) == 0 ); 166 EXPECT_TRUE( str.compare( "foo", 3, String::NoCase ) == 0 ); 167 EXPECT_TRUE( str.compare( "BAR", 3, String::NoCase | String::Right ) == 0 ); 168 EXPECT_TRUE( str.compare( "Foobar" ) == 0 ); 169 EXPECT_TRUE( str.compare( "Foo" ) != 0 ); 170 EXPECT_TRUE( str.compare( "foobar", 0, String::NoCase ) == 0 ); 171 EXPECT_TRUE( str.compare( "FOOBAR", 0, String::NoCase ) == 0 ); 172 EXPECT_TRUE( str.compare( "Foobar", 0, String::Right ) == 0 ); 173 EXPECT_TRUE( str.compare( "foobar", 0, String::NoCase | String::Right ) == 0 ); 174} 175 176TEST(String, Order) 177{ 178 Vector< String> strs; 179 180 strs.push_back( "a" ); 181 strs.push_back( "a0" ); 182 strs.push_back( "a1" ); 183 strs.push_back( "a1a" ); 184 strs.push_back( "a1b" ); 185 strs.push_back( "a2" ); 186 strs.push_back( "a10" ); 187 strs.push_back( "a20" ); 188 189 for( U32 i = 0; i < strs.size(); ++ i ) 190 { 191 for( U32 j = 0; j < i; ++ j ) 192 { 193 EXPECT_TRUE( strs[ j ] < strs[ i ] ); 194 EXPECT_TRUE( strs[ i ] > strs[ j ] ); 195 196 EXPECT_TRUE( !( strs[ j ] > strs[ i ] ) ); 197 EXPECT_TRUE( !( strs[ i ] < strs[ i ] ) ); 198 199 EXPECT_TRUE( strs[ j ] <= strs[ i ] ); 200 EXPECT_TRUE( strs[ i ] >= strs[ j ] ); 201 } 202 203 EXPECT_TRUE( !( strs[ i ] < strs[ i ] ) ); 204 EXPECT_TRUE( !( strs[ i ] > strs[ i ] ) ); 205 EXPECT_TRUE( strs[ i ] <= strs[ i ] ); 206 EXPECT_TRUE( strs[ i ] >= strs[ i ] ); 207 208 for( U32 j = i + 1; j < strs.size(); ++ j ) 209 { 210 EXPECT_TRUE( strs[ j ] > strs[ i ] ); 211 EXPECT_TRUE( strs[ i ] < strs[ j ] ); 212 213 EXPECT_TRUE( !( strs[ j ] < strs[ i ] ) ); 214 EXPECT_TRUE( !( strs[ i ] > strs[ j ] ) ); 215 216 EXPECT_TRUE( strs[ j ] >= strs[ i ] ); 217 EXPECT_TRUE( strs[ i ] <= strs[ j ] ); 218 } 219 } 220} 221 222/// TODO 223TEST(String, Find) 224{ 225} 226 227TEST(String, Insert) 228{ 229 // String.insert( Pos, Char ) 230 EXPECT_TRUE( String( "aa" ).insert( 1, 'c' ) == String( "aca" ) ); 231 232 // String.insert( Pos, String ) 233 EXPECT_TRUE( String( "aa" ).insert( 1, "cc" ) == String( "acca" ) ); 234 EXPECT_TRUE( String( "aa" ).insert( 1, String( "cc" ) ) == String( "acca" ) ); 235 236 // String.insert( Pos, String, Len ) 237 EXPECT_TRUE( String( "aa" ).insert( 1, "ccdddd", 2 ) == String( "acca" ) ); 238} 239 240TEST(String, Erase) 241{ 242 EXPECT_TRUE( String( "abba" ).erase( 1, 2 ) == String( "aa" ) ); 243 EXPECT_TRUE( String( "abba" ).erase( 0, 4 ).isEmpty() ); 244} 245 246TEST(String, Replace) 247{ 248 // String.replace( Pos, Len, String ) 249 EXPECT_TRUE( String( "abba" ).replace( 1, 2, "ccc" ) == String( "accca" ) ); 250 EXPECT_TRUE( String( "abba" ).replace( 1, 2, String( "ccc" ) ) == String( "accca" ) ); 251 EXPECT_TRUE( String( "abba" ).replace( 0, 4, "" ).isEmpty() ); 252 EXPECT_TRUE( String( "abba" ).replace( 2, 2, "c" ) == String( "abc" ) ); 253 254 // String.replace( Char, Char ) 255 EXPECT_TRUE( String().replace( 'a', 'b' ).isEmpty() ); 256 EXPECT_TRUE( String( "ababc" ).replace( 'a', 'b' ) == String( "bbbbc" ) ); 257 EXPECT_TRUE( String( "ababc" ).replace( 'd', 'e' ) == String( "ababc" ) ); 258 259 // String.replace( String, String ) 260 EXPECT_TRUE( String().replace( "foo", "bar" ).isEmpty() ); 261 EXPECT_TRUE( String( "foobarfoo" ).replace( "foo", "bar" ) == String( "barbarbar" ) ); 262 EXPECT_TRUE( String( "foobar" ).replace( "xx", "yy" ) == String( "foobar" ) ); 263 EXPECT_TRUE( String( "foofoofoo" ).replace( "foo", "" ).isEmpty() ); 264} 265 266TEST(String, SubStr) 267{ 268 EXPECT_TRUE( String( "foobar" ).substr( 0, 3 ) == String( "foo" ) ); 269 EXPECT_TRUE( String( "foobar" ).substr( 3 ) == String( "bar" ) ); 270 EXPECT_TRUE( String( "foobar" ).substr( 2, 2 ) == String( "ob" ) ); 271 EXPECT_TRUE( String( "foobar" ).substr( 2, 0 ).isEmpty() ); 272 EXPECT_TRUE( String( "foobar" ).substr( 0, 6 ) == String( "foobar" ) ); 273} 274 275TEST(String, ToString) 276{ 277 EXPECT_TRUE( String::ToString( U32( 1 ) ) == String( "1" ) ); 278 EXPECT_TRUE( String::ToString( S32( -1 ) ) == String( "-1" ) ); 279 EXPECT_TRUE( String::ToString( F32( 1.01 ) ) == String( "1.01" ) ); 280 EXPECT_TRUE( String::ToString( "%s%i", "foo", 1 ) == String( "foo1" ) ); 281} 282 283TEST(String, CaseConversion) 284{ 285 EXPECT_TRUE( String::ToLower( "foobar123." ) == String( "foobar123." ) ); 286 EXPECT_TRUE( String::ToLower( "FOOBAR123." ) == String( "foobar123." ) ); 287 EXPECT_TRUE( String::ToUpper( "barfoo123." ) == String( "BARFOO123." ) ); 288 EXPECT_TRUE( String::ToUpper( "BARFOO123." ) == String( "BARFOO123." ) ); 289} 290 291TEST(String, Concat) 292{ 293 EXPECT_TRUE( String( "foo" ) + String( "bar" ) == String( "foobar" ) ); 294 EXPECT_TRUE( String() + String( "bar" ) == String( "bar" ) ); 295 EXPECT_TRUE( String( "foo" ) + String() == String( "foo" ) ); 296 EXPECT_TRUE( String() + String() == String() ); 297 EXPECT_TRUE( String( "fo" ) + 'o' == String( "foo" ) ); 298 EXPECT_TRUE( 'f' + String( "oo" ) == String( "foo" ) ); 299 EXPECT_TRUE( String( "foo" ) + "bar" == String( "foobar" ) ); 300 EXPECT_TRUE( "foo" + String( "bar" ) == String( "foobar" ) ); 301} 302 303TEST(String, Hash) 304{ 305 EXPECT_TRUE( String( "foo" ).getHashCaseSensitive() == String( "foo" ).getHashCaseSensitive() ); 306 EXPECT_TRUE( String( "foo" ).getHashCaseSensitive() != String( "bar" ).getHashCaseSensitive() ); 307 EXPECT_TRUE( String( "foo" ).getHashCaseInsensitive() == String( "FOO" ).getHashCaseInsensitive() ); 308} 309 310TEST(String, Intern) 311{ 312 EXPECT_TRUE( String( "foo" ).intern().isSame( String( "foo" ).intern() ) ); 313 EXPECT_TRUE( !String( "foo" ).intern().isSame( String( "bar" ).intern() ) ); 314 EXPECT_TRUE( !String( "foo" ).intern().isSame( String( "Foo" ).intern() ) ); 315 EXPECT_TRUE( String( "foo" ).intern() == String( "foo" ).intern() ); 316 EXPECT_TRUE( String( "foo" ).intern() != String( "bar" ).intern() ); 317 EXPECT_TRUE( String( "foo" ).intern().isInterned() ); 318} 319 320TEST(StringBuilder, StringBuilder) 321{ 322 StringBuilder str; 323 324 str.append( 'f' ); 325 str.append( "oo" ); 326 str.append( String( "ba" ) ); 327 str.append( "rfajskfdj", 1 ); 328 str.format( "%s", "barfoo" ); 329 330 EXPECT_TRUE( str.end() == String( "foobarbarfoo" ) ); 331} 332 333#endif 334