/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sal.hxx" #include #ifndef _SAL_TYPES_H_ #include #endif // #ifndef _RTL_TRES_H_ // #include // #endif #include #ifndef _RTL_STRING_HXX_ #include #endif #ifndef _RTL_STRING_CONST_H_ #include #endif #ifndef _RTL_STRING_UTILS_HXX_ #include #endif #include using namespace rtl; //------------------------------------------------------------------------ // test classes //------------------------------------------------------------------------ const int MAXBUFLENGTH = 255; //------------------------------------------------------------------------ // helper functions //------------------------------------------------------------------------ static void unused() { test_ini_uString(); (void)inputChar; (void)input1StrDefault; (void)input1StrNormal; (void)input1StrLastDefault; (void)input1StrLastNormal; unused(); } //------------------------------------------------------------------------ // testing constructors //------------------------------------------------------------------------ static sal_Bool test_rtl_OString_ctor_001( hTestResult hRtlTestResult ) { ::rtl::OString aStr; rtl_String* pData = aStr.pData; return ( c_rtl_tres_state ( hRtlTestResult, pData->length == 0 && ! *pData->buffer, "New OString containing no characters", "ctor_001" ) ); } //------------------------------------------------------------------------ static sal_Bool SAL_CALL test_rtl_OString_ctor_002( hTestResult hRtlTestResult ) { ::rtl::OString aStr(kTestStr1); rtl_String* pData = aStr.pData; return ( c_rtl_tres_state ( hRtlTestResult, pData->refCount == 1 && pData->length == kTestStr1Len && cmpstr( (const sal_Char*)pData->buffer, kTestStr1, kTestStr1Len ), "New OString from a character buffer array", "ctor_002" ) ); } //------------------------------------------------------------------------ static sal_Bool SAL_CALL test_rtl_OString_ctor_003( hTestResult hRtlTestResult ) { ::rtl::OString aStr(kTestStr2, kTestStr1Len); rtl_String* pData = aStr.pData; return ( c_rtl_tres_state ( hRtlTestResult, pData->refCount == 1 && pData->length == kTestStr1Len && cmpstr( (const sal_Char*)pData->buffer, kTestStr2, kTestStr1Len ), "New OString from the first n chars of ascii string", "ctor_003" ) ); } //------------------------------------------------------------------------ static sal_Bool SAL_CALL test_rtl_OString_ctor_004( hTestResult hRtlTestResult) { ::rtl::OString aStr1(kTestStr1); ::rtl::OString aStr2(aStr1); rtl_String* pData1 = aStr1.pData; rtl_String* pData2 = aStr2.pData; return ( c_rtl_tres_state ( hRtlTestResult, pData1->refCount == pData2->refCount && pData1->length == kTestStr1Len && pData1->buffer == pData2->buffer, "New OString from an OString", "ctor_004" ) ); } //------------------------------------------------------------------------ static sal_Bool test_rtl_OString_ctor_005( hTestResult hRtlTestResult ) { rtl_String *aStr1 = NULL; rtl_string_newFromStr( &aStr1, kTestStr1 ); if ( aStr1 != NULL ) { ::rtl::OString aStr2(aStr1); rtl_String* pData2 = aStr2.pData; sal_Bool bOK = c_rtl_tres_state ( hRtlTestResult, aStr1->refCount == pData2->refCount && pData2->length == kTestStr1Len && aStr1->buffer == pData2->buffer, "new OString from a RTL String", "ctor_005" ); rtl_string_release( aStr1 ); aStr1 = NULL; return ( bOK ); } return ( c_rtl_tres_state ( hRtlTestResult, sal_False, "copying an ascii string to a RTL String!", "ctor_005" ) ); } //------------------------------------------------------------------------ static sal_Bool test_rtl_OString_ctor_006( hTestResult hRtlTestResult ) { sal_Unicode aStr1[kTestStr1Len+1]; if ( AStringToUStringNCopy( aStr1, kTestStr1, kTestStr1Len ) ) { if ( AStringToUStringNCompare( aStr1, kTestStr1, kTestStr1Len ) == 0 ) { // const sal_Char *kTCMessage[2] = { "", "array." }; ::rtl::OString aStr2 ( aStr1, kTestStr1Len, kEncodingRTLTextUSASCII, kConvertFlagsOUStringToOString ); return ( c_rtl_tres_state ( hRtlTestResult, aStr2 == kTestStr1, "new OString from a unicode character buffer", "ctor_006" ) ); } /// end if AStringToUStringNCompare return ( c_rtl_tres_state ( hRtlTestResult, sal_False, "compare ascii string with unicode string!", "ctor_006" ) ); } /// end if AStringToUStringNCopy return ( c_rtl_tres_state ( hRtlTestResult, sal_False, "copy ascii string to unicode string!", "ctor_006" ) ); } extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_ctors( hTestResult hRtlTestResult ) { c_rtl_tres_state_start(hRtlTestResult, "ctor"); sal_Bool bTSState = test_rtl_OString_ctor_001( hRtlTestResult ); bTSState &= test_rtl_OString_ctor_002( hRtlTestResult); bTSState &= test_rtl_OString_ctor_003( hRtlTestResult); bTSState &= test_rtl_OString_ctor_004( hRtlTestResult); bTSState &= test_rtl_OString_ctor_005( hRtlTestResult); bTSState &= test_rtl_OString_ctor_006( hRtlTestResult); c_rtl_tres_state_end(hRtlTestResult, "ctor"); // return( bTSState ); } //------------------------------------------------------------------------ // testing the method getLength //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_getLength( hTestResult hRtlTestResult) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "getLength"); typedef struct TestCase { sal_Char* comments; sal_Int32 expVal; OString* input; ~TestCase() { delete input;} } TestCase; TestCase arrTestCase[]={ {"length of ascii string", kTestStr1Len, new OString(kTestStr1)}, {"length of ascci string of size 1", 1, new OString("1")}, {"length of empty string (default constructor)", 0, new OString()}, {"length of empty string (empty ascii string arg)",0,new OString("")}, {"length of empty string (string arg = '\\0')",0,new OString("\0")} }; sal_Bool res = sal_True; sal_uInt32 i; for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Int32 length = arrTestCase[i].input->getLength(); sal_Bool lastRes = (length == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "getLength", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "getLength"); // return ( res ); } //------------------------------------------------------------------------ // testing the method equals( const OString & aStr ) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_equals( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "equals"); typedef struct TestCase { sal_Char* comments; sal_Bool expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2;} } TestCase; TestCase arrTestCase[]={ {"same size", sal_True, new OString(kTestStr1),new OString(kTestStr1)}, {"different size", sal_False, new OString(kTestStr1), new OString(kTestStr2)}, {"same size, no case match", sal_False, new OString(kTestStr1), new OString(kTestStr3)}, {"two empty strings(def. constructor)", sal_True, new OString(), new OString()}, {"empty(def.constructor) and non empty", sal_False, new OString(), new OString(kTestStr2)}, {"non empty and empty(def. constructor)", sal_False, new OString(kTestStr1),new OString()}, {"two empty strings(string arg = '\\0')", sal_True, new OString(""),new OString("")}, {"empty(string arg = '\\0') and non empty", sal_False, new OString(""),new OString(kTestStr2)}, {"non empty and empty(string arg = '\\0')", sal_False, new OString(kTestStr1),new OString("")} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Bool lastRes = ( arrTestCase[i].input1->equals(*(arrTestCase[i].input2)) == arrTestCase[i].expVal ); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "equals", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "equals"); // return (res); } //------------------------------------------------------------------------ // testing the method equalsIgnoreAsciiCase( const OString & aStr ) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_equalsIgnoreAsciiCase( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "equalsIgnoreAsciiCase"); typedef struct TestCase { sal_Char* comments; sal_Bool expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2;} } TestCase; TestCase arrTestCase[]={ {"same strings but different cases",sal_True,new OString(kTestStr4), new OString(kTestStr5)}, {"same strings",sal_True,new OString(kTestStr4), new OString(kTestStr4)}, {"with equal beginning",sal_False,new OString(kTestStr2), new OString(kTestStr4)}, {"empty(def.constructor) and non empty",sal_False,new OString(), new OString(kTestStr5)}, {"non empty and empty(def.constructor)",sal_False, new OString(kTestStr4), new OString()}, {"two empty strings(def.constructor)",sal_True,new OString(), new OString()}, {"different strings with equal length",sal_False, new OString(kTestStr10), new OString(kTestStr11)} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Bool lastRes = (arrTestCase[i].input1->equalsIgnoreAsciiCase(*arrTestCase[i].input2) == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "equalsIgnoreAsciiCase", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "equalsIgnoreAsciiCase"); // return (res); } static sal_Bool SAL_CALL test_rtl_OString_compareTo_001( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; typedef struct TestCase { sal_Char* comments; sal_Int32 expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2;} } TestCase; TestCase arrTestCase[]={ {"simple compare, str1 to str5",-1,new OString(kTestStr1), new OString(kTestStr5)}, {"simple compare, str2 to str5",-1,new OString(kTestStr2), new OString(kTestStr5)}, {"simple compare, str1 to str9",-1,new OString(kTestStr1), new OString(kTestStr9)}, {"simple compare, str1 to str2",-1,new OString(kTestStr1), new OString(kTestStr2)}, {"simple compare, str4 to str5",-1,new OString(kTestStr4), new OString(kTestStr5)}, {"simple compare, str1 to str3",-1,new OString(kTestStr1), new OString(kTestStr3)}, {"simple compare, str5 to str1",+1,new OString(kTestStr5), new OString(kTestStr1)}, {"simple compare, str2 to str1",+1,new OString(kTestStr2), new OString(kTestStr1)}, {"simple compare, str9 to str5",+1,new OString(kTestStr9), new OString(kTestStr5)}, {"simple compare, str5 to str4",+1,new OString(kTestStr5), new OString(kTestStr4)}, {"simple compare, str1 to str1",0,new OString(kTestStr1), new OString(kTestStr1)}, {"simple compare, nullString to nullString",0,new OString(), new OString()}, {"simple compare, nullString to str2",-1,new OString(), new OString(kTestStr2)}, {"simple compare, str1 to nullString",+1,new OString(kTestStr1), new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Int32 cmpRes = arrTestCase[i].input1->compareTo(*arrTestCase[i].input2); cmpRes = ( cmpRes == 0 ) ? 0 : ( cmpRes > 0 ) ? +1 : -1 ; sal_Bool lastRes = ( cmpRes == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "compareTo(const OString&)", i ) ); res &= lastRes; } return (res); } //------------------------------------------------------------------------ // testing the method compareTo( const OString & rObj, sal_Int32 length ) //------------------------------------------------------------------------ static sal_Bool SAL_CALL test_rtl_OString_compareTo_002( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; typedef struct TestCase { sal_Char* comments; sal_Int32 expVal; sal_Int32 maxLength; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2;} } TestCase; TestCase arrTestCase[] = { {"compare with maxlength, str1 to str9, 16",-1,16, new OString(kTestStr1), new OString(kTestStr9)}, {"compare with maxlength, str2 to str9, 32",-1,32, new OString(kTestStr2), new OString(kTestStr9)}, {"compare with maxlength, str9 to str4, 16",+1,16, new OString(kTestStr9), new OString(kTestStr4)}, {"compare with maxlength, str9 to str22, 32",+1,32, new OString(kTestStr9), new OString(kTestStr22)}, {"compare with maxlength, str9 to str5, 16",0,16, new OString(kTestStr9), new OString(kTestStr5)}, {"compare with maxlength, str9 to str9, 32",0,32, new OString(kTestStr9), new OString(kTestStr9)}, {"compare with maxlength, str1 to str2, 32",-1,32, new OString(kTestStr1), new OString(kTestStr2)}, {"compare with maxlength, str1 to str2, 32",-1,32, new OString(kTestStr1), new OString(kTestStr2)} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Int32 cmpRes = arrTestCase[i].input1->compareTo(*arrTestCase[i].input2, arrTestCase[i].maxLength); cmpRes = (cmpRes == 0) ? 0 : (cmpRes > 0) ? +1 : -1 ; sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "compareTo(const OString&, sal_Int32)", i ) ); res &= lastRes; } return (res); } extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_compareTo( hTestResult hRtlTestResult ) { c_rtl_tres_state_start(hRtlTestResult, "compareTo"); sal_Bool res = test_rtl_OString_compareTo_001(hRtlTestResult); res &= test_rtl_OString_compareTo_002(hRtlTestResult); c_rtl_tres_state_end(hRtlTestResult, "compareTo"); // return (res); } //------------------------------------------------------------------------ // testing the operator == ( const OString& rStr1, const OString& rStr2 ) // testing the operator == ( const OString& rStr1, const sal_Char *rStr2 ) // testing the operator == ( const sal_Char *rStr1, const OString& rStr2 ) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_cmp( hTestResult hRtlTestResult ) { c_rtl_tres_state_start(hRtlTestResult, "op_cmp"); const sal_Int16 NCASES = 7; sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; const sal_Char *arrOStr[NCASES][2] = { {kTestStr1, kTestStr1}, {kTestStr1, kTestStr3}, {kTestStr1, kTestStr2}, {0, 0}, {0, kTestStr2}, {kTestStr1, 0}, {"", ""} }; sal_Bool arrExpVal[NCASES] = { sal_True, sal_False, sal_False, sal_True, sal_False, sal_False, sal_True }; sal_Char *arrComments[NCASES] = { "'Sun Microsystems'=='Sun Microsystems'", "!('Sun Microsystems'=='Sun microsystems')", "!('Sun Microsystems'=='Sun Microsystems Java Technology')", "two empty strings(def.constructor)", "!(empty string=='Sun Microsystems Java Technology')", "!('Sun Microsystems Java Technology'==empty string)", "''==''" }; sal_Bool res = sal_True; sal_Int32 i; for(i = 0; i < NCASES; i++) { OString *str1, *str2; str1 = (arrOStr[i][0]) ? new OString(arrOStr[i][0]) : new OString() ; str2 = (arrOStr[i][1]) ? new OString(arrOStr[i][1]) : new OString() ; sal_Bool cmpRes = (*str1 == *str2); sal_Bool lastRes = (cmpRes == arrExpVal[i]); res &= lastRes; c_rtl_tres_state ( hRtlTestResult, lastRes, arrComments[i], createName( pMeth, "operator ==(OString&, OString&)", i ) ); cmpRes = (*str1 == arrOStr[i][1]); lastRes = (cmpRes == arrExpVal[i]); res &= lastRes; c_rtl_tres_state ( hRtlTestResult, lastRes, arrComments[i], createName( pMeth, "operator ==(OString&, sal_Char *)", i ) ); cmpRes = (arrOStr[i][0] == *str2); lastRes = (cmpRes == arrExpVal[i]); res &= lastRes; c_rtl_tres_state ( hRtlTestResult, lastRes, arrComments[i], createName( pMeth, "operator ==(sal_Char *, OString&)", i ) ); delete str2; delete str1; } c_rtl_tres_state_end(hRtlTestResult, "op_cmp"); // return ( res ); } //------------------------------------------------------------------------ // testing the operator != (const OString& rStr1, const OString& rStr2) // testing the operator != (const OString& rStr1, const sal_Char *rStr2) // testing the operator != (const sal_Char *rStr1, const OString& rStr2) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_neq( hTestResult hRtlTestResult ) { c_rtl_tres_state_start(hRtlTestResult, "op_neq"); const sal_Int16 NCASES = 6; sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; const sal_Char *arrOStr[NCASES][2] = { {kTestStr1, kTestStr3}, {kTestStr1, kTestStr2}, {kTestStr1, kTestStr1}, {0, kTestStr2}, {kTestStr1, 0}, {0, 0} }; sal_Bool arrExpVal[NCASES] = { sal_True, sal_True, sal_False, sal_True, sal_True, sal_False }; sal_Char *arrComments[NCASES] = { "'Sun Microsystems'!='Sun microsystems'", "'Sun Microsystems'!='Sun Microsystems Java Technology'", "!('Sun Microsystems'!='Sun Microsystems')", "empty string!='Sun Microsystems Java Technology'", "'Sun Microsystems Java Technology'!=empty string", "!(''!='')" }; sal_Bool res = sal_True; sal_Int32 i; for(i = 0; i < NCASES; i++) { OString *str1, *str2; str1 = (arrOStr[i][0]) ? new OString(arrOStr[i][0]) : new OString() ; str2 = (arrOStr[i][1]) ? new OString(arrOStr[i][1]) : new OString() ; sal_Bool cmpRes = (*str1 != *str2); sal_Bool lastRes = (cmpRes == arrExpVal[i]); res &= lastRes; c_rtl_tres_state ( hRtlTestResult, lastRes, arrComments[i], createName( pMeth, "operator !=(OString&, OString&)", i ) ); cmpRes = (*str1 != arrOStr[i][1]); lastRes = (cmpRes == arrExpVal[i]); res &= lastRes; c_rtl_tres_state ( hRtlTestResult, lastRes, arrComments[i], createName( pMeth, "operator !=(OString&, sal_Char *)", i ) ); cmpRes = (arrOStr[i][0] != *str2); lastRes = (cmpRes == arrExpVal[i]); res &= lastRes; c_rtl_tres_state ( hRtlTestResult, lastRes, arrComments[i], createName( pMeth, "operator !=(sal_Char *, OString&)", i ) ); delete str2; delete str1; } c_rtl_tres_state_end(hRtlTestResult, "op_neq"); // return ( res ); } //------------------------------------------------------------------------ // testing the operator > (const OString& rStr1, const OString& rStr2) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_g( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "op_g"); typedef struct TestCase { sal_Char* comments; sal_Bool expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2;} } TestCase; TestCase arrTestCase[] = { { "'Sun microsystems'>'Sun Microsystems'",sal_True, new OString(kTestStr3), new OString(kTestStr1)}, {"!('Sun Microsystems'>'Sun microsystems')",sal_False, new OString(kTestStr1), new OString(kTestStr3)}, {"'Sun Microsystems Java Technology'>'Sun Microsystems'",sal_True, new OString(kTestStr2), new OString(kTestStr1)}, {"!('Sun Microsystems'>'Sun Microsystems Java Technology')",sal_False, new OString(kTestStr1), new OString(kTestStr2)}, {"!('Sun Microsystems'>'Sun Microsystems'",sal_False, new OString(kTestStr1), new OString(kTestStr1)}, {"'Sun Microsystems'>''",sal_True,new OString(kTestStr1), new OString()}, {"!(''>'Sun Microsystems')",sal_False,new OString(), new OString(kTestStr1)}, {"!(''>'')",sal_False,new OString(), new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Bool cmpRes = (*arrTestCase[i].input1 > *arrTestCase[i].input2); sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "operator >", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "op_g"); // return ( res ); } //------------------------------------------------------------------------ // testing the operator < (const OString& rStr1, const OString& rStr2) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_l( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "op_l"); typedef struct TestCase { sal_Char* comments; sal_Bool expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2;} } TestCase; TestCase arrTestCase[] = { {"!('Sun microsystems'<'Sun Microsystems')",sal_False, new OString(kTestStr3), new OString(kTestStr1)}, {"'Sun Microsystems'<'Sun microsystems'",sal_True, new OString(kTestStr1), new OString(kTestStr3)}, {"'Sun Microsystems'<'Sun Microsystems Java Technology'",sal_True, new OString(kTestStr1), new OString(kTestStr2)}, {"!('Sun Microsystems Java Technology'<'Sun Microsystems')",sal_False, new OString(kTestStr2), new OString(kTestStr1)}, {"!('Sun Microsystems'<'Sun Microsystems'", sal_False, new OString(kTestStr1), new OString(kTestStr1)}, {"'Sun Microsystems'<''",sal_False,new OString(kTestStr1), new OString()}, {"''<'Sun Microsystems Java Technology'",sal_True,new OString(), new OString(kTestStr2)}, {"!(''<'')",sal_False,new OString(), new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Bool cmpRes = (*arrTestCase[i].input1 < *arrTestCase[i].input2); sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "operator <", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "op_l"); // return ( res ); } //------------------------------------------------------------------------ // testing the operator >= (const OString& rStr1, const OString& rStr2) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_ge( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "op_ge"); typedef struct TestCase { sal_Char* comments; sal_Bool expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2;} } TestCase; TestCase arrTestCase[] = { {"'Sun microsystems'>='Sun Microsystems'",sal_True, new OString(kTestStr3), new OString(kTestStr1)}, {"!('Sun Microsystems'>='Sun microsystems')",sal_False, new OString(kTestStr1), new OString(kTestStr3)}, {"!('Sun Microsystems'>='Sun Microsystems Java Technology')",sal_False, new OString(kTestStr1), new OString(kTestStr2)}, {"'Sun Microsystems Java Technology'>='Sun Microsystems'",sal_True, new OString(kTestStr2), new OString(kTestStr1)}, {"'Sun Microsystems'>='Sun Microsystems'", sal_True, new OString(kTestStr1), new OString(kTestStr1)}, {"'Sun Microsystems'>=''",sal_True,new OString(kTestStr1), new OString()}, { "''>='Sun microsystems'",sal_False,new OString(), new OString(kTestStr3)}, {"''>=''",sal_True,new OString(), new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Bool cmpRes = (*arrTestCase[i].input1 >= *arrTestCase[i].input2); sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "operator >=", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "op_ge"); // return ( res ); } //------------------------------------------------------------------------ // testing the operator <= (const OString& rStr1, const OString& rStr2) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_le( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "op_le"); typedef struct TestCase { sal_Char* comments; sal_Bool expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2;} } TestCase; TestCase arrTestCase[] = { {"!('Sun microsystems'<='Sun Microsystems')",sal_False, new OString(kTestStr3), new OString(kTestStr1)}, {"'Sun Microsystems'<='Sun microsystems'",sal_True, new OString(kTestStr1), new OString(kTestStr3)}, {"'Sun Microsystems'<='Sun Microsystems Java Technology'",sal_True, new OString(kTestStr1), new OString(kTestStr2)}, {"!('Sun Microsystems Java Technology'<='Sun Microsystems')",sal_False, new OString(kTestStr2), new OString(kTestStr1)}, {"!('Sun Microsystems'<='Sun Microsystems'", sal_True, new OString(kTestStr1), new OString(kTestStr1)}, {"'Sun Microsystems'<=''",sal_False,new OString(kTestStr1), new OString()}, {"''<='Sun Microsystems Java Technology'",sal_True,new OString(), new OString(kTestStr2)}, {"!(''<='')",sal_True,new OString(), new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Bool cmpRes = (*arrTestCase[i].input1 <= *arrTestCase[i].input2); sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "operator <=", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "op_le"); // return ( res ); } //------------------------------------------------------------------------ // testing the operator = //------------------------------------------------------------------------ static sal_Bool test_rtl_OString_op_eq_001( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; typedef struct TestCase { sal_Char* comments; sal_Bool expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2;} } TestCase; TestCase arrTestCase[] = { {"'' = str1, str1 == str2",sal_True,new OString(kTestStr1), new OString()}, {"str1 = str2, str1 == str2",sal_True,new OString(kTestStr1), new OString(kTestStr6)}, {"str2 = '', str1 == str2",sal_True,new OString(), new OString(kTestStr2)}, {"'' = '', str1 == str2",sal_True,new OString(), new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { *(arrTestCase[i].input1) = *(arrTestCase[i].input2); sal_Bool cmpRes = (*(arrTestCase[i].input1) == *(arrTestCase[i].input2)); sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "operator =", i ) ); res &= lastRes; } return ( res ); } static sal_Bool test_rtl_OString_op_eq_002( hTestResult hRtlTestResult ) { ::rtl::OString aStr; aStr = OString(kTestStr1); return ( c_rtl_tres_state ( hRtlTestResult, aStr == kTestStr1, "str = OString(\"%s\"), str == \"%s\"", "operator =" ) ); } static sal_Bool test_rtl_OString_op_eq_003( hTestResult hRtlTestResult ) { sal_Bool bTCState = false; ::rtl::OString aStr1(kTestStr1); ::rtl::OString aStr2; ::rtl::OString aStr3; aStr3 = aStr2 = aStr1; bTCState = ( aStr1 == aStr2 ) && ( aStr1 == aStr3 ) && ( aStr2 == aStr3 ); c_rtl_tres_state ( hRtlTestResult, bTCState, "str3=str2=str1,(str1 == str2)&&(str1 == str3)&&(str2 == str3)", "operator =" ); return bTCState; } extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_eq( hTestResult hRtlTestResult ) { c_rtl_tres_state_start(hRtlTestResult, "op_eq"); sal_Bool res = test_rtl_OString_op_eq_001( hRtlTestResult ); res &= test_rtl_OString_op_eq_002( hRtlTestResult ); res &= test_rtl_OString_op_eq_003( hRtlTestResult ); c_rtl_tres_state_end(hRtlTestResult, "op_eq"); // return ( res ); } //------------------------------------------------------------------------ // testing the operator + //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_plus( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "op_plus"); typedef struct TestCase { sal_Char* comments; OString* expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2; delete expVal;} } TestCase; TestCase arrTestCase[] = { {"str1 = str7 + str8",new OString(kTestStr1), new OString(kTestStr7), new OString(kTestStr8)}, {"str1 = str1 + '' ",new OString(kTestStr1), new OString(kTestStr1), new OString("")}, {"str1 = '' + str1", new OString(kTestStr1), new OString(""), new OString(kTestStr1)}, {" '' = '' + '' ", new OString(""),new OString(""), new OString("")}, {"str1 = str1 + def.constr", new OString(kTestStr1), new OString(kTestStr1), new OString()}, {" str1 = def.constr + str1 ",new OString(kTestStr1), new OString(), new OString(kTestStr1)}, {" def.constr= def.constr + def.constr", new OString(), new OString(), new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { OString str = (*arrTestCase[i].input1) + (*arrTestCase[i].input2); sal_Bool lastRes = (str == *arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "operator +", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "op_plus"); // return ( res ); } //------------------------------------------------------------------------ // testing the operator += //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_peq( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "op_peq"); typedef struct TestCase { sal_Char* comments; OString* expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2; delete expVal;} } TestCase; TestCase arrTestCase[] = { {"str1 == (str7 += str8)",new OString(kTestStr1), new OString(kTestStr7), new OString(kTestStr8)}, {"str1 == (str1 += '')",new OString(kTestStr1), new OString(kTestStr1), new OString("")}, {"str1 == ('' += str1)", new OString(kTestStr1), new OString(""), new OString(kTestStr1)}, {" '' == ('' += '')", new OString(""), new OString(""), new OString("")}, {"str1 == (str1 += def.constr)", new OString(kTestStr1), new OString(kTestStr1), new OString()}, {" str1 == (def.constr += str1)",new OString(kTestStr1), new OString(), new OString(kTestStr1)}, {" def.constr== (def.constr += def.constr)", new OString(),new OString(), new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { OString str; str += (*arrTestCase[i].input1); str += (*arrTestCase[i].input2); sal_Bool lastRes = (str == *arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "operator +", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "op_peq"); // return ( res ); } //------------------------------------------------------------------------ // testing the operator const sal_Char * (cscs for short) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_op_cscs( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "op_cscs"); typedef struct TestCase { sal_Char* comments; const sal_Char* expVal; sal_Int32 cmpLen; OString* input1; ~TestCase() { delete input1;} } TestCase; TestCase arrTestCase[] = { {"test normal string",kTestStr1,kTestStr1Len,new OString(kTestStr1)}, {"test empty string","",1,new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { const sal_Char* pstr = (*arrTestCase[i].input1); res &= c_rtl_tres_state ( hRtlTestResult, cmpstr((sal_Char*)pstr,(sal_Char*)arrTestCase[i].expVal, arrTestCase[i].cmpLen), arrTestCase[i].comments, createName( pMeth, "const sal_Char*", i ) ); } c_rtl_tres_state_end(hRtlTestResult, "op_cscs"); // return ( res ); } //------------------------------------------------------------------------ // testing the method getStr() //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_getStr( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "getStr"); typedef struct TestCase { sal_Char* comments; const sal_Char* expVal; sal_Int32 cmpLen; OString* input1; ~TestCase() { delete input1;} } TestCase; TestCase arrTestCase[] = { {"test normal string",kTestStr1,kTestStr1Len,new OString(kTestStr1)}, {"test empty string","",0,new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { const sal_Char* pstr = arrTestCase[i].input1->getStr(); res &= c_rtl_tres_state ( hRtlTestResult, cmpstr(pstr, arrTestCase[i].expVal, arrTestCase[i].cmpLen), arrTestCase[i].comments, createName( pMeth, "getStr", i ) ); } c_rtl_tres_state_end(hRtlTestResult, "getStr"); // return ( res ); } //------------------------------------------------------------------------ // testing the method copy( sal_Int32 beginIndex ) //------------------------------------------------------------------------ static sal_Bool SAL_CALL test_rtl_OString_copy_001( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; typedef struct TestCase { sal_Char* comments; const sal_Char* srcStr; const sal_Char* arrExpStr; // string for comparing with result sal_Int32 beginIndex; // beginIndex for the method copy sal_Int32 lengthForCmp; // number of symbols for comparing // (if value is equal to 0 then pointers to buffers must be equal) sal_Int32 expLength; //expected length of the result string } TestCase; TestCase arrTestCase[] = { {"beginIndex == 0 ( whole string )", kTestStr2,kTestStr2, 0, kTestStr2Len, kTestStr2Len}, {"beginIndex == strlen-2 ( last two char )", kTestStr2,"gy", kTestStr2Len-2, 2, 2}, {"beginIndex == strlen-1( last char )", kTestStr2, "y", kTestStr2Len-1, 1, 1} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i <(sizeof (arrTestCase))/(sizeof (TestCase)); i++) { OString src(arrTestCase[i].srcStr); OString dst; // rtl_String* pDataSrc = src.pData; dst = src.copy(arrTestCase[i].beginIndex); // rtl_String* pDataDst = dst.pData; sal_Bool lastRes; lastRes= (dst== arrTestCase[i].arrExpStr); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "copy_001(beginIndex)(check buffer and length)", i ) ); res &= lastRes; } return (res); } //------------------------------------------------------------------------ // testing the method copy( sal_Int32 beginIndex, sal_Int32 count ) //------------------------------------------------------------------------ static sal_Bool SAL_CALL test_rtl_OString_copy_002( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; typedef struct TestCase { sal_Char* comments; const sal_Char* arrExpStr; sal_Int32 beginIndex; sal_Int32 count; sal_Int32 expLen; } TestCase; TestCase arrTestCase[] ={ {"copy substring", kTestStr6, kTestStr11Len, kTestStr2Len - kTestStr11Len,kTestStr6Len}, /* LLA: it is a bug, beginIndex + count > kTestStr2.getLength() */ /* {"copy normal substring with incorrect count",kTestStr6, kTestStr11Len, 31, 15}, */ {"copy whole string", kTestStr2, 0, kTestStr2Len, kTestStr2Len}, /* {"copy whole string with incorrect count larger than len and index 0", kTestStr2, 0, 40, 32}, */ /* LLA: bug beginIndex + count > kTestStr2 {"copy last character", "y",kTestStr2Len - 1, 31,1}, */ {"copy last character", "y",kTestStr2Len - 1, 1,1}, /* LLA: bug, beginIndex > kTestStr2 {"beginindex larger than len","",60, 0,0}, */ {"beginindex exact as large as it's length","",kTestStr2Len, 0,0} /* LLA: bug, negative count is not allowed. {"count is nagative int","",3, -1,0} */ }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { OString src(kTestStr2); OString dst; dst = src.copy(arrTestCase[i].beginIndex, arrTestCase[i].count); // rtl_String* pDataSrc = src.pData; // rtl_String* pDataDst = dst.pData; sal_Bool lastRes=sal_True; // checks buffer and length //t_print("this is copy__002 #%d\n", i); //t_print("dst buffer =%s\n", pDataDst->buffer); //t_print("expStr =%s\n", arrTestCase[i].arrExpStr); //t_print("dst length =%d\n", pDataDst->length); //t_print("count =%d\n", arrTestCase[i].count); //t_print("expLen =%d\n", arrTestCase[i].expLen); lastRes = (dst.equals(arrTestCase[i].arrExpStr)) ? sal_True : sal_False; c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "copy_002(beginIndex,count)(check buffer and length)", i) ); res &= lastRes; } return (res); } static sal_Bool SAL_CALL test_rtl_OString_copy_003( hTestResult hRtlTestResult ) { sal_Bool res = sal_True; char comment[] = "copy whole short string to long string"; OString src(kTestStr1); // rtl_String* pDataSrc = src.pData; OString dst(kTestStr2); dst = src.copy(0); // rtl_String* pDataDst = dst.pData; //check buffer and length sal_Bool lastRes =(dst==src); c_rtl_tres_state ( hRtlTestResult, lastRes, comment, "copy_003(beginIndex)(check buffer and length)" ); res &= lastRes; return (res); } static sal_Bool SAL_CALL test_rtl_OString_copy_004( hTestResult hRtlTestResult ) { sal_Bool res = sal_True; sal_Char comment[] = "copy whole long string to short string"; OString src(kTestStr2); // rtl_String* pDataSrc = src.pData; OString dst(kTestStr1); dst = src.copy(0); // rtl_String* pDataDst = dst.pData; //check buffer and length sal_Bool lastRes =(dst==src); c_rtl_tres_state ( hRtlTestResult, lastRes, comment, "copy_004(beginIndex)(check buffer and length)" ); res &= lastRes; return (res); } extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_copy( hTestResult hRtlTestResult ) { c_rtl_tres_state_start(hRtlTestResult, "copy"); sal_Bool res = test_rtl_OString_copy_001(hRtlTestResult); res &= test_rtl_OString_copy_002(hRtlTestResult); res &= test_rtl_OString_copy_003(hRtlTestResult); res &= test_rtl_OString_copy_004(hRtlTestResult); c_rtl_tres_state_end(hRtlTestResult, "copy"); // return ( res ); } //------------------------------------------------------------------------ // testing the method concat( const OString & aStr ) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_concat( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth =methName; c_rtl_tres_state_start(hRtlTestResult, "concat"); typedef struct TestCase { sal_Char* comments; OString* expVal; OString* input1; OString* input2; ~TestCase() { delete input1;delete input2; delete expVal;} } TestCase; TestCase arrTestCase[] = { {"concatenates two strings",new OString(kTestStr1), new OString(kTestStr7), new OString(kTestStr8)}, {"concatenates empty string",new OString(kTestStr1), new OString(kTestStr1), new OString("")}, {"concatenates to empty string",new OString(kTestStr1), new OString(""), new OString(kTestStr1)}, {"concatenates two empty strings",new OString(""),new OString(""), new OString("")}, {"concatenates string constructed by default constructor", new OString(kTestStr1), new OString(kTestStr1), new OString()}, {"concatenates to string constructed by default constructor", new OString(kTestStr1), new OString(), new OString(kTestStr1)}, {"concatenates two strings constructed by default constructor", new OString(), new OString(), new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { OString str = arrTestCase[i].input1->concat(*arrTestCase[i].input2); sal_Bool lastRes = (str == *arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "concat", i) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "concat"); // return ( res ); } //------------------------------------------------------------------------ // testing the method toAsciiLowerCase() //----------------------------------------------------------------------- extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toAsciiLowerCase( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth =methName; c_rtl_tres_state_start(hRtlTestResult, "toAsciiLowerCase"); typedef struct TestCase { sal_Char* comments; OString* expVal; OString* input1; ~TestCase() { delete input1; delete expVal;} } TestCase; TestCase arrTestCase[] = { {"only uppercase",new OString(kTestStr5),new OString(kTestStr4)}, {"different cases",new OString(kTestStr5),new OString(kTestStr1)}, {"different cases",new OString(kTestStr5),new OString(kTestStr3)}, {"only lowercase",new OString(kTestStr5),new OString(kTestStr5)}, {"empty string",new OString(""),new OString("")}, {"string constructed by default constructor", new OString(),new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { OString str = arrTestCase[i].input1->toAsciiLowerCase(); sal_Bool lastRes = (str ==* arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "toAsciiLowerCase", i) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "toAsciiLowerCase"); // return ( res ); } //------------------------------------------------------------------------ // testing the method toAsciiUpperCase() //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toAsciiUpperCase( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth =methName; c_rtl_tres_state_start(hRtlTestResult, "toAsciiUpperCase"); typedef struct TestCase { sal_Char* comments; OString* expVal; OString* input1; ~TestCase() { delete input1; delete expVal;} } TestCase; TestCase arrTestCase[] = { {"only lowercase",new OString(kTestStr4),new OString(kTestStr5)}, {"mixed cases",new OString(kTestStr4),new OString(kTestStr3)}, {"miced cases",new OString(kTestStr4),new OString(kTestStr1)}, {"only uppercase",new OString(kTestStr4),new OString(kTestStr4)}, {"empty string",new OString(""),new OString("")}, {"string constructed by default constructor", new OString(),new OString()} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { OString str = arrTestCase[i].input1->toAsciiUpperCase(); sal_Bool lastRes = (str == *arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "toAsciiLowerCase", i) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "toAsciiUpperCase"); // return ( res ); } //------------------------------------------------------------------------ // testing the method trim() //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_trim( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth =methName; c_rtl_tres_state_start(hRtlTestResult, "trim"); typedef struct TestCase { sal_Char* comments; OString* expVal; OString* input1; ~TestCase() { delete input1; delete expVal;} } TestCase; TestCase arrTestCase[] = { {"removes space from the front",new OString(kTestStr1), new OString(kTestStr10)}, {"removes space from the end",new OString(kTestStr1), new OString(kTestStr11)}, {"removes space from the front and end",new OString(kTestStr1), new OString(kTestStr12)}, {"removes several spaces from the end",new OString(kTestStr1), new OString(kTestStr13)}, {"removes several spaces from the front",new OString(kTestStr1), new OString(kTestStr14)}, {"removes several spaces from the front and one from the end", new OString(kTestStr1), new OString(kTestStr15)}, {"removes one space from the front and several from the end", new OString(kTestStr1), new OString(kTestStr16)}, {"removes several spaces from the front and end", new OString(kTestStr1), new OString(kTestStr17)}, {"removes characters that have codes <= 32",new OString(kTestStr20), new OString("\1\3\5\7\11\13\15\17sun\21\23\25\27\31\33\40")}, {"no spaces",new OString(kTestStr8),new OString(kTestStr8)} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { OString strRes = arrTestCase[i].input1->trim(); sal_Bool lastRes = (strRes == *arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "trim", i) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "trim"); // return ( res ); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Bool b ) //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_sal_Bool( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth =methName; typedef struct TestCase { sal_Char* comments; sal_Bool input1; OString* expVal; ~TestCase() {delete expVal;} } TestCase; TestCase arrTestCase[] = { {"true",sal_True,new OString("true")}, {"false",sal_False, new OString("false")} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { ::rtl::OString aStr1; aStr1 = aStr1.valueOf( arrTestCase[i].input1 ); sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "valueof_bool", i) ); res &= lastRes; } return ( res ); } sal_Bool SAL_CALL test_rtl_OString_valueOf_sal_Char( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth =methName; typedef struct TestCase { sal_Char* comments; sal_Char input1; OString* expVal; ~TestCase() {delete expVal;} } TestCase; TestCase arrTestCase[] = { {"A",'A',new OString("A")}, {"a",'a', new OString("a")}, {"0",'0', new OString("0")}, {"-",'-', new OString("-")}, {"_",'_', new OString("_")}, {"|",'|', new OString("|")}, {"?",'?', new OString("?")}, {"?",'?', new OString("?")}, {"\n",'\n', new OString("\n")}, {"\'",'\'', new OString("\'")}, {"\"",'\"', new OString("\"")} }; sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { ::rtl::OString aStr1; aStr1 = aStr1.valueOf( arrTestCase[i].input1 ); sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "valueof_char", i) ); res &= lastRes; } return ( res ); } /** * Calls the method valueOf(T, radix) and compares * returned strings with strings that passed in the array resArray. * * @param T, type of argument, passed to valueOf * @param resArray, array of result strings to compare to * @param n the number of elements in the array resArray (testcases) * @param pTestResult the instance of the class TestResult * @param inArray [optional], array of value that is passed as first argument * to valueOf * * @return true, if all returned strings are equal to corresponding string in * resArray else, false. */ template sal_Bool test_valueOf( const char** resArray, int n, sal_Int16 radix, hTestResult hRtlTestResult, const T *inArray ) { sal_Bool bRes = sal_True; sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; sal_Int32 i; for (i = 0; i < n; i++) { ::rtl::OString aStr1; ::rtl::OString aStr2( resArray[i] ); if (inArray == 0) aStr1 = ::rtl::OString::valueOf((T)i, radix); else { if ( inArray[i] < 0 ) { aStr2 = "-"; aStr2 += resArray[i]; } aStr1 = ::rtl::OString::valueOf((T)inArray[i], radix); } bRes &= c_rtl_tres_state ( hRtlTestResult, aStr2.compareTo(aStr1) == 0, (sal_Char*)resArray[i], createName( pMeth, "valueOf", i ) ); } return (bRes); } #define test_valueOf_Int32 test_valueOf #define test_valueOf_Int64 test_valueOf // LLA: #define test_valueOf_float test_valueOf // LLA: #define test_valueOf_double test_valueOf //------------------------------------------------------------------------ // testing the method valueOf( sal_Int32 i, sal_Int16 radix=2 ) // testing the method valueOf( sal_Int32 i, sal_Int16 radix=8 ) // testing the method valueOf( sal_Int32 i, sal_Int16 radix=10 ) // testing the method valueOf( sal_Int32 i, sal_Int16 radix=16 ) // testing the method valueOf( sal_Int32 i, sal_Int16 radix=36 ) //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32( hTestResult hRtlTestResult ) { sal_Bool bRes = sal_False; bRes = c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kBinaryNumsStr, kBinaryNumsCount, kRadixBinary, hRtlTestResult, 0 ), "kRadixBinary", "valueOf(sal_Int32, radix 2)" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kOctolNumsStr, kOctolNumsCount, kRadixOctol, hRtlTestResult, 0), "kRadixOctol", "valueOf(sal_Int32, radix 8)" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kDecimalNumsStr, kDecimalNumsCount, kRadixDecimal, hRtlTestResult, 0), "kRadixDecimal", "valueOf(sal_Int32, radix 10)" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kHexDecimalNumsStr, kHexDecimalNumsCount, kRadixHexdecimal, hRtlTestResult, 0), "kRadixHexdecimal", "valueOf(sal_Int32, radix 16)" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kBase36NumsStr, kBase36NumsCount, kRadixBase36, hRtlTestResult, 0), "kRadixBase36", "valueOf(sal_Int32, radix 36)" ); return ( bRes ); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Int32 l, sal_Int32 radix=2 ) // where l = large constants // testing the method valueOf( sal_Int32 l, sal_Int32 radix=8 ) // where l = large constants // testing the method valueOf( sal_Int32 l, sal_Int32 radix=10 ) // where l = large constants // testing the method valueOf( sal_Int32 l, sal_Int32 radix=16 ) // where l = large constants // testing the method valueOf( sal_Int32 l, sal_Int32 radix=36 ) // where l = large constants //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32_Bounderies( hTestResult hRtlTestResult ) { sal_Bool bRes = sal_False; bRes = c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kBinaryMaxNumsStr, kInt32MaxNumsCount, kRadixBinary, hRtlTestResult, kInt32MaxNums), "kRadixBinary", "valueOf(salInt32, radix 2) Bounderies" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kOctolMaxNumsStr, kInt32MaxNumsCount, kRadixOctol, hRtlTestResult, kInt32MaxNums), "kRadixOctol", "valueOf(salInt32, radix 8) Bounderies" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kDecimalMaxNumsStr, kInt32MaxNumsCount, kRadixDecimal, hRtlTestResult, kInt32MaxNums), "kRadixDecimal", "valueOf(salInt32, radix 10) Bounderies" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kHexDecimalMaxNumsStr, kInt32MaxNumsCount, kRadixHexdecimal, hRtlTestResult, kInt32MaxNums), "kRadixHexdecimal", "valueOf(salInt32, radix 16) Bounderies" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32((const char**)kBase36MaxNumsStr, kInt32MaxNumsCount, kRadixBase36, hRtlTestResult, kInt32MaxNums), "kRadixBase36", "valueOf(salInt32, radix 36) Bounderies" ); return ( bRes ); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Int32 i, sal_Int16 radix=2 ) // for negative value // testing the method valueOf( sal_Int32 i, sal_Int16 radix=8 ) // for negative value // testing the method valueOf( sal_Int32 i, sal_Int16 radix=10 ) // for negative value // testing the method valueOf( sal_Int32 i, sal_Int16 radix=16 ) // for negative value // testing the method valueOf( sal_Int32 i, sal_Int16 radix=36 ) // for negative value //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32_Negative( hTestResult hRtlTestResult ) { sal_Bool bRes = sal_False; sal_Int32 inArr[kBase36NumsCount]; sal_Int32 i; for (i = 0; i < kBase36NumsCount; i++ ) inArr[i] = -i; bRes = c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32( kBinaryNumsStr, kBinaryNumsCount, kRadixBinary, hRtlTestResult, inArr ), "negative Int32, kRadixBinary", "valueOf( negative Int32, radix 2 )" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32( kOctolNumsStr, kOctolNumsCount, kRadixOctol, hRtlTestResult, inArr ), "negative Int32, kRadixOctol", "valueOf( negative Int32, radix 8 )" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32( kDecimalNumsStr, kDecimalNumsCount, kRadixDecimal, hRtlTestResult, inArr ), "negative Int32, kRadixDecimal", "valueOf( negative Int32, radix 10 )" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32( kHexDecimalNumsStr, kHexDecimalNumsCount, kRadixHexdecimal, hRtlTestResult, inArr ), "negative Int32, kRadixHexdecimal", "valueOf( negative Int32, radix 16 )" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int32( kBase36NumsStr, kBase36NumsCount, kRadixBase36, hRtlTestResult, inArr ), "negative Int32, kRadixBase36", "valueOf( negative Int32, radix 36 )" ); return ( bRes ); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Int32 l, sal_Int32 radix ) where radix = -5 //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32_WrongRadix( hTestResult hRtlTestResult ) { sal_Bool bRes = sal_False; sal_Int32 intVal = 11; ::rtl::OString aStr1; ::rtl::OString aStr2("11"); aStr1 = aStr1.valueOf( intVal, -5 ); bRes = c_rtl_tres_state ( hRtlTestResult, aStr2.compareTo( aStr1 ) == 0, "if radix not valid then radix must be 10", "valueOf(sal_Int32, sal_Int32 radix): radix = -5" ); return (bRes); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Int32 l, sal_Int32 radix ) // where l = -2147483648 (smallest negative value) //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int32_SmallestNegativeValue( hTestResult hRtlTestResult) { // Standard-conforming way to assign -2147483648 to n: sal_Int32 n = -1; for (int i = 1; i < 32; ++i) n *= 2; return c_rtl_tres_state ( hRtlTestResult, ::rtl::OString::valueOf(n) == "-2147483648", "-2147483648", "valueOf(sal_Int32 -2147483648)" ); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Int64 l, sal_Int16 radix=2 ) // testing the method valueOf( sal_Int64 l, sal_Int16 radix=8 ) // testing the method valueOf( sal_Int64 l, sal_Int16 radix=10 ) // testing the method valueOf( sal_Int64 l, sal_Int16 radix=16 ) // testing the method valueOf( sal_Int64 l, sal_Int16 radix=36 ) //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64( hTestResult hRtlTestResult ) { sal_Bool bRes = sal_False; bRes = c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kBinaryNumsStr, kBinaryNumsCount, kRadixBinary, hRtlTestResult, 0), "kRadixBinary", "valueOf(sal_Int64, radix 2)_" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kOctolNumsStr, kOctolNumsCount, kRadixOctol, hRtlTestResult, 0), "kRadixOctol", "valueOf(sal_Int64, radix 8)_" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kDecimalNumsStr, kDecimalNumsCount, kRadixDecimal, hRtlTestResult, 0), "kRadixDecimal", "valueOf(sal_Int64, radix 10)_" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kHexDecimalNumsStr, kHexDecimalNumsCount, kRadixHexdecimal, hRtlTestResult, 0), "kRadixHexdecimal", "valueOf(sal_Int64, radix 16)_" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kBase36NumsStr, kBase36NumsCount, kRadixBase36, hRtlTestResult, 0), "kRadixBase36", "valueOf(sal_Int64, radix 36)_" ); return (bRes); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Int64 l, sal_Int32 radix=2 ) // where l = large constants // testing the method valueOf( sal_Int64 l, sal_Int32 radix=8 ) // where l = large constants // testing the method valueOf( sal_Int64 l, sal_Int32 radix=10 ) // where l = large constants // testing the method valueOf( sal_Int64 l, sal_Int32 radix=16 ) // where l = large constants // testing the method valueOf( sal_Int64 l, sal_Int32 radix=36 ) // where l = large constants //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64_Bounderies( hTestResult hRtlTestResult ) { sal_Bool bRes = sal_False; bRes = c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kBinaryMaxNumsStr, kInt64MaxNumsCount, kRadixBinary, hRtlTestResult, kInt64MaxNums), "kRadixBinary", "valueOf(salInt64, radix 2) Bounderies" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kOctolMaxNumsStr, kInt64MaxNumsCount, kRadixOctol, hRtlTestResult, kInt64MaxNums), "kRadixOctol", "valueOf(salInt64, radix 8) Bounderies" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kDecimalMaxNumsStr, kInt64MaxNumsCount, kRadixDecimal, hRtlTestResult, kInt64MaxNums), "kRadixDecimal", "valueOf(salInt64, radix 10) Bounderies" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kHexDecimalMaxNumsStr, kInt64MaxNumsCount, kRadixHexdecimal, hRtlTestResult, kInt64MaxNums), "kRadixHexdecimal", "valueOf(salInt64, radix 16) Bounderies" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64((const char**)kBase36MaxNumsStr, kInt64MaxNumsCount, kRadixBase36, hRtlTestResult, kInt64MaxNums), "kRadixBase36", "valueOf(salInt64, radix 36) Bounderies" ); return ( bRes ); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Int64 l, sal_Int16 radix=2 ) // for negative value // testing the method valueOf( sal_Int64 l, sal_Int16 radix=8 ) // for negative value // testing the method valueOf( sal_Int64 l, sal_Int16 radix=10 ) // for negative value // testing the method valueOf( sal_Int64 l, sal_Int16 radix=16 ) // for negative value // testing the method valueOf( sal_Int64 l, sal_Int16 radix=36 ) // for negative value //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64_Negative( hTestResult hRtlTestResult ) { sal_Bool bRes = sal_False; sal_Int64 inArr[36]; sal_Int32 i; for (i = 0; i < 36; i++) { inArr[i] = -i; } bRes = c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64( kBinaryNumsStr, kBinaryNumsCount, kRadixBinary, hRtlTestResult, inArr ), "negative Int64, kRadixBinary", "valueOf( negative Int64, radix 2 )" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64( kOctolNumsStr, kOctolNumsCount, kRadixOctol, hRtlTestResult, inArr ), "negative Int64, kRadixOctol", "valueOf( negative Int64, radix 8 )" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64( kDecimalNumsStr, kDecimalNumsCount, kRadixDecimal, hRtlTestResult, inArr ), "negative Int64, kRadixDecimal", "valueOf( negative Int64, radix 10 )" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64( kHexDecimalNumsStr, kHexDecimalNumsCount, kRadixHexdecimal, hRtlTestResult, inArr ), "negative Int64, kRadixHexDecimal", "valueOf( negative Int64, radix 16 )" ); bRes &= c_rtl_tres_state ( hRtlTestResult, test_valueOf_Int64( kBase36NumsStr, kBase36NumsCount, kRadixBase36, hRtlTestResult, inArr), "negative Int64, kRadixBase36", "valueOf( negative Int64, radix 36 )" ); return (bRes); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Int64 l, sal_Int32 radix ) // where radix = -5 //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64_WrongRadix( hTestResult hRtlTestResult ) { sal_Bool bRes = sal_False; sal_Int64 intVal = 11; ::rtl::OString aStr1; ::rtl::OString aStr2("11"); aStr1 = aStr1.valueOf( intVal, -5 ); bRes = c_rtl_tres_state ( hRtlTestResult, aStr2.compareTo(aStr1) == 0, "if radix not valid then radix must be 10", "valueOf(sal_Int64, sal_Int32 radix): radix = -5" ); return (bRes); } //------------------------------------------------------------------------ // testing the method valueOf( sal_Int64 l, sal_Int32 radix ) // where l = -9223372036854775808 (smallest negative value) //------------------------------------------------------------------------ sal_Bool SAL_CALL test_rtl_OString_valueOf_Int64_SmallestNegativeValue( hTestResult hRtlTestResult) { // Standard-conforming way to assign -9223372036854775808 to n: sal_Int64 n = -1; for (int i = 1; i < 64; ++i) n *= 2; return c_rtl_tres_state ( hRtlTestResult, ::rtl::OString::valueOf(n) == "-9223372036854775808", "-9223372036854775808", "valueOf(sal_Int64 -9223372036854775808)" ); } //------------------------------------------------------------------------ // testing the method valueOf( float f ) //------------------------------------------------------------------------ // LLA: sal_Bool SAL_CALL test_rtl_OString_valueOf_float( // LLA: hTestResult hRtlTestResult ) // LLA: { // LLA: sal_Char methName[MAXBUFLENGTH]; // LLA: sal_Char* pMeth =methName; // LLA: // LLA: typedef struct TestCase // LLA: { // LLA: sal_Char* comments; // LLA: float input1; // LLA: OString* expVal; // LLA: // LLA: ~TestCase() {delete expVal;} // LLA: } TestCase; // LLA: // LLA: TestCase arrTestCase[] = // LLA: { // LLA: { "3.0", 3.0, new OString("3.0") }, // LLA: { "3.5", 3.5f, new OString("3.5")}, // LLA: { "3.0625", 3.0625f, new OString("3.0625")}, // LLA: { "3.502525", 3.502525f, new OString("3.502525") }, // LLA: { "3.141592", 3.141592f, new OString("3.141592") }, // LLA: { "3.5025255", 3.5025255f, new OString("3.5025255") }, // LLA: { "3.0039062", 3.00390625f, new OString("3.0039062") } // LLA: }; // LLA: // LLA: sal_Bool res = sal_True; // LLA: sal_Int32 i; // LLA: // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) // LLA: { // LLA: ::rtl::OString aStr1; // LLA: aStr1 = aStr1.valueOf( arrTestCase[i].input1 ); // LLA: sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0); // LLA: // LLA: c_rtl_tres_state // LLA: ( // LLA: hRtlTestResult, // LLA: lastRes, // LLA: arrTestCase[i].comments, // LLA: createName( pMeth, "valueof_float", i) // LLA: ); // LLA: // LLA: res &= lastRes; // LLA: // LLA: } // LLA: // LLA: return ( res ); // LLA: } //------------------------------------------------------------------------ // testing the method valueOf( float f ) for negative value //------------------------------------------------------------------------ // LLA: sal_Bool SAL_CALL test_rtl_OString_valueOf_Float_Negative( // LLA: hTestResult hRtlTestResult ) // LLA: { // LLA: sal_Char methName[MAXBUFLENGTH]; // LLA: sal_Char* pMeth =methName; // LLA: // LLA: typedef struct TestCase // LLA: { // LLA: sal_Char* comments; // LLA: float input1; // LLA: OString* expVal; // LLA: // LLA: ~TestCase() {delete expVal;} // LLA: } TestCase; // LLA: // LLA: TestCase arrTestCase[] = // LLA: { // LLA: { "-3.0", -3.0, new OString("-3.0") }, // LLA: { "-3.5", -3.5f, new OString("-3.5")}, // LLA: { "-3.0625", -3.0625f, new OString("-3.0625")}, // LLA: { "-3.502525", -3.502525f, new OString("-3.502525") }, // LLA: { "-3.141592", -3.141592f, new OString("-3.141592") }, // LLA: { "-3.5025255", -3.5025255f, new OString("-3.5025255") }, // LLA: { "-3.0039062", -3.00390625f, new OString("-3.0039062") } // LLA: }; // LLA: // LLA: sal_Bool res = sal_True; // LLA: sal_Int32 i; // LLA: // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) // LLA: { // LLA: ::rtl::OString aStr1; // LLA: aStr1 = aStr1.valueOf( arrTestCase[i].input1 ); // LLA: sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0); // LLA: // LLA: c_rtl_tres_state // LLA: ( // LLA: hRtlTestResult, // LLA: lastRes, // LLA: arrTestCase[i].comments, // LLA: createName( pMeth, "valueof_negative float", i) // LLA: ); // LLA: // LLA: res &= lastRes; // LLA: // LLA: } // LLA: // LLA: return ( res ); // LLA: } //------------------------------------------------------------------------ // testing the method valueOf( double f ) //------------------------------------------------------------------------ // LLA: sal_Bool SAL_CALL test_rtl_OString_valueOf_double( // LLA: hTestResult hRtlTestResult ) // LLA: { // LLA: sal_Char methName[MAXBUFLENGTH]; // LLA: sal_Char* pMeth =methName; // LLA: // LLA: typedef struct TestCase // LLA: { // LLA: sal_Char* comments; // LLA: double input1; // LLA: OString* expVal; // LLA: // LLA: ~TestCase() {delete expVal;} // LLA: } TestCase; // LLA: // LLA: TestCase arrTestCase[] = // LLA: { // LLA: {"3.0", 3.0, new OString("3.0")}, // LLA: {"3.5", 3.5, new OString("3.5")}, // LLA: {"3.0625", 3.0625, new OString("3.0625")}, // LLA: {"3.1415926535", 3.1415926535, new OString("3.1415926535")}, // LLA: {"3.1415926535897931", 3.141592653589793, // LLA: new OString("3.1415926535897931")}, // LLA: {"3.1415926535897931", 3.1415926535897932, // LLA: new OString("3.1415926535897931")}, // LLA: {"3.1415926535897931", 3.14159265358979323, // LLA: new OString("3.1415926535897931")}, // LLA: {"3.1415926535897931", 3.141592653589793238462643, // LLA: new OString("3.1415926535897931")} // LLA: }; // LLA: // LLA: sal_Bool res = sal_True; // LLA: sal_Int32 i; // LLA: // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) // LLA: { // LLA: ::rtl::OString aStr1; // LLA: aStr1 = aStr1.valueOf( arrTestCase[i].input1 ); // LLA: sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0); // LLA: // LLA: c_rtl_tres_state // LLA: ( // LLA: hRtlTestResult, // LLA: lastRes, // LLA: arrTestCase[i].comments, // LLA: createName( pMeth, "valueof_double", i) // LLA: ); // LLA: // LLA: res &= lastRes; // LLA: // LLA: } // LLA: // LLA: return ( res ); // LLA: } //------------------------------------------------------------------------ // testing the method valueOf( double f ) for negative value //------------------------------------------------------------------------ // LLA: sal_Bool SAL_CALL test_rtl_OString_valueOf_Double_Negative( // LLA: hTestResult hRtlTestResult ) // LLA: { // LLA: sal_Char methName[MAXBUFLENGTH]; // LLA: sal_Char* pMeth =methName; // LLA: // LLA: typedef struct TestCase // LLA: { // LLA: sal_Char* comments; // LLA: double input1; // LLA: OString* expVal; // LLA: // LLA: ~TestCase() {delete expVal;} // LLA: } TestCase; // LLA: // LLA: TestCase arrTestCase[] = // LLA: { // LLA: {"-3.0", -3.0, new OString("-3.0")}, // LLA: {"-3.5", -3.5, new OString("-3.5")}, // LLA: {"-3.0625", -3.0625, new OString("-3.0625")}, // LLA: {"-3.1415926535", -3.1415926535, new OString("-3.1415926535")}, // LLA: {"-3.1415926535897931", -3.141592653589793, // LLA: new OString("-3.1415926535897931")}, // LLA: {"-3.1415926535897931", -3.1415926535897932, // LLA: new OString("-3.1415926535897931")}, // LLA: {"-3.1415926535897931", -3.14159265358979323, // LLA: new OString("-3.1415926535897931")}, // LLA: {"-3.1415926535897931", -3.141592653589793238462643, // LLA: new OString("-3.1415926535897931")} // LLA: }; // LLA: // LLA: sal_Bool res = sal_True; // LLA: sal_Int32 i; // LLA: // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) // LLA: { // LLA: ::rtl::OString aStr1; // LLA: aStr1 = aStr1.valueOf( arrTestCase[i].input1 ); // LLA: sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0); // LLA: // LLA: c_rtl_tres_state // LLA: ( // LLA: hRtlTestResult, // LLA: lastRes, // LLA: arrTestCase[i].comments, // LLA: createName( pMeth, "valueof_nagative double", i) // LLA: ); // LLA: // LLA: res &= lastRes; // LLA: // LLA: } // LLA: // LLA: return ( res ); // LLA: } //------------------------------------------------------------------------ // testing the method valueOf() //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_valueOf( hTestResult hRtlTestResult ) { c_rtl_tres_state_start(hRtlTestResult, "valueOf"); sal_Bool bTState = test_rtl_OString_valueOf_sal_Bool( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_sal_Char( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int32( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int32_Bounderies( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int32_Negative( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int32_WrongRadix( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int32_SmallestNegativeValue( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int64( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int64_Bounderies( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int64_Negative( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int64_WrongRadix( hRtlTestResult ); bTState &= test_rtl_OString_valueOf_Int64_SmallestNegativeValue( hRtlTestResult ); // LLA: the tests for valueOf(float) and valueOf(double) are moved to file // sal/qa/rtl/ostring/rtl_OString2.cxx // LLA: bTState &= test_rtl_OString_valueOf_float( hRtlTestResult ); // LLA: bTState &= test_rtl_OString_valueOf_Float_Negative( hRtlTestResult ); // LLA: bTState &= test_rtl_OString_valueOf_double( hRtlTestResult ); // LLA: bTState &= test_rtl_OString_valueOf_Double_Negative( hRtlTestResult ); c_rtl_tres_state_end(hRtlTestResult, "valueOf"); // return ( bTState ); } //------------------------------------------------------------------------ // testing the method toChar() //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toChar( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "toChar"); typedef struct TestCase { sal_Char* comments; sal_Char expVal; OString* input1; ~TestCase() {delete input1;} } TestCase; TestCase arrTestCase[] = { {"A", 'A', new OString("A")}, {"a", 'a', new OString("a")}, {"0", '0',new OString("0")}, {"-", '-',new OString("-")}, {"_", '_',new OString("_")}, // TODO: may be UTF-8 values // {"¥", '¥',new OString("¥")}, // { "¦", '¦',new OString("¦")}, // {"ô", 'ô',new OString("ô")}, // {"†", '†',new OString("†")}, {"\n", '\n',new OString("\n")}, {"\'", '\'',new OString("\'")}, {"\"", '\"',new OString("\"")}, {"\0", '\0',new OString("\0")}, {"", '\0',new OString("")}, {"Sun Microsystems", 'S', new OString(kTestStr1)} }; // sal_Bool res = sal_True; sal_uInt32 i; for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++ ) { sal_Char strRes = arrTestCase[i].input1->toChar(); sal_Bool lastRes = ( strRes == arrTestCase[i].expVal ); char com[MAXBUFLENGTH]; com[0] = '\''; cpynstr(com + 1, (*arrTestCase[i].input1), MAXBUFLENGTH); int length = AStringLen( (*arrTestCase[i].input1) ); com[length + 1] = '\''; com[length + 2] = 0; c_rtl_tres_state ( hRtlTestResult, lastRes, com, createName( pMeth, "toChar", i ) ); } c_rtl_tres_state_end(hRtlTestResult, "toChar"); // return (res); } //------------------------------------------------------------------------ // testing the method toFloat() //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toFloat( hTestResult hRtlTestResult ) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "toFloat"); typedef struct TestCase { float expVal; OString* input1; float m_nPrecision; ~TestCase() {delete input1;} } TestCase; TestCase arrTestCase[] = { {3.0f, new OString("3"), 3e-7f}, {3.1f, new OString("3.1"), 3e-7f}, {3.1415f, new OString("3.1415"), 3e-7f}, {3.14159f, new OString("3.14159"), 3e-7f}, {3.141592f, new OString("3.141592"), 3e-7f}, {3.1415926f, new OString("3.1415926"), 3e-7f}, {3.14159265f, new OString("3.14159265"), 3e-7f}, {3.141592653589793238462643f, new OString("3.141592653589793238462643"), 3e-7f}, {6.5822e-16f, new OString("6.5822e-16"), 6e-16f * 1e-7f}, {9.1096e-31f, new OString("9.1096e-31"), 9e-31f * 1e-7f}, {2.997925e8f, new OString("2.997925e8"), 3e8f * 1e-7f}, {6.241e18f, new OString("6.241e18"), 6e18f * 1e-7f}, {3.1f, new OString("03.1"), 3e-7f}, {3.1f, new OString(" 3.1"), 3e-7f}, {-3.1f, new OString("-3.1"), 3e-7f}, {3.1f, new OString("+3.1"), 3e-7f}, {0.0f, new OString("-0.0"), 1e-7f} }; // sal_Bool res = sal_True; sal_uInt32 i; t_print("sizeof(float)=%d, sizeof(double)=%d\n", sizeof(float), sizeof(double)); for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++ ) { float fA = arrTestCase[i].input1->toFloat(); float fB = arrTestCase[i].expVal; float fPrec = arrTestCase[i].m_nPrecision; float fResult = (float) fabs(fA - fB); // t_print("float result: A:(%.9f) B:(%.9f) fabs(A-B):%E\n", fA, fB, fResult); t_print("float result: A:(%E) B:(%E) fabs(A-B):%E\n", fA, fB, (float) fResult); sal_Bool lastRes = ( fResult <= fPrec ); char com[MAXBUFLENGTH]; com[0] = '\''; cpynstr(com + 1, (*arrTestCase[i].input1), MAXBUFLENGTH); int length = AStringLen( (*arrTestCase[i].input1) ); com[length + 1] = '\''; com[length + 2] = 0; c_rtl_tres_state ( hRtlTestResult, lastRes, com, createName( pMeth, "toFloat", i ) ); } c_rtl_tres_state_end(hRtlTestResult, "toFloat"); // return (res); } //------------------------------------------------------------------------ // testing the method toDouble() //------------------------------------------------------------------------ // LLA: extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toDouble( // LLA: hTestResult hRtlTestResult ) // LLA: { // LLA: sal_Char methName[MAXBUFLENGTH]; // LLA: sal_Char* pMeth = methName; // LLA: // LLA: c_rtl_tres_state_start(hRtlTestResult, "toDouble"); // LLA: typedef struct TestCase // LLA: { // LLA: double expVal; // LLA: double expDiff; // LLA: OString* input1; // LLA: ~TestCase() {delete input1;} // LLA: } TestCase; // LLA: // LLA: // LLA: TestCase arrTestCase[] = // LLA: { // LLA: {3.0, 1e-35, new OString("3")}, // LLA: {3.1, 1e-2, new OString("3.1")}, // LLA: {3.1415, 1e-5, new OString("3.1415")}, // LLA: {3.1415926535, 1e-11, new OString("3.1415926535")}, // LLA: {3.141592653589793, 1e-15, // LLA: new OString("3.141592653589793")}, // LLA: {3.1415926535897932, 1e-16, // LLA: new OString("3.1415926535897932")}, // LLA: {3.14159265358979323, 1e-15, // LLA: new OString("3.14159265358979323")}, // LLA: {3.141592653589793238462643, 1e-15, // LLA: new OString("3.141592653589793238462643")}, // LLA: {6.5822e-16, 1e-20, new OString("6.5822e-16")}, // LLA: {9.1096e-31, 1e-35, new OString("9.1096e-31")}, // LLA: {2.997925e8, 10, new OString("2.997925e8")}, // LLA: {6.241e18, 100, new OString("6.241e18")}, // LLA: {1.7e-308, 1e-35, new OString("1.7e-308")}, // LLA: {1.7e+308, 100, new OString("1.7e+308")}, // LLA: {3.1, 1e-2, new OString("03.1")}, // LLA: {3.1, 1e-2, new OString(" 3.1")}, // LLA: {-3.1, 1e-2, new OString("-3.1")}, // LLA: {3.1, 1e-2, new OString("+3.1")}, // LLA: {0.0, 1e-2, new OString("-0.0")} // LLA: }; // LLA: // LLA: sal_Bool res = sal_True; // LLA: sal_Int32 i; // LLA: // LLA: for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++ ) // LLA: { // LLA: double dRes = arrTestCase[i].input1->toDouble(); // LLA: double dErg = dRes - arrTestCase[i].expVal ; // LLA: double dComp = fabs( dErg ); // LLA: sal_Bool lastRes = ( dComp <= arrTestCase[i].expDiff ); // LLA: // LLA: char com[MAXBUFLENGTH]; // LLA: com[0] = '\''; // LLA: cpynstr(com + 1, (*arrTestCase[i].input1), MAXBUFLENGTH); // LLA: int length = AStringLen( (*arrTestCase[i].input1) ); // LLA: com[length + 1] = '\''; // LLA: com[length + 2] = 0; // LLA: // LLA: c_rtl_tres_state // LLA: ( // LLA: hRtlTestResult, // LLA: lastRes, // LLA: com, // LLA: createName( pMeth, "toDouble", i ) // LLA: ); // LLA: // LLA: } // LLA: // LLA: c_rtl_tres_state_end(hRtlTestResult, "toDouble"); // LLA: // return (res); // LLA: } //------------------------------------------------------------------------ // testing the method toBoolean() //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toBoolean( hTestResult hRtlTestResult) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "toBoolean"); typedef struct TestCase { sal_Char* comments; sal_Bool expVal; OString* input; } TestCase; TestCase arrTestCase[]={ {"expected true", sal_True, new OString("True")}, {"expected false", sal_False, new OString("False")}, {"expected true", sal_True, new OString("1")} }; sal_Bool res = sal_True; sal_uInt32 i; for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { sal_Bool bRes = arrTestCase[i].input->toBoolean(); sal_Bool lastRes = (bRes == arrTestCase[i].expVal); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "toBoolean", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "toBoolean"); // return ( res ); } //------------------------------------------------------------------------ // testing the method toInt32( sal_Int16 radix = 2,8,10,16,36 ) //------------------------------------------------------------------------ sal_Bool test_toInt32( int num, const sal_Char** in, const sal_Int32 *expVal,sal_Int16 radix, hTestResult hRtlTestResult ) { sal_Bool res = sal_True; sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; sal_Int32 i; for( i = 0; i < num; i++ ) { OString str(in[i]); sal_Int32 intRes = str.toInt32(radix); sal_Bool lastRes = (intRes == expVal[i]); char buf[MAXBUFLENGTH]; buf[0] = '\''; cpynstr( buf + 1, in[i], MAXBUFLENGTH ); int length = AStringLen( in[i] ); buf[length + 1] = '\''; buf[length + 2] = 0; c_rtl_tres_state ( hRtlTestResult, lastRes, buf, createName( pMeth,"toInt32", i ) ); res &= lastRes; } return( res ); } sal_Bool SAL_CALL test_rtl_OString_toInt32_wrongRadix( hTestResult hRtlTestResult ) { ::rtl::OString str("0"); sal_Int32 iRes = str.toInt32(-1); return ( c_rtl_tres_state ( hRtlTestResult, iRes == 0, "wrong radix -1", "toInt32( 0, wrong radix -1 )" ) ); } extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toInt32( hTestResult hRtlTestResult ) { sal_Int32 expValues[kBase36NumsCount]; sal_Int32 i; c_rtl_tres_state_start(hRtlTestResult, "toInt32"); for ( i = 0; i < kBase36NumsCount; i++ ) expValues[i] = i; sal_Bool res = c_rtl_tres_state ( hRtlTestResult, test_toInt32( kBinaryNumsCount, kBinaryNumsStr, expValues, kRadixBinary, hRtlTestResult ), "kBinaryNumsStr", "toInt32( radix 2 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( kInt32MaxNumsCount, kBinaryMaxNumsStr, kInt32MaxNums, kRadixBinary, hRtlTestResult ), "kBinaryMaxNumsStr", "toInt32_Boundaries( radix 2 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( kOctolNumsCount, kOctolNumsStr, expValues, kRadixOctol, hRtlTestResult ), "kOctolNumsStr", "toInt32( radix 8 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( kInt32MaxNumsCount, kOctolMaxNumsStr, (sal_Int32*)kInt32MaxNums, kRadixOctol, hRtlTestResult ), "kOctolMaxNumsStr", "toInt32_Boundaries( radix 8 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( kDecimalNumsCount, kDecimalNumsStr, expValues, kRadixDecimal, hRtlTestResult ), "kDecimalNumsStr", "toInt32( radix 10 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( kInt32MaxNumsCount, kDecimalMaxNumsStr, (sal_Int32*)kInt32MaxNums, kRadixDecimal, hRtlTestResult ), "kDecimalMaxNumsStr", "toInt32_Boundaries( radix 10 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( kHexDecimalNumsCount, kHexDecimalNumsStr, expValues, kRadixHexdecimal, hRtlTestResult ), "kHexDecimalNumsStr", "toInt32( radix 16 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( kInt32MaxNumsCount, kHexDecimalMaxNumsStr, (sal_Int32*)kInt32MaxNums, kRadixHexdecimal, hRtlTestResult ), "kHexDecimalMaxNumsStr", "toInt32_Boundaries( radix 16 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( kBase36NumsCount, kBase36NumsStr, expValues, kRadixBase36, hRtlTestResult ), "kBase36NumsStr", "toInt32( radix 36 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( kInt32MaxNumsCount, kBase36MaxNumsStr, (sal_Int32*)kInt32MaxNums, kRadixBase36, hRtlTestResult ), "kBase36MaxNumsStr", "toInt32_Boundaries( radix 36 )" ); const sal_Int16 nSpecCases = 5; static const sal_Char *spString[nSpecCases] = { "-1", "+1", " 1", " -1", "001" }; sal_Int32 expSpecVal[nSpecCases] = { -1, 1, 1, -1, 1 }; res &= c_rtl_tres_state ( hRtlTestResult, test_toInt32( nSpecCases, spString, expSpecVal, kRadixDecimal, hRtlTestResult ), "special cases", "toInt32( specialcases )" ); res &= test_rtl_OString_toInt32_wrongRadix( hRtlTestResult ); c_rtl_tres_state_end(hRtlTestResult, "toInt32"); // return ( res ); } //------------------------------------------------------------------------ // testing the method toInt64( sal_Int16 radix = 2,8,10,16,36 ) //------------------------------------------------------------------------ sal_Bool test_toInt64( int num, const sal_Char** in, const sal_Int64 *expVal,sal_Int16 radix, hTestResult hRtlTestResult ) { sal_Bool res = sal_True; sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; sal_Int32 i; for( i = 0; i < num; i++ ) { OString str( in[i] ); sal_Int64 intRes = str.toInt64( radix ); sal_Bool lastRes = ( intRes == expVal[i] ); char buf[MAXBUFLENGTH]; buf[0] = '\''; cpynstr( buf + 1, in[i], MAXBUFLENGTH ); int length = AStringLen(in[i]); buf[length + 1] = '\''; buf[length + 2] = 0; c_rtl_tres_state ( hRtlTestResult, lastRes, buf, createName( pMeth, "toInt64", i ) ); res &= lastRes; } return (res); } sal_Bool SAL_CALL test_rtl_OString_toInt64_wrongRadix( hTestResult hRtlTestResult ) { ::rtl::OString str("0"); sal_Int64 iRes = str.toInt64(-1); return ( c_rtl_tres_state ( hRtlTestResult, iRes == 0, "wrong radix -1", "toInt64( wrong radix -1)" ) ); } extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_toInt64( hTestResult hRtlTestResult ) { sal_Int64 expValues[kBase36NumsCount]; sal_Int32 i; c_rtl_tres_state_start(hRtlTestResult, "toInt64"); for (i = 0; i < kBase36NumsCount; expValues[i] = i, i++); sal_Bool res = c_rtl_tres_state ( hRtlTestResult, test_toInt64( kBinaryNumsCount, kBinaryNumsStr, expValues, kRadixBinary, hRtlTestResult ), "kBinaryNumsStr", "toInt64( radix 2 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( kInt32MaxNumsCount, kBinaryMaxNumsStr, (sal_Int64*)kInt64MaxNums, kRadixBinary, hRtlTestResult ), "kBinaryMaxNumsStr", "toInt64_Boundaries( radix 2 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( kOctolNumsCount, kOctolNumsStr, expValues, kRadixOctol, hRtlTestResult ), "kOctolNumsStr", "toInt64( radix 8 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( kInt32MaxNumsCount, kOctolMaxNumsStr, (sal_Int64*)kInt64MaxNums, kRadixOctol, hRtlTestResult ), "kOctolMaxNumsStr", "toInt64_Boundaries( radix 8 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( kDecimalNumsCount, kDecimalNumsStr, expValues, kRadixDecimal, hRtlTestResult ), "kDecimalNumsStr", "toInt64( radix 10 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( kInt32MaxNumsCount, kDecimalMaxNumsStr, (sal_Int64*)kInt64MaxNums, kRadixDecimal, hRtlTestResult ), "kDecimalMaxNumsStr", "toInt64_Boundaries( radix 10 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( kHexDecimalNumsCount, kHexDecimalNumsStr, expValues, kRadixHexdecimal, hRtlTestResult ), "kHexDecimalNumsStr", "toInt64( radix 16 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( kInt32MaxNumsCount, kHexDecimalMaxNumsStr, (sal_Int64*)kInt64MaxNums, kRadixHexdecimal, hRtlTestResult ), "kHexDecimalMaxNumsStr", "toInt64_Boundaries( radix 16 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( kBase36NumsCount, kBase36NumsStr, expValues, kRadixBase36, hRtlTestResult ), "kBase36NumsStr", "toInt64( radix 36 )" ); res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( kInt32MaxNumsCount, kBase36MaxNumsStr, (sal_Int64*)kInt64MaxNums, kRadixBase36, hRtlTestResult ), "kBase36MaxNumsStr", "toInt64_Boundaries( radix 36 )" ); const sal_Int16 nSpecCases = 5; static const sal_Char *spString[nSpecCases] = { "-1", "+1", " 1", " -1", "001" }; sal_Int64 expSpecVal[nSpecCases] = { -1, 1, 1, -1, 1 }; res &= c_rtl_tres_state ( hRtlTestResult, test_toInt64( nSpecCases, spString, expSpecVal, kRadixDecimal, hRtlTestResult ), "special cases", "toInt64( specialcases )" ); res &= test_rtl_OString_toInt64_wrongRadix( hRtlTestResult ); c_rtl_tres_state_end(hRtlTestResult, "toInt64"); // return (res); } //------------------------------------------------------------------------ // testing the method replace( sal_Char oldChar, sal_Char newChar ) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_replace( hTestResult hRtlTestResult) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "replace"); typedef struct TestCase { sal_Char* comments; OString* expVal; OString* input; sal_Char oldChar; sal_Char newChar; ~TestCase() { delete input; delete expVal;} } TestCase; TestCase arrTestCase[]={ {"string differs", new OString(kTestStr18), new OString(kTestStr4),'S','s'}, {"string differs", new OString(kTestStr19), new OString(kTestStr17),(sal_Char)' ',(sal_Char)'-'}, {"same string, no replace ", new OString(kTestStr22), new OString(kTestStr22),'*','8'} }; sal_Bool res = sal_True; sal_uInt32 i; for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { ::rtl::OString aStr1; aStr1= arrTestCase[i].input->replace(arrTestCase[i].oldChar, arrTestCase[i].newChar); res &= c_rtl_tres_state ( hRtlTestResult, (arrTestCase[i].expVal->compareTo(aStr1) == 0), arrTestCase[i].comments, createName( pMeth, "replace", i ) ); } c_rtl_tres_state_end(hRtlTestResult, "replace"); // return ( res ); } //------------------------------------------------------------------------ // testing the method replaceAt( sal_Int32 index, sal_Int32 count, // const OString& newStr ) //------------------------------------------------------------------------ extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString_replaceAt( hTestResult hRtlTestResult) { sal_Char methName[MAXBUFLENGTH]; sal_Char* pMeth = methName; c_rtl_tres_state_start(hRtlTestResult, "replaceAt"); typedef struct TestCase { sal_Char* comments; OString* expVal; OString* input; OString* newStr; sal_Int32 index; sal_Int32 count; ~TestCase() { delete input; delete expVal; delete newStr;} } TestCase; TestCase arrTestCase[]= { { "string differs", new OString(kTestStr2), new OString(kTestStr22), new OString(kTestStr2), 0, kTestStr22Len }, { "larger index", new OString(kTestStr1), new OString(kTestStr7), new OString(kTestStr8), 64, kTestStr8Len }, { "larger count", new OString(kTestStr2), new OString(kTestStr22), new OString(kTestStr2),0, 64 }, { "navigate index", new OString(kTestStr2), new OString(kTestStr22), new OString(kTestStr2), -64, 64 }, { "null string", new OString(""), new OString(kTestStr14),new OString(""), 0, kTestStr14Len } }; sal_Bool res = sal_True; sal_uInt32 i; for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++) { ::rtl::OString aStr1; aStr1= arrTestCase[i].input->replaceAt( arrTestCase[i].index, arrTestCase[i].count, *arrTestCase[i].newStr ); sal_Bool lastRes = ( arrTestCase[i].expVal->compareTo(aStr1) == 0 ); c_rtl_tres_state ( hRtlTestResult, lastRes, arrTestCase[i].comments, createName( pMeth, "replaceAt", i ) ); res &= lastRes; } c_rtl_tres_state_end(hRtlTestResult, "replaceAt"); // return ( res ); } extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OString( hTestResult hRtlTestResult ) { c_rtl_tres_state_start(hRtlTestResult, "rtl_OString" ); test_rtl_OString_ctors( hRtlTestResult ); test_rtl_OString_getLength( hRtlTestResult ); test_rtl_OString_equals( hRtlTestResult ); test_rtl_OString_equalsIgnoreAsciiCase( hRtlTestResult ); test_rtl_OString_compareTo( hRtlTestResult ); test_rtl_OString_op_cmp( hRtlTestResult ); test_rtl_OString_op_neq( hRtlTestResult ); test_rtl_OString_op_g( hRtlTestResult ); test_rtl_OString_op_l( hRtlTestResult ); test_rtl_OString_op_ge( hRtlTestResult ); test_rtl_OString_op_le( hRtlTestResult ); test_rtl_OString_op_eq( hRtlTestResult ); test_rtl_OString_op_plus( hRtlTestResult ); test_rtl_OString_op_peq( hRtlTestResult ); test_rtl_OString_op_cscs( hRtlTestResult ); test_rtl_OString_getStr( hRtlTestResult ); test_rtl_OString_copy( hRtlTestResult ); test_rtl_OString_concat( hRtlTestResult ); test_rtl_OString_toAsciiLowerCase( hRtlTestResult ); test_rtl_OString_toAsciiUpperCase( hRtlTestResult ); test_rtl_OString_trim( hRtlTestResult ); test_rtl_OString_valueOf( hRtlTestResult ); test_rtl_OString_toChar( hRtlTestResult ); test_rtl_OString_toFloat( hRtlTestResult ); // LLA: test_rtl_OString_toDouble( hRtlTestResult ); test_rtl_OString_toBoolean( hRtlTestResult ); test_rtl_OString_toInt32( hRtlTestResult ); test_rtl_OString_toInt64( hRtlTestResult ); test_rtl_OString_replace( hRtlTestResult ); test_rtl_OString_replaceAt( hRtlTestResult ); c_rtl_tres_state_end(hRtlTestResult, "rtl_OString"); } // ----------------------------------------------------------------------------- void RegisterAdditionalFunctions(FktRegFuncPtr _pFunc) { if (_pFunc) { (_pFunc)(&test_rtl_OString, ""); //# (_pFunc)(&test_rtl_OString_ctors, ""); //# (_pFunc)(&test_rtl_OString_getLength, ""); //# (_pFunc)(&test_rtl_OString_equals, ""); //# (_pFunc)(&test_rtl_OString_equalsIgnoreAsciiCase, ""); //# (_pFunc)(&test_rtl_OString_compareTo, ""); //# (_pFunc)(&test_rtl_OString_op_cmp, ""); //# (_pFunc)(&test_rtl_OString_op_neq, ""); //# (_pFunc)(&test_rtl_OString_op_g, ""); //# (_pFunc)(&test_rtl_OString_op_l, ""); //# (_pFunc)(&test_rtl_OString_op_ge, ""); //# (_pFunc)(&test_rtl_OString_op_le, ""); //# (_pFunc)(&test_rtl_OString_op_eq, ""); //# (_pFunc)(&test_rtl_OString_op_plus, ""); //# (_pFunc)(&test_rtl_OString_op_peq, ""); //# (_pFunc)(&test_rtl_OString_op_cscs, ""); //# (_pFunc)(&test_rtl_OString_getStr, ""); //# (_pFunc)(&test_rtl_OString_copy, ""); //# (_pFunc)(&test_rtl_OString_concat, ""); //# (_pFunc)(&test_rtl_OString_toAsciiLowerCase, ""); //# (_pFunc)(&test_rtl_OString_toAsciiUpperCase, ""); //# (_pFunc)(&test_rtl_OString_trim, ""); //# (_pFunc)(&test_rtl_OString_valueOf, ""); //# (_pFunc)(&test_rtl_OString_toChar, ""); //# (_pFunc)(&test_rtl_OString_toFloat, ""); //# (_pFunc)(&test_rtl_OString_toDouble, ""); //# (_pFunc)(&test_rtl_OString_toBoolean, ""); //# (_pFunc)(&test_rtl_OString_toInt32, ""); //# (_pFunc)(&test_rtl_OString_toInt64, ""); //# (_pFunc)(&test_rtl_OString_replace, ""); //# (_pFunc)(&test_rtl_OString_replaceAt, ""); } } /* D:\local\644\SRX644\sal\qa\rtl_OString.cxx(3559) : error C2664: 'unsigned char (void (__cdecl *)(void *),const char *)' : cannot convert parameter 1 from 'unsigned char (__cdecl *)(void *)' to 'void (__cdecl *)(void *)' This conversion requires a reinterpret_cast, a C-style cast or function- style cast */