| /************************************************************** |
| * |
| * 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" |
| // autogenerated file with codegen.pl |
| |
| #include <math.h> |
| #include <stdio.h> |
| |
| #include <algorithm> // STL |
| |
| #include "gtest/gtest.h" |
| #include "stringhelper.hxx" |
| #include "valueequal.hxx" |
| |
| inline void printOUString( ::rtl::OUString const & _suStr ) |
| { |
| rtl::OString aString; |
| |
| printf( "OUString: " ); |
| aString = ::rtl::OUStringToOString( _suStr, RTL_TEXTENCODING_ASCII_US ); |
| printf( "'%s'\n", aString.getStr( ) ); |
| } |
| |
| namespace rtl_OUString |
| { |
| |
| class ctors_rtl_uString : public ::testing::Test |
| { |
| public: |
| }; |
| |
| /// test of OUString(rtl_uString*) |
| TEST_F(ctors_rtl_uString, ctors_001) |
| { |
| rtl::OUString *pStr = new rtl::OUString( rtl::OUString::createFromAscii("a String") ); |
| |
| rtl::OUString aStrToTest(pStr->pData); |
| delete pStr; |
| |
| // maybe here should we do something with current memory |
| char* pBuffer = (char*) malloc(2 * 8); |
| memset(pBuffer, 0, 2 * 8); |
| free(pBuffer); |
| |
| sal_Bool bResult = aStrToTest.equals(rtl::OUString::createFromAscii("a String")); |
| ASSERT_TRUE(bResult == sal_True) << "String must not be empty"; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| class valueOf : public ::testing::Test |
| { |
| protected: |
| void valueOf_float_test_impl(float _nValue) |
| { |
| rtl::OUString suValue; |
| suValue = rtl::OUString::valueOf( _nValue ); |
| rtl::OString sValue; |
| sValue <<= suValue; |
| printf("nFloat := %.9f sValue := %s\n", _nValue, sValue.getStr()); |
| |
| float nValueATOF = static_cast<float>(atof( sValue.getStr() )); |
| |
| bool bEqualResult = is_float_equal(_nValue, nValueATOF); |
| ASSERT_TRUE(bEqualResult == true) << "Values are not equal."; |
| } |
| |
| void valueOf_float_test(float _nValue) |
| { |
| valueOf_float_test_impl(_nValue); |
| |
| // test also the negative part. |
| float nNegativeValue = -_nValue; |
| valueOf_float_test_impl(nNegativeValue); |
| } |
| |
| protected: |
| |
| void valueOf_double_test_impl(double _nValue) |
| { |
| rtl::OUString suValue; |
| suValue = rtl::OUString::valueOf( _nValue ); |
| rtl::OString sValue; |
| sValue <<= suValue; |
| printf("nDouble := %.20f sValue := %s\n", _nValue, sValue.getStr()); |
| |
| double nValueATOF = atof( sValue.getStr() ); |
| |
| bool bEqualResult = is_double_equal(_nValue, nValueATOF); |
| ASSERT_TRUE(bEqualResult == true) << "Values are not equal."; |
| } |
| |
| void valueOf_double_test(double _nValue) |
| { |
| valueOf_double_test_impl(_nValue); |
| |
| // test also the negative part. |
| double nNegativeValue = -_nValue; |
| valueOf_double_test_impl(nNegativeValue); |
| } |
| }; // class valueOf |
| |
| TEST_F(valueOf, valueOf_float_test_001) |
| { |
| // this is demonstration code |
| // ASSERT_TRUE(1 == 1) << "a message"; |
| float nValue = 3.0f; |
| valueOf_float_test(nValue); |
| } |
| |
| TEST_F(valueOf, valueOf_float_test_002) |
| { |
| float nValue = 3.5f; |
| valueOf_float_test(nValue); |
| } |
| |
| TEST_F(valueOf, valueOf_float_test_003) |
| { |
| float nValue = 3.0625f; |
| valueOf_float_test(nValue); |
| } |
| |
| TEST_F(valueOf, valueOf_float_test_004) |
| { |
| float nValue = 3.502525f; |
| valueOf_float_test(nValue); |
| } |
| |
| TEST_F(valueOf, valueOf_float_test_005) |
| { |
| float nValue = 3.141592f; |
| valueOf_float_test(nValue); |
| } |
| |
| TEST_F(valueOf, valueOf_float_test_006) |
| { |
| float nValue = 3.5025255f; |
| valueOf_float_test(nValue); |
| } |
| |
| TEST_F(valueOf, valueOf_float_test_007) |
| { |
| float nValue = 3.0039062f; |
| valueOf_float_test(nValue); |
| } |
| |
| // valueOf double |
| TEST_F(valueOf, valueOf_double_test_001) |
| { |
| double nValue = 3.0; |
| valueOf_double_test(nValue); |
| } |
| TEST_F(valueOf, valueOf_double_test_002) |
| { |
| double nValue = 3.5; |
| valueOf_double_test(nValue); |
| } |
| TEST_F(valueOf, valueOf_double_test_003) |
| { |
| double nValue = 3.0625; |
| valueOf_double_test(nValue); |
| } |
| TEST_F(valueOf, valueOf_double_test_004) |
| { |
| double nValue = 3.1415926535; |
| valueOf_double_test(nValue); |
| } |
| TEST_F(valueOf, valueOf_double_test_005) |
| { |
| double nValue = 3.141592653589793; |
| valueOf_double_test(nValue); |
| } |
| TEST_F(valueOf, valueOf_double_test_006) |
| { |
| double nValue = 3.1415926535897932; |
| valueOf_double_test(nValue); |
| } |
| TEST_F(valueOf, valueOf_double_test_007) |
| { |
| double nValue = 3.14159265358979323; |
| valueOf_double_test(nValue); |
| } |
| TEST_F(valueOf, valueOf_double_test_008) |
| { |
| double nValue = 3.141592653589793238462643; |
| valueOf_double_test(nValue); |
| } |
| |
| //------------------------------------------------------------------------ |
| // testing the method toDouble() |
| //------------------------------------------------------------------------ |
| template<class T> |
| sal_Int16 SAL_CALL checkPrecisionSize() |
| { |
| // sal_Int16 nSize = sizeof(T); |
| volatile T nCalcValue = 1.0; |
| |
| |
| // (i + 1) is the current precision |
| // numerical series |
| // 1.1 |
| // 10.1 |
| // 100.1 |
| // ... |
| // 1000...0.1 |
| |
| sal_Int16 i = 0; |
| for (i=0;i<50;i++) |
| { |
| nCalcValue *= 10; |
| volatile T nValue = nCalcValue + static_cast<T>(0.1); |
| volatile T dSub = nValue - nCalcValue; |
| // ----- 0.11 ---- 0.1 ---- 0.09 ----- |
| if (0.11 > dSub && dSub < 0.09) |
| { |
| // due to the fact, that the value is break down we sub 1 from the precision value |
| // but to suppress this, we start at zero, precision is i+1 till here --i; |
| break; |
| } |
| } |
| |
| sal_Int16 j= 0; |
| nCalcValue = 1.0; |
| |
| // numerical series |
| // 1.1 |
| // 1.01 |
| // 1.001 |
| // ... |
| // 1.000...001 |
| |
| for (j=0;j<50;j++) |
| { |
| nCalcValue /= 10; |
| volatile T nValue = nCalcValue + static_cast<T>(1.0); |
| volatile T dSub = nValue - static_cast<T>(1.0); |
| // ---- 0.02 ----- 0.01 ---- 0 --- -0.99 ---- -0.98 ---- |
| // volatile T dSubAbsolut = fabs(dSub); |
| // ---- 0.02 ----- 0.01 ---- 0 (cut) |
| if ( dSub == 0) |
| break; |
| } |
| if (i != j) |
| { |
| // hmmm.... |
| // imho i +- 1 == j is a good value |
| int n = i - j; |
| if (n < 0) n = -n; |
| if (n <= 1) |
| { |
| return std::min(i,j); |
| } |
| else |
| { |
| printf("warning: presision differs more than 1!\n"); |
| } |
| } |
| |
| return i; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| class testPrecision |
| { |
| public: |
| testPrecision() |
| { |
| sal_Int16 nPrecision; |
| nPrecision = checkPrecisionSize<float>(); |
| printf("precision of float: %d sizeof()=%lu \n", nPrecision, sizeof(float)); |
| |
| nPrecision = checkPrecisionSize<double>(); |
| printf("precision of double: %d sizeof()=%lu \n", nPrecision, sizeof(double)); |
| |
| nPrecision = checkPrecisionSize<long double>(); |
| printf("precision of long double: %d sizeof()=%lu \n", nPrecision, sizeof(long double)); |
| |
| } |
| |
| }; |
| |
| class toInt: public ::testing::Test { |
| public: |
| }; |
| |
| TEST_F(toInt, test) { |
| ASSERT_EQ( |
| static_cast< sal_Int32 >(-0x76543210), |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("-76543210")). |
| toInt32(16))); |
| ASSERT_EQ( |
| static_cast< sal_Int32 >(0xFEDCBA98), |
| (rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("+FEDCBA98")). |
| toInt32(16))); |
| ASSERT_EQ( |
| static_cast< sal_Int64 >(-SAL_CONST_INT64(0x76543210FEDCBA98)), |
| (rtl::OUString( |
| RTL_CONSTASCII_USTRINGPARAM("-76543210FEDCBA98")). |
| toInt64(16))); |
| ASSERT_EQ( |
| static_cast< sal_Int64 >(SAL_CONST_INT64(0xFEDCBA9876543210)), |
| (rtl::OUString( |
| RTL_CONSTASCII_USTRINGPARAM("+FEDCBA9876543210")). |
| toInt64(16))); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // - toDouble (tests) |
| // ----------------------------------------------------------------------------- |
| class toDouble : public ::testing::Test |
| { |
| public: |
| void toDouble_test_impl(rtl::OString const& _sValue) |
| { |
| //printf("the original str is %s\n", _sValue.getStr()); |
| double nValueATOF = atof( _sValue.getStr() ); |
| //printf("original data is %e\n", nValueATOF); |
| rtl::OUString suValue = rtl::OUString::createFromAscii( _sValue.getStr() ); |
| double nValueToDouble = suValue.toDouble(); |
| //printf("result data is %e\n", nValueToDouble); |
| |
| bool bEqualResult = is_double_equal(nValueToDouble, nValueATOF); |
| ASSERT_TRUE(bEqualResult == true) << "Values are not equal."; |
| } |
| |
| void toDouble_test(rtl::OString const& _sValue) |
| { |
| toDouble_test_impl(_sValue); |
| |
| // test also the negativ part. |
| rtl::OString sNegativValue("-"); |
| sNegativValue += _sValue; |
| toDouble_test_impl(sNegativValue); |
| } |
| }; // class toDouble |
| |
| TEST_F(toDouble, toDouble_selftest) |
| { |
| printf("Start selftest:\n"); |
| ASSERT_TRUE (is_double_equal(1.0, 1.01) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.0001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.00001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.000001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.0000001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.00000001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.000000001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.0000000001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.00000000001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.000000000001) == false); |
| ASSERT_TRUE (is_double_equal(1.0, 1.0000000000001) == false); |
| // we check til 15 values after comma |
| ASSERT_TRUE (is_double_equal(1.0, 1.00000000000001) == true); |
| ASSERT_TRUE (is_double_equal(1.0, 1.000000000000001) == true); |
| ASSERT_TRUE (is_double_equal(1.0, 1.0000000000000001) == true); |
| printf("Selftest done.\n"); |
| } |
| |
| TEST_F(toDouble, toDouble_test_3) |
| { |
| rtl::OString sValue("3"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_3_5) |
| { |
| rtl::OString sValue("3.5"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_3_0625) |
| { |
| rtl::OString sValue("3.0625"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_pi) |
| { |
| // value from http://www.angio.net/pi/digits/50.txt |
| rtl::OString sValue("3.141592653589793238462643383279502884197169399375"); |
| toDouble_test(sValue); |
| } |
| |
| TEST_F(toDouble, toDouble_test_1) |
| { |
| rtl::OString sValue("1"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_10) |
| { |
| rtl::OString sValue("10"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_100) |
| { |
| rtl::OString sValue("100"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_1000) |
| { |
| rtl::OString sValue("1000"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_10000) |
| { |
| rtl::OString sValue("10000"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_1e99) |
| { |
| rtl::OString sValue("1e99"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_1e_n99) |
| { |
| rtl::OString sValue("1e-99"); |
| toDouble_test(sValue); |
| } |
| TEST_F(toDouble, toDouble_test_1e308) |
| { |
| rtl::OString sValue("1e308"); |
| toDouble_test(sValue); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // - toFloat (tests) |
| // ----------------------------------------------------------------------------- |
| class toFloat : public ::testing::Test |
| { |
| public: |
| void toFloat_test_impl(rtl::OString const& _sValue) |
| { |
| //printf("the original str is %s\n", _sValue.getStr()); |
| float nValueATOF = static_cast<float>(atof( _sValue.getStr() )); |
| //printf("the original str is %.10f\n", nValueATOF); |
| rtl::OUString suValue = rtl::OUString::createFromAscii( _sValue.getStr() ); |
| float nValueToFloat = suValue.toFloat(); |
| //printf("the result str is %.10f\n", nValueToFloat); |
| |
| bool bEqualResult = is_float_equal(nValueToFloat, nValueATOF); |
| ASSERT_TRUE(bEqualResult == true) << "Values are not equal."; |
| } |
| |
| void toFloat_test(rtl::OString const& _sValue) |
| { |
| toFloat_test_impl(_sValue); |
| |
| // test also the negativ part. |
| rtl::OString sNegativValue("-"); |
| sNegativValue += _sValue; |
| toFloat_test_impl(sNegativValue); |
| } |
| }; // class toFloat |
| |
| TEST_F(toFloat, toFloat_selftest) |
| { |
| printf("Start selftest:\n"); |
| ASSERT_TRUE (is_float_equal(1.0f, 1.01f) == false); |
| ASSERT_TRUE (is_float_equal(1.0f, 1.001f) == false); |
| ASSERT_TRUE (is_float_equal(1.0f, 1.0001f) == false); |
| ASSERT_TRUE (is_float_equal(1.0f, 1.00001f) == false); |
| ASSERT_TRUE (is_float_equal(1.0f, 1.000002f) == false); |
| ASSERT_TRUE (is_float_equal(1.0f, 1.0000001f) == true); |
| ASSERT_TRUE (is_float_equal(1.0f, 1.00000001f) == true); |
| ASSERT_TRUE (is_float_equal(1.0f, 1.000000001f) == true); |
| |
| printf("Selftest done.\n"); |
| } |
| |
| TEST_F(toFloat, toFloat_test_3) |
| { |
| rtl::OString sValue("3"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_3_5) |
| { |
| rtl::OString sValue("3.5"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_3_0625) |
| { |
| rtl::OString sValue("3.0625"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_3_0625_e) |
| { |
| rtl::OString sValue("3.0625e-4"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_pi) |
| { |
| // value from http://www.angio.net/pi/digits/50.txt |
| rtl::OString sValue("3.141592653589793238462643383279502884197169399375"); |
| toFloat_test(sValue); |
| } |
| |
| TEST_F(toFloat, toFloat_test_1) |
| { |
| rtl::OString sValue("1"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_10) |
| { |
| rtl::OString sValue("10"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_100) |
| { |
| rtl::OString sValue("100"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_1000) |
| { |
| rtl::OString sValue("1000"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_10000) |
| { |
| rtl::OString sValue("10000"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_mix) |
| { |
| rtl::OString sValue("456789321455.123456789012"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_1e99) |
| { |
| rtl::OString sValue("1e99"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_1e_n99) |
| { |
| rtl::OString sValue("1e-9"); |
| toFloat_test(sValue); |
| } |
| TEST_F(toFloat, toFloat_test_1e308) |
| { |
| rtl::OString sValue("1e308"); |
| toFloat_test(sValue); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // - lastIndexOf (tests) |
| // ----------------------------------------------------------------------------- |
| class lastIndexOf : public ::testing::Test |
| { |
| public: |
| void lastIndexOf_oustring(rtl::OUString const& _suStr, rtl::OUString const& _suSearchStr, sal_Int32 _nExpectedResultPos) |
| { |
| // Algorithm |
| // search the string _suSearchStr (rtl::OUString) in the string _suStr. |
| // check if the _nExpectedResultPos occurs. |
| |
| sal_Int32 nPos = _suStr.lastIndexOf(_suSearchStr); |
| ASSERT_TRUE(nPos == _nExpectedResultPos) << "expected position is wrong"; |
| } |
| |
| void lastIndexOf_salunicode(rtl::OUString const& _suStr, sal_Unicode _cuSearchChar, sal_Int32 _nExpectedResultPos) |
| { |
| // Algorithm |
| // search the unicode char _suSearchChar (sal_Unicode) in the string _suStr. |
| // check if the _nExpectedResultPos occurs. |
| |
| sal_Int32 nPos = _suStr.lastIndexOf(_cuSearchChar); |
| ASSERT_TRUE(nPos == _nExpectedResultPos) << "expected position is wrong"; |
| } |
| |
| void lastIndexOf_oustring_offset(rtl::OUString const& _suStr, rtl::OUString const& _suSearchStr, sal_Int32 _nExpectedResultPos, sal_Int32 _nStartOffset) |
| { |
| sal_Int32 nPos = _suStr.lastIndexOf(_suSearchStr, _nStartOffset); |
| ASSERT_TRUE(nPos == _nExpectedResultPos) << "expected position is wrong"; |
| } |
| |
| void lastIndexOf_salunicode_offset(rtl::OUString const& _suStr, sal_Unicode _cuSearchChar, sal_Int32 _nExpectedResultPos, sal_Int32 _nStartOffset) |
| { |
| sal_Int32 nPos = _suStr.lastIndexOf(_cuSearchChar, _nStartOffset); |
| ASSERT_TRUE(nPos == _nExpectedResultPos) << "expected position is wrong"; |
| } |
| }; // class lastIndexOf |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_offset_001) |
| { |
| // search for sun, start at the end, found (pos==0) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring_offset(aStr, aSearchStr, 0, aStr.getLength()); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_offset_002) |
| { |
| // search for sun, start at pos = 3, found (pos==0) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring_offset(aStr, aSearchStr, 0, 3); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_offset_003) |
| { |
| // search for sun, start at pos = 2, found (pos==-1) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring_offset(aStr, aSearchStr, -1, 2); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_offset_004) |
| { |
| // search for sun, start at the end, found (pos==0) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring_offset(aStr, aSearchStr, -1, -1); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_001) |
| { |
| // search for sun, found (pos==0) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("sun java system"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring(aStr, aSearchStr, 0); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_002) |
| { |
| // search for sun, found (pos==4) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the sun java system"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring(aStr, aSearchStr, 4); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_003) |
| { |
| // search for sun, found (pos==8) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring(aStr, aSearchStr, 8); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_004) |
| { |
| // search for sun, found (pos==8) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring(aStr, aSearchStr, 8); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_005) |
| { |
| // search for sun, found (pos==4) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the sun su"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring(aStr, aSearchStr, 4); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_006) |
| { |
| // search for sun, found (pos==-1) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the su su"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("sun"); |
| lastIndexOf_oustring(aStr, aSearchStr, -1); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_007) |
| { |
| // search for earth, not found (-1) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the su su"); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("earth"); |
| lastIndexOf_oustring(aStr, aSearchStr, -1); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_008) |
| { |
| // search for earth, not found (-1) |
| rtl::OUString aStr = rtl::OUString(); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("earth"); |
| lastIndexOf_oustring(aStr, aSearchStr, -1); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_oustring_009) |
| { |
| // search for earth, not found (-1) |
| rtl::OUString aStr = rtl::OUString(); |
| rtl::OUString aSearchStr = rtl::OUString(); |
| lastIndexOf_oustring(aStr, aSearchStr, -1); |
| |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_salunicode_001) |
| { |
| // search for 's', found (19) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system"); |
| sal_Unicode suChar = L's'; |
| lastIndexOf_salunicode(aStr, suChar, 19); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_salunicode_002) |
| { |
| // search for 'x', not found (-1) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system"); |
| sal_Unicode suChar = L'x'; |
| lastIndexOf_salunicode(aStr, suChar, -1); |
| } |
| |
| TEST_F(lastIndexOf, lastIndexOf_test_salunicode_offset_001) |
| { |
| // search for 's', start from pos last char, found (19) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system"); |
| sal_Unicode cuChar = L's'; |
| lastIndexOf_salunicode_offset(aStr, cuChar, 19, aStr.getLength()); |
| } |
| TEST_F(lastIndexOf, lastIndexOf_test_salunicode_offset_002) |
| { |
| // search for 's', start pos is last occur from search behind, found (17) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system"); |
| sal_Unicode cuChar = L's'; |
| lastIndexOf_salunicode_offset(aStr, cuChar, 17, 19); |
| } |
| TEST_F(lastIndexOf, lastIndexOf_test_salunicode_offset_003) |
| { |
| // search for 't', start pos is 1, found (0) |
| rtl::OUString aStr = rtl::OUString::createFromAscii("the sun sun java system"); |
| sal_Unicode cuChar = L't'; |
| lastIndexOf_salunicode_offset(aStr, cuChar, 0, 1); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // - getToken (tests) |
| // ----------------------------------------------------------------------------- |
| class getToken : public ::testing::Test |
| { |
| public: |
| }; // class getToken |
| |
| TEST_F(getToken, getToken_000) |
| { |
| rtl::OUString suTokenStr; |
| |
| sal_Int32 nIndex = 0; |
| do |
| { |
| rtl::OUString suToken = suTokenStr.getToken( 0, ';', nIndex ); |
| } |
| while ( nIndex >= 0 ); |
| printf("Index %d\n", nIndex); |
| // should not GPF |
| } |
| |
| TEST_F(getToken, getToken_001) |
| { |
| rtl::OUString suTokenStr = rtl::OUString::createFromAscii("a;b"); |
| |
| sal_Int32 nIndex = 0; |
| |
| rtl::OUString suToken = suTokenStr.getToken( 0, ';', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("a")) == sal_True) << "Token should be a 'a'"; |
| |
| /* rtl::OUString */ suToken = suTokenStr.getToken( 0, ';', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("b")) == sal_True) << "Token should be a 'b'"; |
| ASSERT_TRUE(nIndex == -1) << "index should be negative"; |
| } |
| |
| TEST_F(getToken, getToken_002) |
| { |
| rtl::OUString suTokenStr = rtl::OUString::createFromAscii("a;b.c"); |
| |
| sal_Int32 nIndex = 0; |
| |
| rtl::OUString suToken = suTokenStr.getToken( 0, ';', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("a")) == sal_True) << "Token should be a 'a'"; |
| |
| /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("b")) == sal_True) << "Token should be a 'b'"; |
| |
| /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("c")) == sal_True) << "Token should be a 'c'"; |
| ASSERT_TRUE(nIndex == -1) << "index should be negative"; |
| } |
| |
| TEST_F(getToken, getToken_003) |
| { |
| rtl::OUString suTokenStr = rtl::OUString::createFromAscii("a;;b"); |
| |
| sal_Int32 nIndex = 0; |
| |
| rtl::OUString suToken = suTokenStr.getToken( 0, ';', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("a")) == sal_True) << "Token should be a 'a'"; |
| |
| /* rtl::OUString */ suToken = suTokenStr.getToken( 0, ';', nIndex ); |
| ASSERT_TRUE(suToken.getLength() == 0) << "Token should be empty"; |
| |
| /* rtl::OUString */ suToken = suTokenStr.getToken( 0, ';', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("b")) == sal_True) << "Token should be a 'b'"; |
| ASSERT_TRUE(nIndex == -1) << "index should be negative"; |
| } |
| |
| TEST_F(getToken, getToken_004) |
| { |
| rtl::OUString suTokenStr = rtl::OUString::createFromAscii("longer.then.ever."); |
| |
| sal_Int32 nIndex = 0; |
| |
| rtl::OUString suToken = suTokenStr.getToken( 0, '.', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("longer")) == sal_True) << "Token should be 'longer'"; |
| |
| /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("then")) == sal_True) << "Token should be 'then'"; |
| |
| /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex ); |
| ASSERT_TRUE(suToken.equals(rtl::OUString::createFromAscii("ever")) == sal_True) << "Token should be 'ever'"; |
| |
| /* rtl::OUString */ suToken = suTokenStr.getToken( 0, '.', nIndex ); |
| ASSERT_TRUE(suToken.getLength() == 0) << "Token should be empty"; |
| |
| ASSERT_TRUE(nIndex == -1) << "index should be negative"; |
| } |
| |
| TEST_F(getToken, getToken_005) { |
| rtl::OUString ab(RTL_CONSTASCII_USTRINGPARAM("ab")); |
| sal_Int32 n = 0; |
| ASSERT_TRUE(ab.getToken(0, '-', n) == ab) << "token should be 'ab'"; |
| ASSERT_TRUE(n == -1) << "n should be -1"; |
| ASSERT_TRUE(ab.getToken(0, '-', n).getLength() == 0) << "token should be empty"; |
| } |
| |
| class convertToString: public ::testing::Test { |
| public: |
| }; |
| |
| TEST_F(convertToString, test) { |
| static sal_Unicode const utf16[] = { 0x0041, 0x00E4, 0x0061 }; |
| rtl::OString s; |
| ASSERT_TRUE( |
| rtl::OUString(utf16, sizeof utf16 / sizeof utf16[0]).convertToString( |
| &s, RTL_TEXTENCODING_UTF7, |
| (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR | |
| RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR))); |
| ASSERT_EQ( |
| rtl::OString(RTL_CONSTASCII_STRINGPARAM("A+AOQ-a")), s); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // - string construction & interning (tests) |
| // ----------------------------------------------------------------------------- |
| class construction : public ::testing::Test |
| { |
| public: |
| }; |
| |
| TEST_F(construction, construct) |
| { |
| #ifdef RTL_INLINE_STRINGS |
| ::rtl::OUString aFoo( RTL_CONSTASCII_USTRINGPARAM("foo") ); |
| ASSERT_TRUE(aFoo[0] == 'f') << "string contents"; |
| ASSERT_TRUE(aFoo[1] == 'o') << "string contents"; |
| ASSERT_TRUE(aFoo[2] == 'o') << "string contents"; |
| ASSERT_TRUE(aFoo.getLength() == 3) << "string length"; |
| |
| ::rtl::OUString aBaa( RTL_CONSTASCII_USTRINGPARAM("this is a very long string with a lot of long things inside it and it goes on and on and on forever etc.") ); |
| ASSERT_TRUE(aBaa.getLength() == 104) << "string length"; |
| // Dig at the internals ... FIXME: should we have the bit-flag defines public ? |
| ASSERT_TRUE((aBaa.pData->refCount & 1<<30) != 0) << "string static flags"; |
| #endif |
| } |
| |
| TEST_F(construction, intern) |
| { |
| // The empty string is 'static' a special case ... |
| rtl::OUString aEmpty = rtl::OUString().intern(); |
| rtl::OUString aEmpty2 = rtl::OUString::intern( RTL_CONSTASCII_USTRINGPARAM( "" ) ); |
| |
| ::rtl::OUString aFoo( RTL_CONSTASCII_USTRINGPARAM("foo") ); |
| ::rtl::OUString aFooIntern = aFoo.intern(); |
| ASSERT_TRUE(aFooIntern.equalsAscii("foo")) << "string contents"; |
| ASSERT_TRUE(aFooIntern.getLength() == 3) << "string length"; |
| // We have to dup due to no atomic 'intern' bit-set operation |
| ASSERT_TRUE(aFoo.pData != aFooIntern.pData) << "intern dups"; |
| |
| // Test interning lots of things |
| int i; |
| static const int nSequence = 4096; |
| rtl::OUString *pStrs; |
| sal_uIntPtr *pValues; |
| |
| pStrs = new rtl::OUString[nSequence]; |
| pValues = new sal_uIntPtr[nSequence]; |
| for (i = 0; i < nSequence; i++) |
| { |
| pStrs[i] = rtl::OUString::valueOf( sqrt( static_cast<double>(i) ) ).intern(); |
| pValues[i] = reinterpret_cast<sal_uIntPtr>( pStrs[i].pData ); |
| } |
| for (i = 0; i < nSequence; i++) |
| { |
| rtl::OUString aNew = rtl::OUString::valueOf( sqrt( static_cast<double>(i) ) ).intern(); |
| ASSERT_TRUE(aNew.pData == pStrs[i].pData) << "double intern failed"; |
| } |
| |
| // Free strings to check for leaks |
| for (i = 0; i < nSequence; i++) |
| { |
| // Overwrite - hopefully this re-uses the memory |
| pStrs[i] = rtl::OUString(); |
| pStrs[i] = rtl::OUString::valueOf( sqrt( static_cast<double>(i) ) ); |
| } |
| |
| for (i = 0; i < nSequence; i++) |
| { |
| rtl::OUString aIntern; |
| sal_uIntPtr nValue; |
| aIntern = rtl::OUString::valueOf( sqrt( static_cast<double>(i) ) ).intern(); |
| |
| nValue = reinterpret_cast<sal_uIntPtr>( aIntern.pData ); |
| // This may not be 100% reliable: memory may |
| // have been re-used, but it's worth checking. |
| ASSERT_TRUE(nValue != pValues[i]) << "intern leaking"; |
| } |
| delete [] pValues; |
| delete [] pStrs; |
| } |
| |
| class indexOfAscii: public ::testing::Test { |
| public: |
| }; |
| |
| TEST_F(indexOfAscii, test) { |
| ASSERT_EQ( |
| sal_Int32(-1), |
| rtl::OUString().indexOfAsciiL(RTL_CONSTASCII_STRINGPARAM(""))); |
| ASSERT_EQ( |
| sal_Int32(-1), |
| rtl::OUString().lastIndexOfAsciiL(RTL_CONSTASCII_STRINGPARAM(""))); |
| ASSERT_EQ( |
| sal_Int32(0), |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foo")).indexOfAsciiL( |
| RTL_CONSTASCII_STRINGPARAM("foo"))); |
| ASSERT_EQ( |
| sal_Int32(0), |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foo")).lastIndexOfAsciiL( |
| RTL_CONSTASCII_STRINGPARAM("foo"))); |
| ASSERT_EQ( |
| sal_Int32(2), |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("fofoobar")).indexOfAsciiL( |
| RTL_CONSTASCII_STRINGPARAM("foo"))); |
| ASSERT_EQ( |
| sal_Int32(3), |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foofoofob")). |
| lastIndexOfAsciiL(RTL_CONSTASCII_STRINGPARAM("foo"))); |
| ASSERT_EQ( |
| sal_Int32(3), |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foofoobar")).indexOfAsciiL( |
| RTL_CONSTASCII_STRINGPARAM("foo"), 1)); |
| } |
| |
| class endsWith: public ::testing::Test { |
| public: |
| }; |
| |
| TEST_F(endsWith, test) { |
| ASSERT_EQ( |
| true, |
| rtl::OUString().endsWithAsciiL(RTL_CONSTASCII_STRINGPARAM(""))); |
| ASSERT_EQ( |
| false, |
| rtl::OUString().endsWithAsciiL(RTL_CONSTASCII_STRINGPARAM("foo"))); |
| ASSERT_EQ( |
| true, |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("bar")).endsWithAsciiL( |
| RTL_CONSTASCII_STRINGPARAM("bar"))); |
| ASSERT_EQ( |
| true, |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("foobar")).endsWithAsciiL( |
| RTL_CONSTASCII_STRINGPARAM("bar"))); |
| ASSERT_EQ( |
| false, |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("FOOBAR")).endsWithAsciiL( |
| RTL_CONSTASCII_STRINGPARAM("bar"))); |
| } |
| |
| class createFromCodePoints: public ::testing::Test { |
| public: |
| }; |
| |
| TEST_F(createFromCodePoints, test) { |
| ASSERT_EQ( |
| sal_Int32(0), |
| rtl::OUString(static_cast< sal_uInt32 const * >(NULL), 0).getLength()); |
| static sal_uInt32 const cp[] = { 0, 0xD800, 0xFFFF, 0x10000, 0x10FFFF }; |
| rtl::OUString s(cp, sizeof cp / sizeof (sal_uInt32)); |
| ASSERT_EQ(sal_Int32(7), s.getLength()); |
| ASSERT_EQ(sal_Unicode(0), s[0]); |
| ASSERT_EQ(sal_Unicode(0xD800), s[1]); |
| ASSERT_EQ(sal_Unicode(0xFFFF), s[2]); |
| ASSERT_EQ(sal_Unicode(0xD800), s[3]); |
| ASSERT_EQ(sal_Unicode(0xDC00), s[4]); |
| ASSERT_EQ(sal_Unicode(0xDBFF), s[5]); |
| ASSERT_EQ(sal_Unicode(0xDFFF), s[6]); |
| } |
| |
| class iterateCodePoints: public ::testing::Test { |
| public: |
| }; |
| |
| TEST_F(iterateCodePoints, testNotWellFormed) { |
| static sal_Unicode const utf16[] = |
| { 0xD800, 0xDC00, 0x0041, 0xDBFF, 0xDFFF, 0xDDEF, 0xD9AB }; |
| rtl::OUString s(utf16, sizeof utf16 / sizeof (sal_Unicode)); |
| sal_Int32 i = 0; |
| ASSERT_EQ(sal_uInt32(0x10000), s.iterateCodePoints(&i)); |
| ASSERT_EQ(sal_Int32(2), i); |
| ASSERT_EQ(sal_uInt32(0x0041), s.iterateCodePoints(&i)); |
| ASSERT_EQ(sal_Int32(3), i); |
| ASSERT_EQ(sal_uInt32(0x10FFFF), s.iterateCodePoints(&i)); |
| ASSERT_EQ(sal_Int32(5), i); |
| ASSERT_EQ(sal_uInt32(0xDDEF), s.iterateCodePoints(&i)); |
| ASSERT_EQ(sal_Int32(6), i); |
| ASSERT_EQ(sal_uInt32(0xD9AB), s.iterateCodePoints(&i)); |
| ASSERT_EQ(sal_Int32(7), i); |
| ASSERT_EQ(sal_uInt32(0xD9AB), s.iterateCodePoints(&i, -1)); |
| ASSERT_EQ(sal_Int32(6), i); |
| ASSERT_EQ(sal_uInt32(0xDDEF), s.iterateCodePoints(&i, -1)); |
| ASSERT_EQ(sal_Int32(5), i); |
| ASSERT_EQ(sal_uInt32(0x10FFFF), s.iterateCodePoints(&i, -1)); |
| ASSERT_EQ(sal_Int32(3), i); |
| ASSERT_EQ(sal_uInt32(0x0041), s.iterateCodePoints(&i, -1)); |
| ASSERT_EQ(sal_Int32(2), i); |
| ASSERT_EQ(sal_uInt32(0x10000), s.iterateCodePoints(&i, -1)); |
| ASSERT_EQ(sal_Int32(0), i); |
| i = 1; |
| ASSERT_EQ(sal_uInt32(0xDC00), s.iterateCodePoints(&i, 2)); |
| ASSERT_EQ(sal_Int32(3), i); |
| i = 4; |
| ASSERT_EQ(sal_uInt32(0x10000), s.iterateCodePoints(&i, -3)); |
| ASSERT_EQ(sal_Int32(0), i); |
| } |
| |
| class convertFromString: public ::testing::Test { |
| public: |
| }; |
| |
| TEST_F(convertFromString, test) { |
| rtl::OUString t; |
| ASSERT_TRUE( |
| !rtl_convertStringToUString( |
| &t.pData, RTL_CONSTASCII_STRINGPARAM("\x80"), RTL_TEXTENCODING_UTF8, |
| (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR | |
| RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR | |
| RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR))); |
| ASSERT_TRUE( |
| !rtl_convertStringToUString( |
| &t.pData, RTL_CONSTASCII_STRINGPARAM("\xC0"), RTL_TEXTENCODING_UTF8, |
| (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR | |
| RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR | |
| RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR))); |
| ASSERT_TRUE( |
| !rtl_convertStringToUString( |
| &t.pData, RTL_CONSTASCII_STRINGPARAM("\xFF"), RTL_TEXTENCODING_UTF8, |
| (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR | |
| RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR | |
| RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR))); |
| ASSERT_TRUE( |
| rtl_convertStringToUString( |
| &t.pData, RTL_CONSTASCII_STRINGPARAM("abc"), RTL_TEXTENCODING_UTF8, |
| (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR | |
| RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR | |
| RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR))); |
| ASSERT_TRUE(t.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("abc"))); |
| } |
| |
| |
| } // namespace rtl_OUString |
| |
| int main(int argc, char **argv) |
| { |
| ::testing::InitGoogleTest(&argc, argv); |
| return RUN_ALL_TESTS(); |
| } |
