diff options
Diffstat (limited to 'sal/qa/rtl/ostring/rtl_OString2.cxx')
| -rw-r--r-- | sal/qa/rtl/ostring/rtl_OString2.cxx | 508 |
1 files changed, 508 insertions, 0 deletions
diff --git a/sal/qa/rtl/ostring/rtl_OString2.cxx b/sal/qa/rtl/ostring/rtl_OString2.cxx new file mode 100644 index 000000000..204475084 --- /dev/null +++ b/sal/qa/rtl/ostring/rtl_OString2.cxx @@ -0,0 +1,508 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include <sal/types.h> +#include <cppunit/TestFixture.h> +#include <cppunit/extensions/HelperMacros.h> +#include <cppunit/plugin/TestPlugIn.h> + +#include <rtl/string.hxx> + +#include "valueequal.hxx" + +namespace rtl_OString +{ + +class valueOf : public CppUnit::TestFixture +{ + void valueOf_float_test_impl(float _nValue) + { + OString sValue; + sValue = OString::valueOf( _nValue ); + printf("nFloat := %.9f sValue := %s\n", _nValue, sValue.getStr()); + + float nValueATOF = static_cast<float>(atof( sValue.getStr() )); + + bool bEqualResult = is_float_equal(_nValue, nValueATOF); + CPPUNIT_ASSERT_MESSAGE("Values are not equal.", bEqualResult == true); + } + + void valueOf_float_test(float _nValue) + { + valueOf_float_test_impl(_nValue); + + // test also the negative part. + float nNegativeValue = -_nValue; + valueOf_float_test_impl(nNegativeValue); + } + +public: + // insert your test code here. + void valueOf_float_test_001() + { + // this is demonstration code + // CPPUNIT_ASSERT_MESSAGE("a message", 1 == 1); + float nValue = 3.0f; + valueOf_float_test(nValue); + } + + void valueOf_float_test_002() + { + float nValue = 3.5f; + valueOf_float_test(nValue); + } + + void valueOf_float_test_003() + { + float nValue = 3.0625f; + valueOf_float_test(nValue); + } + + void valueOf_float_test_004() + { + float nValue = 3.502525f; + valueOf_float_test(nValue); + } + + void valueOf_float_test_005() + { + float nValue = 3.141592f; + valueOf_float_test(nValue); + } + + void valueOf_float_test_006() + { + float nValue = 3.5025255f; + valueOf_float_test(nValue); + } + + void valueOf_float_test_007() + { + float nValue = 3.0039062f; + valueOf_float_test(nValue); + } + +private: + + void valueOf_double_test_impl(double _nValue) + { + OString sValue; + sValue = OString::valueOf( _nValue ); + printf("nDouble := %.20f sValue := %s\n", _nValue, sValue.getStr()); + + double nValueATOF = atof( sValue.getStr() ); + + bool bEqualResult = is_double_equal(_nValue, nValueATOF); + CPPUNIT_ASSERT_MESSAGE("Values are not equal.", bEqualResult == true); + } + + void valueOf_double_test(double _nValue) + { + valueOf_double_test_impl(_nValue); + + // test also the negative part. + double nNegativeValue = -_nValue; + valueOf_double_test_impl(nNegativeValue); + } +public: + + // valueOf double + void valueOf_double_test_001() + { + double nValue = 3.0; + valueOf_double_test(nValue); + } + void valueOf_double_test_002() + { + double nValue = 3.5; + valueOf_double_test(nValue); + } + void valueOf_double_test_003() + { + double nValue = 3.0625; + valueOf_double_test(nValue); + } + void valueOf_double_test_004() + { + double nValue = 3.1415926535; + valueOf_double_test(nValue); + } + void valueOf_double_test_005() + { + double nValue = 3.141592653589793; + valueOf_double_test(nValue); + } + void valueOf_double_test_006() + { + double nValue = 3.1415926535897932; + valueOf_double_test(nValue); + } + void valueOf_double_test_007() + { + double nValue = 3.14159265358979323; + valueOf_double_test(nValue); + } + void valueOf_double_test_008() + { + double nValue = 3.141592653589793238462643; + valueOf_double_test(nValue); + } + + // Change the following lines only, if you add, remove or rename + // member functions of the current class, + // because these macros are need by auto register mechanism. + + CPPUNIT_TEST_SUITE(valueOf); + CPPUNIT_TEST(valueOf_float_test_001); + CPPUNIT_TEST(valueOf_float_test_002); + CPPUNIT_TEST(valueOf_float_test_003); + CPPUNIT_TEST(valueOf_float_test_004); + CPPUNIT_TEST(valueOf_float_test_005); + CPPUNIT_TEST(valueOf_float_test_006); + CPPUNIT_TEST(valueOf_float_test_007); + + CPPUNIT_TEST(valueOf_double_test_001); + CPPUNIT_TEST(valueOf_double_test_002); + CPPUNIT_TEST(valueOf_double_test_003); + CPPUNIT_TEST(valueOf_double_test_004); + CPPUNIT_TEST(valueOf_double_test_005); + CPPUNIT_TEST(valueOf_double_test_006); + CPPUNIT_TEST(valueOf_double_test_007); + CPPUNIT_TEST(valueOf_double_test_008); + CPPUNIT_TEST_SUITE_END(); +}; // class valueOf + +// - toDouble (tests) + +class toDouble : public CppUnit::TestFixture +{ + +public: + + toDouble() + { + // testPrecision a; + } + + void toDouble_test_impl(OString const& _sValue) + { + double nValueATOF = atof( _sValue.getStr() ); + + // OUString suValue = OUString::createFromAscii( _sValue.getStr() ); + double nValueToDouble = _sValue.toDouble(); + + bool bEqualResult = is_double_equal(nValueToDouble, nValueATOF); + CPPUNIT_ASSERT_MESSAGE("Values are not equal.", bEqualResult == true); + } + + void toDouble_test(OString const& _sValue) + { + toDouble_test_impl(_sValue); + + // test also the negative part. + OString sNegativValue("-"); + sNegativValue += _sValue; + toDouble_test_impl(sNegativValue); + } + + // insert your test code here. + void toDouble_selftest() + { + printf("Start selftest:\n"); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.01) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.0001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.00001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.000001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.0000001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.00000001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.000000001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.0000000001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.00000000001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.000000000001) == false); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.0000000000001) == false); + // we check til 14 values after comma + CPPUNIT_ASSERT (is_double_equal(1.0, 1.00000000000001) == true); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.000000000000001) == true); + CPPUNIT_ASSERT (is_double_equal(1.0, 1.0000000000000001) == true); + printf("Selftest done.\n"); + } + + void toDouble_test_3() + { + OString sValue("3"); + toDouble_test(sValue); + } + void toDouble_test_3_5() + { + OString sValue("3.5"); + toDouble_test(sValue); + } + void toDouble_test_3_0625() + { + OString sValue("3.0625"); + toDouble_test(sValue); + } + void toDouble_test_pi() + { + // value from http://www.angio.net/pi/digits/50.txt + OString sValue("3.141592653589793238462643383279502884197169399375"); + toDouble_test(sValue); + } + + void toDouble_test_1() + { + OString sValue("1"); + toDouble_test(sValue); + } + void toDouble_test_10() + { + OString sValue("10"); + toDouble_test(sValue); + } + void toDouble_test_100() + { + OString sValue("100"); + toDouble_test(sValue); + } + void toDouble_test_1000() + { + OString sValue("1000"); + toDouble_test(sValue); + } + void toDouble_test_10000() + { + OString sValue("10000"); + toDouble_test(sValue); + } + void toDouble_test_1e99() + { + OString sValue("1e99"); + toDouble_test(sValue); + } + void toDouble_test_1e_n99() + { + OString sValue("1e-99"); + toDouble_test(sValue); + } + void toDouble_test_1e308() + { + OString sValue("1e308"); + toDouble_test(sValue); + } + + // Change the following lines only, if you add, remove or rename + // member functions of the current class, + // because these macros are need by auto register mechanism. + + CPPUNIT_TEST_SUITE(toDouble); + CPPUNIT_TEST(toDouble_selftest); + + CPPUNIT_TEST(toDouble_test_3); + CPPUNIT_TEST(toDouble_test_3_5); + CPPUNIT_TEST(toDouble_test_3_0625); + CPPUNIT_TEST(toDouble_test_pi); + CPPUNIT_TEST(toDouble_test_1); + CPPUNIT_TEST(toDouble_test_10); + CPPUNIT_TEST(toDouble_test_100); + CPPUNIT_TEST(toDouble_test_1000); + CPPUNIT_TEST(toDouble_test_10000); + CPPUNIT_TEST(toDouble_test_1e99); + CPPUNIT_TEST(toDouble_test_1e_n99); + CPPUNIT_TEST(toDouble_test_1e308); + CPPUNIT_TEST_SUITE_END(); +}; // class toDouble + +// - getToken (tests) + +class getToken : public CppUnit::TestFixture +{ + +public: + void getToken_000() + { + OString sTokenStr; + + sal_Int32 nIndex = 0; + do + { + OString sToken = sTokenStr.getToken( 0, ';', nIndex ); + } + while ( nIndex >= 0 ); + // printf("Index %d\n", nIndex); + // should not GPF + } + + void getToken_001() + { + OString sTokenStr = "a;b"; + + sal_Int32 nIndex = 0; + + OString sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'a'", sToken.equals("a") == sal_True); + + /* OString */ sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'b'", sToken.equals("b") == sal_True); + CPPUNIT_ASSERT_MESSAGE("index should be negative", nIndex == -1); + } + + void getToken_002() + { + OString sTokenStr = "a;b.c"; + + sal_Int32 nIndex = 0; + + OString sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'a'", sToken.equals("a") == sal_True); + + /* OString */ sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'b'", sToken.equals("b") == sal_True); + + /* OString */ sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'c'", sToken.equals("c") == sal_True); + CPPUNIT_ASSERT_MESSAGE("index should be negative", nIndex == -1); + } + + void getToken_003() + { + OString sTokenStr = "a;;b"; + + sal_Int32 nIndex = 0; + + OString sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'a'", sToken.equals("a") == sal_True); + + /* OString */ sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be empty", sToken.isEmpty()); + + /* OString */ sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'b'", sToken.equals("b") == sal_True); + CPPUNIT_ASSERT_MESSAGE("index should be negative", nIndex == -1); + } + + void getToken_004() + { + OString sTokenStr = "longer.then.ever."; + + sal_Int32 nIndex = 0; + + OString sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be 'longer'", sToken.equals("longer") == sal_True); + + /* OString */ sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be 'then'", sToken.equals("then") == sal_True); + + /* OString */ sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be 'ever'", sToken.equals("ever") == sal_True); + + /* OString */ sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be empty", sToken.isEmpty()); + + CPPUNIT_ASSERT_MESSAGE("index should be negative", nIndex == -1); + } + + CPPUNIT_TEST_SUITE(getToken); + CPPUNIT_TEST(getToken_000); + CPPUNIT_TEST(getToken_001); + CPPUNIT_TEST(getToken_002); + CPPUNIT_TEST(getToken_003); + CPPUNIT_TEST(getToken_004); + CPPUNIT_TEST_SUITE_END(); +}; // class getToken + +// testing the method replaceAt( sal_Int32 index, sal_Int32 count, +// const OString& newStr ) + +// Developer note: Mindy Liu, 2004-04-23 +// stolen from sal/qa/rtl_strings/rtl_OString.cxx + +class replaceAt : public CppUnit::TestFixture +{ + +public: + sal_Bool check_replaceAt( const OString* expVal, const OString* input, + const OString* newStr, sal_Int32 index, sal_Int32 count) + { + OString aStr1; + aStr1= input->replaceAt( index, count, *newStr ); + + printf("the result OString is %s#\n", aStr1.getStr() ); + + sal_Bool bRes = ( expVal->compareTo(aStr1) == 0 ); + return bRes; + } + + void replaceAt_001() + { + sal_Bool bRes = check_replaceAt(new OString("Java@Sun"), + new OString("Sun java"), new OString("Java@Sun"), 0, 8 ); + CPPUNIT_ASSERT_MESSAGE("string differs, replace whole string", bRes == sal_True); + } + + void replaceAt_002() + { + sal_Bool bRes = check_replaceAt(new OString("Sun Java desktop system"), + new OString("Sun "), new OString("Java desktop system"), 10, 8 ); + CPPUNIT_ASSERT_MESSAGE("index > length of input string", bRes == sal_True); + } + + void replaceAt_003() + { + sal_Bool bRes = check_replaceAt(new OString("SuJava desktop system"), + new OString("Sun "), new OString("Java desktop system"), 2, 64 ); + CPPUNIT_ASSERT_MESSAGE("larger count", bRes == sal_True); + } + + void replaceAt_004() + { + + sal_Bool bRes = check_replaceAt(new OString("Java desktop system"), + new OString("Sun "), new OString("Java desktop system"), -4, 8 ); + CPPUNIT_ASSERT_MESSAGE("navigate index", bRes == sal_True); + } + void replaceAt_005() + { + + sal_Bool bRes = check_replaceAt(new OString("Sun Jesktop System"), + new OString("Sun Java Desktop System"), new OString(""), 5, 5 ); + CPPUNIT_ASSERT_MESSAGE("replace with null string", bRes == sal_True); + } + + CPPUNIT_TEST_SUITE(replaceAt); + CPPUNIT_TEST(replaceAt_001); + CPPUNIT_TEST(replaceAt_002); + CPPUNIT_TEST(replaceAt_003); + CPPUNIT_TEST(replaceAt_004); + CPPUNIT_TEST(replaceAt_005); + CPPUNIT_TEST_SUITE_END(); +}; // class replaceAt + +CPPUNIT_TEST_SUITE_REGISTRATION(rtl_OString::valueOf); +CPPUNIT_TEST_SUITE_REGISTRATION(rtl_OString::toDouble); +CPPUNIT_TEST_SUITE_REGISTRATION(rtl_OString::getToken); +CPPUNIT_TEST_SUITE_REGISTRATION(rtl_OString::replaceAt); + +} // namespace rtl_OString + +// this macro creates an empty function, which will called by the RegisterAllFunctions() +// to let the user the possibility to also register some functions by hand. +CPPUNIT_PLUGIN_IMPLEMENT(); + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |