diff options
Diffstat (limited to 'sal/qa/rtl/ostring')
-rw-r--r-- | sal/qa/rtl/ostring/joblist.txt | 10 | ||||
-rw-r--r-- | sal/qa/rtl/ostring/makefile.mk | 93 | ||||
-rw-r--r-- | sal/qa/rtl/ostring/rtl_OString2.cxx | 568 | ||||
-rw-r--r-- | sal/qa/rtl/ostring/rtl_str.cxx | 890 | ||||
-rw-r--r-- | sal/qa/rtl/ostring/rtl_str.xsce | 26 | ||||
-rw-r--r-- | sal/qa/rtl/ostring/rtl_string.cxx | 183 | ||||
-rw-r--r-- | sal/qa/rtl/ostring/rtl_string.xsce | 1 |
7 files changed, 1771 insertions, 0 deletions
diff --git a/sal/qa/rtl/ostring/joblist.txt b/sal/qa/rtl/ostring/joblist.txt new file mode 100644 index 000000000000..81d1b7a6ba8e --- /dev/null +++ b/sal/qa/rtl/ostring/joblist.txt @@ -0,0 +1,10 @@ +# JobFile for rtl_OString +# header source sal/inc/rtl/string.hxx + +rtl_OString.valueOf.valueOf_test_001 +rtl_OString.valueOf.valueOf_test_002 +rtl_OString.valueOf.valueOf_test_003 +rtl_OString.valueOf.valueOf_test_004 +rtl_OString.valueOf.valueOf_test_005 +rtl_OString.valueOf.valueOf_test_006 +rtl_OString.valueOf.valueOf_test_007 diff --git a/sal/qa/rtl/ostring/makefile.mk b/sal/qa/rtl/ostring/makefile.mk new file mode 100644 index 000000000000..06469b38a407 --- /dev/null +++ b/sal/qa/rtl/ostring/makefile.mk @@ -0,0 +1,93 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +PRJ=..$/..$/.. +INCPRE+= $(PRJ)$/qa$/inc + +PRJNAME=sal +TARGET=qa_rtl_ostring2 + +ENABLE_EXCEPTIONS=TRUE + +# --- Settings ----------------------------------------------------- + +.INCLUDE : settings.mk + +CFLAGS+= $(LFS_CFLAGS) +CXXFLAGS+= $(LFS_CFLAGS) + +CFLAGSCXX += $(CPPUNIT_CFLAGS) + +# BEGIN ---------------------------------------------------------------- +# auto generated Target:joblist by codegen.pl +SHL1OBJS= \ + $(SLO)$/rtl_OString2.obj + +SHL1TARGET= rtl_OString2 +SHL1STDLIBS= $(SALLIB) $(CPPUNITLIB) $(TESTSHL2LIB) + +SHL1IMPLIB= i$(SHL1TARGET) +# SHL1DEF= $(MISC)$/$(SHL1TARGET).def + +DEF1NAME =$(SHL1TARGET) +# DEF2EXPORTFILE= export.exp +SHL1VERSIONMAP= $(PRJ)$/qa$/export.map +# auto generated Target:joblist +# END ------------------------------------------------------------------ + +# BEGIN ---------------------------------------------------------------- +SHL2OBJS= \ + $(SLO)$/rtl_str.obj + +SHL2TARGET= rtl_str +SHL2STDLIBS= $(SALLIB) $(CPPUNITLIB) $(TESTSHL2LIB) + +SHL2IMPLIB= i$(SHL2TARGET) +DEF2NAME =$(SHL2TARGET) +SHL2VERSIONMAP= $(PRJ)$/qa$/export.map +# END ------------------------------------------------------------------ + +# BEGIN ---------------------------------------------------------------- +SHL3OBJS= \ + $(SLO)$/rtl_string.obj + +SHL3TARGET= rtl_string +SHL3STDLIBS= $(SALLIB) $(CPPUNITLIB) $(TESTSHL2LIB) + +SHL3IMPLIB= i$(SHL3TARGET) +DEF3NAME =$(SHL3TARGET) +SHL3VERSIONMAP= $(PRJ)$/qa$/export.map +# END ------------------------------------------------------------------ +#------------------------------- All object files ------------------------------- +# do this here, so we get right dependencies +# SLOFILES=$(SHL1OBJS) + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk +.INCLUDE : _cppunit.mk + diff --git a/sal/qa/rtl/ostring/rtl_OString2.cxx b/sal/qa/rtl/ostring/rtl_OString2.cxx new file mode 100644 index 000000000000..ee380c86812d --- /dev/null +++ b/sal/qa/rtl/ostring/rtl_OString2.cxx @@ -0,0 +1,568 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sal.hxx" +// autogenerated file with codegen.pl +// There exist some more test code in sal/qa/rtl_strings/rtl_OString.cxx + +#include <testshl/simpleheader.hxx> +#include "valueequal.hxx" + +namespace rtl_OString +{ + +class valueOf : public CppUnit::TestFixture +{ + void valueOf_float_test_impl(float _nValue) + { + rtl::OString sValue; + sValue = rtl::OString::valueOf( _nValue ); + t_print(T_VERBOSE, "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: + // initialise your test code values here. + void setUp() + { + } + + void tearDown() + { + } + + // 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) + { + rtl::OString sValue; + sValue = rtl::OString::valueOf( _nValue ); + t_print(T_VERBOSE, "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; + } + + + + // initialise your test code values here. + void setUp() + { + } + + void tearDown() + { + } + + void toDouble_test_impl(rtl::OString const& _sValue) + { + double nValueATOF = atof( _sValue.getStr() ); + + // rtl::OUString suValue = rtl::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(rtl::OString const& _sValue) + { + toDouble_test_impl(_sValue); + + // test also the negativ part. + rtl::OString sNegativValue("-"); + sNegativValue += _sValue; + toDouble_test_impl(sNegativValue); + } + + // insert your test code here. + void toDouble_selftest() + { + t_print("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); + t_print("Selftest done.\n"); + } + + void toDouble_test_3() + { + rtl::OString sValue("3"); + toDouble_test(sValue); + } + void toDouble_test_3_5() + { + rtl::OString sValue("3.5"); + toDouble_test(sValue); + } + void toDouble_test_3_0625() + { + rtl::OString sValue("3.0625"); + toDouble_test(sValue); + } + void toDouble_test_pi() + { + // value from http://www.angio.net/pi/digits/50.txt + rtl::OString sValue("3.141592653589793238462643383279502884197169399375"); + toDouble_test(sValue); + } + + void toDouble_test_1() + { + rtl::OString sValue("1"); + toDouble_test(sValue); + } + void toDouble_test_10() + { + rtl::OString sValue("10"); + toDouble_test(sValue); + } + void toDouble_test_100() + { + rtl::OString sValue("100"); + toDouble_test(sValue); + } + void toDouble_test_1000() + { + rtl::OString sValue("1000"); + toDouble_test(sValue); + } + void toDouble_test_10000() + { + rtl::OString sValue("10000"); + toDouble_test(sValue); + } + void toDouble_test_1e99() + { + rtl::OString sValue("1e99"); + toDouble_test(sValue); + } + void toDouble_test_1e_n99() + { + rtl::OString sValue("1e-99"); + toDouble_test(sValue); + } + void toDouble_test_1e308() + { + rtl::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: + + // initialise your test code values here. + void setUp() + { + } + + void tearDown() + { + } + + // ----------------------------------------------------------------------------- + + void getToken_000() + { + rtl::OString sTokenStr; + + sal_Int32 nIndex = 0; + do + { + rtl::OString sToken = sTokenStr.getToken( 0, ';', nIndex ); + } + while ( nIndex >= 0 ); + // t_print("Index %d\n", nIndex); + // should not GPF + } + + void getToken_001() + { + rtl::OString sTokenStr = "a;b"; + + sal_Int32 nIndex = 0; + + rtl::OString sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'a'", sToken.equals("a") == sal_True); + + /* rtl::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() + { + rtl::OString sTokenStr = "a;b.c"; + + sal_Int32 nIndex = 0; + + rtl::OString sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'a'", sToken.equals("a") == sal_True); + + /* rtl::OString */ sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'b'", sToken.equals("b") == sal_True); + + /* rtl::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() + { + rtl::OString sTokenStr = "a;;b"; + + sal_Int32 nIndex = 0; + + rtl::OString sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be a 'a'", sToken.equals("a") == sal_True); + + /* rtl::OString */ sToken = sTokenStr.getToken( 0, ';', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be empty", sToken.getLength() == 0); + + /* rtl::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() + { + rtl::OString sTokenStr = "longer.then.ever."; + + sal_Int32 nIndex = 0; + + rtl::OString sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be 'longer'", sToken.equals("longer") == sal_True); + + /* rtl::OString */ sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be 'then'", sToken.equals("then") == sal_True); + + /* rtl::OString */ sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be 'ever'", sToken.equals("ever") == sal_True); + + /* rtl::OString */ sToken = sTokenStr.getToken( 0, '.', nIndex ); + CPPUNIT_ASSERT_MESSAGE("Token should be empty", sToken.getLength() == 0); + + 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 +// stollen from sal/qa/rtl_strings/rtl_OString.cxx + +class replaceAt : public CppUnit::TestFixture +{ + +public: + // initialise your test code values here. + void setUp() + { + } + + void tearDown() + { + } + sal_Bool check_replaceAt( const rtl::OString* expVal, const rtl::OString* input, + const rtl::OString* newStr, sal_Int32 index, sal_Int32 count) + { + ::rtl::OString aStr1; + aStr1= input->replaceAt( index, count, *newStr ); + + t_print("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 rtl::OString("Java@Sun"), + new rtl::OString("Sun java"), new rtl::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 rtl::OString("Sun Java desktop system"), + new rtl::OString("Sun "), new rtl::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 rtl::OString("SuJava desktop system"), + new rtl::OString("Sun "), new rtl::OString("Java desktop system"), 2, 64 ); + CPPUNIT_ASSERT_MESSAGE("larger count", bRes == sal_True); + } + + void replaceAt_004() + { + + sal_Bool bRes = check_replaceAt(new rtl::OString("Java desktop system"), + new rtl::OString("Sun "), new rtl::OString("Java desktop system"), -4, 8 ); + CPPUNIT_ASSERT_MESSAGE("navigate index", bRes == sal_True); + } + void replaceAt_005() + { + + sal_Bool bRes = check_replaceAt(new rtl::OString("Sun Jesktop System"), + new rtl::OString("Sun Java Desktop System"), new rtl::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_NAMED_REGISTRATION(rtl_OString::valueOf, "rtl_OString"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_OString::toDouble, "rtl_OString"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_OString::getToken, "rtl_OString"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_OString::replaceAt, "rtl_OString"); + +} // 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. +NOADDITIONAL; + diff --git a/sal/qa/rtl/ostring/rtl_str.cxx b/sal/qa/rtl/ostring/rtl_str.cxx new file mode 100644 index 000000000000..b513c6cb1398 --- /dev/null +++ b/sal/qa/rtl/ostring/rtl_str.cxx @@ -0,0 +1,890 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sal.hxx" +#include <testshl/simpleheader.hxx> + +namespace rtl_str +{ + + class compare : public CppUnit::TestFixture + { + public: + + void compare_000() + { + rtl_str_compare( NULL, NULL); + } + + void compare_000_1() + { + rtl::OString aStr1 = "Line must be equal."; + rtl_str_compare( aStr1.getStr(), NULL); + } + void compare_001() + { + rtl::OString aStr1 = ""; + rtl::OString aStr2 = ""; + + sal_Int32 nValue = rtl_str_compare( aStr1.getStr(), aStr2.getStr()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); + } + + void compare_002() + { + rtl::OString aStr1 = "Line must be equal."; + rtl::OString aStr2 = "Line must be equal."; + + sal_Int32 nValue = rtl_str_compare( aStr1.getStr(), aStr2.getStr()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); + } + + void compare_003() + { + rtl::OString aStr1 = "Line must differ."; + rtl::OString aStr2 = "Line foo bar, ok, differ."; + + sal_Int32 nValue = rtl_str_compare( aStr1.getStr(), aStr2.getStr()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); + } + + // 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(compare); + CPPUNIT_TEST(compare_000); + CPPUNIT_TEST(compare_000_1); + CPPUNIT_TEST(compare_001); + CPPUNIT_TEST(compare_002); + CPPUNIT_TEST(compare_003); + CPPUNIT_TEST_SUITE_END(); +}; // class compare + + + class compareIgnoreAsciiCase : public CppUnit::TestFixture + { + public: + + void compare_000() + { + rtl_str_compareIgnoreAsciiCase( NULL, NULL); + } + + void compare_000_1() + { + rtl::OString aStr1 = "Line must be equal."; + rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), NULL); + } + void compare_001() + { + rtl::OString aStr1 = ""; + rtl::OString aStr2 = ""; + + sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); + } + + void compare_002() + { + rtl::OString aStr1 = "Line must be equal."; + rtl::OString aStr2 = "Line must be equal."; + + sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); + } + + void compare_002_1() + { + rtl::OString aStr1 = "Line must be equal."; + rtl::OString aStr2 = "LINE MUST BE EQUAL."; + + sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); + } + + void compare_003() + { + rtl::OString aStr1 = "Line must differ."; + rtl::OString aStr2 = "Line foo bar, ok, differ."; + + sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); + } + + // 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(compareIgnoreAsciiCase); + CPPUNIT_TEST(compare_000); + CPPUNIT_TEST(compare_000_1); + CPPUNIT_TEST(compare_001); + CPPUNIT_TEST(compare_002); + CPPUNIT_TEST(compare_002_1); + CPPUNIT_TEST(compare_003); + CPPUNIT_TEST_SUITE_END(); + }; // class compareIgnoreAsciiCase + +// ----------------------------------------------------------------------------- + + class shortenedCompareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture + { + public: + + void compare_000() + { + rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0, 0); + } + + void compare_000_1() + { + rtl::OString aStr1 = "Line must be equal."; + rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0, 1); + } + void compare_001() + { + rtl::OString aStr1 = ""; + rtl::OString aStr2 = ""; + + sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), aStr2.getStr(), aStr2.getLength(), aStr1.getLength()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); + } + + void compare_002() + { + rtl::OString aStr1 = "Line must be equal."; + rtl::OString aStr2 = "Line must be equal."; + + sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), + aStr2.getStr(), aStr2.getLength(), + aStr1.getLength()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); + } + + void compare_002_1() + { + rtl::OString aStr1 = "Line must be equal."; + rtl::OString aStr2 = "LINE MUST BE EQUAL."; + + sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), + aStr2.getStr(), aStr2.getLength(), + aStr1.getLength()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); + } + + void compare_003() + { + rtl::OString aStr1 = "Line must differ."; + rtl::OString aStr2 = "Line foo bar, ok, differ."; + + sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), + aStr2.getStr(), aStr2.getLength(), + 5); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal first 5 characters.", nValue == 0); + } + + void compare_004() + { + rtl::OString aStr1 = "Line must differ."; + rtl::OString aStr2 = "Line foo bar, ok, differ."; + + sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), + aStr2.getStr(), aStr2.getLength(), + aStr1.getLength()); + CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); + } + + // 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(shortenedCompareIgnoreAsciiCase_WithLength); + CPPUNIT_TEST(compare_000); + CPPUNIT_TEST(compare_000_1); + CPPUNIT_TEST(compare_001); + CPPUNIT_TEST(compare_002); + CPPUNIT_TEST(compare_002_1); + CPPUNIT_TEST(compare_003); + CPPUNIT_TEST(compare_004); + CPPUNIT_TEST_SUITE_END(); +}; // class compare + + +// ----------------------------------------------------------------------------- + + class hashCode : public CppUnit::TestFixture + { + public: + + void hashCode_000() + { + rtl_str_hashCode( NULL ); + } + + void hashCode_001() + { + rtl::OString aStr1 = "Line for a hashCode."; + sal_Int32 nHashCode = rtl_str_hashCode( aStr1.getStr() ); + t_print("hashcode: %d\n", nHashCode); + // CPPUNIT_ASSERT_MESSAGE("failed.", nValue == 0); + } + + void hashCode_002() + { + rtl::OString aStr1 = "Line for a hashCode."; + sal_Int32 nHashCode1 = rtl_str_hashCode( aStr1.getStr() ); + + rtl::OString aStr2 = "Line for a hashCode."; + sal_Int32 nHashCode2 = rtl_str_hashCode( aStr2.getStr() ); + + CPPUNIT_ASSERT_MESSAGE("hashcodes must be equal.", nHashCode1 == nHashCode2 ); + } + + void hashCode_003() + { + rtl::OString aStr1 = "Line for a hashCode."; + sal_Int32 nHashCode1 = rtl_str_hashCode( aStr1.getStr() ); + + rtl::OString aStr2 = "Line for an other hashcode."; + sal_Int32 nHashCode2 = rtl_str_hashCode( aStr2.getStr() ); + + CPPUNIT_ASSERT_MESSAGE("hashcodes must differ.", nHashCode1 != nHashCode2 ); + } + + // 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(hashCode); + CPPUNIT_TEST(hashCode_000); + CPPUNIT_TEST(hashCode_001); + CPPUNIT_TEST(hashCode_002); + CPPUNIT_TEST(hashCode_003); + CPPUNIT_TEST_SUITE_END(); + }; // class compare + + +// ----------------------------------------------------------------------------- + + class indexOfChar : public CppUnit::TestFixture + { + public: + + void indexOfChar_000() + { + rtl_str_indexOfChar( NULL, 0 ); + } + + void indexOfChar_001() + { + rtl::OString aStr1 = "Line for a indexOfChar."; + + sal_Int32 nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'L' ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); + + /* sal_Int32 */ nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'i' ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 1); + + /* sal_Int32 */ nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'n' ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 2); + + /* sal_Int32 */ nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'e' ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 3); + } + + void indexOfChar_002() + { + rtl::OString aStr1 = "Line for a indexOfChar."; + sal_Int32 nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'y' ); + + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); + } + + // 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(indexOfChar); + CPPUNIT_TEST(indexOfChar_000); + CPPUNIT_TEST(indexOfChar_001); + CPPUNIT_TEST(indexOfChar_002); + CPPUNIT_TEST_SUITE_END(); + }; // class compare + +// ----------------------------------------------------------------------------- + class lastIndexOfChar : public CppUnit::TestFixture + { + public: + + void lastIndexOfChar_000() + { + rtl_str_lastIndexOfChar( NULL, 0 ); + } + + void lastIndexOfChar_001() + { + rtl::OString aStr1 = "Line for a lastIndexOfChar."; + + sal_Int32 nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'C' ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 22); + + /* sal_Int32 */ nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'h' ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 23); + + /* sal_Int32 */ nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'a' ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 24); + + /* sal_Int32 */ nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'r' ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 25); + } + + void lastIndexOfChar_002() + { + rtl::OString aStr1 = "Line for a lastIndexOfChar."; + sal_Int32 nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'y' ); + + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); + } + + // 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(lastIndexOfChar); + CPPUNIT_TEST(lastIndexOfChar_000); + CPPUNIT_TEST(lastIndexOfChar_001); + CPPUNIT_TEST(lastIndexOfChar_002); + CPPUNIT_TEST_SUITE_END(); + }; // class lastIndexOfChar + + +// ----------------------------------------------------------------------------- + + class indexOfStr : public CppUnit::TestFixture + { + public: + + void indexOfStr_000() + { + rtl_str_indexOfStr( NULL, 0 ); + } + + void indexOfStr_000_1() + { + rtl::OString aStr1 = "Line for a indexOfStr."; + rtl_str_indexOfStr( aStr1.getStr(), 0 ); + } + + void indexOfStr_001() + { + rtl::OString aStr1 = "Line for a indexOfStr."; + + sal_Int32 nIndex = rtl_str_indexOfStr( aStr1.getStr(), "Line" ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); + + /* sal_Int32 */ nIndex = rtl_str_indexOfStr( aStr1.getStr(), "for" ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 5); + + /* sal_Int32 */ nIndex = rtl_str_indexOfStr( aStr1.getStr(), "a" ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 9); + + /* sal_Int32 */ nIndex = rtl_str_indexOfStr( aStr1.getStr(), "a index" ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex ==9); + } + + void indexOfStr_002() + { + rtl::OString aStr1 = "Line for a indexOfStr."; + sal_Int32 nIndex = rtl_str_indexOfStr( aStr1.getStr(), "not exist" ); + + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); + } + + // 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(indexOfStr); + CPPUNIT_TEST(indexOfStr_000); + CPPUNIT_TEST(indexOfStr_001); + CPPUNIT_TEST(indexOfStr_002); + CPPUNIT_TEST_SUITE_END(); + }; // class compare +// ----------------------------------------------------------------------------- + + + class lastIndexOfStr : public CppUnit::TestFixture + { + public: + + void lastIndexOfStr_000() + { + rtl_str_lastIndexOfStr( NULL, NULL ); + } + + void lastIndexOfStr_000_1() + { + rtl::OString aStr1 = "Line for a lastIndexOfStr."; + rtl_str_lastIndexOfStr( aStr1.getStr(), NULL ); + } + + void lastIndexOfStr_001() + { + rtl::OString aStr1 = "Line for a lastIndexOfStr."; + rtl::OString aSearchStr = "Index"; + + sal_Int32 nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 15); + + /* rtl::OString */ aSearchStr = "Line"; + /* sal_Int32 */ nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); + + /* rtl::OString */ aSearchStr = ""; + /* sal_Int32 */ nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1); + } + + void lastIndexOfStr_002() + { + rtl::OString aStr1 = "Line for a lastIndexOfStr."; + rtl::OString aSearchStr = "foo"; + sal_Int32 nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); + + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); + } + + void lastIndexOfStr_003() + { + rtl::OString aStr1 = "Line for a lastIndexOfStr."; + rtl::OString aSearchStr = "O"; + sal_Int32 nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); + + CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 20 ); + } + + // 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(lastIndexOfStr); + CPPUNIT_TEST(lastIndexOfStr_000); + CPPUNIT_TEST(lastIndexOfStr_001); + CPPUNIT_TEST(lastIndexOfStr_002); + CPPUNIT_TEST(lastIndexOfStr_003); + CPPUNIT_TEST_SUITE_END(); + }; // class lastIndexOfStr + +// ----------------------------------------------------------------------------- + + class replaceChar : public CppUnit::TestFixture + { + public: + + void replaceChar_000() + { + rtl_str_replaceChar( NULL, 0, 0 ); + } + + void replaceChar_001() + { + rtl::OString aStr1 = "replace char."; + rtl::OString aShouldStr1 = "ruplacu char."; + + sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); + CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); + strcpy(pStr, aStr1.getStr()); + + rtl_str_replaceChar( pStr, 'e', 'u' ); + + CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); + free(pStr); + } + + // 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(replaceChar); + CPPUNIT_TEST(replaceChar_000); + CPPUNIT_TEST(replaceChar_001); + CPPUNIT_TEST_SUITE_END(); + }; // class replaceChar + +// ----------------------------------------------------------------------------- + + class replaceChar_WithLength : public CppUnit::TestFixture + { + public: + + void replaceChar_WithLength_000() + { + rtl_str_replaceChar_WithLength( NULL, 0, 0, 0 ); + } + + void replaceChar_WithLength_000_1() + { + rtl_str_replaceChar_WithLength( NULL, 1, 0, 0 ); + } + void replaceChar_WithLength_001() + { + rtl::OString aStr1 = "replace char."; + rtl::OString aShouldStr1 = "ruplace char."; + + sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); + CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); + strcpy(pStr, aStr1.getStr()); + + rtl_str_replaceChar_WithLength( pStr, 6, 'e', 'u' ); + + CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); + free(pStr); + } + + // 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(replaceChar_WithLength); + CPPUNIT_TEST(replaceChar_WithLength_000); + CPPUNIT_TEST(replaceChar_WithLength_000_1); + CPPUNIT_TEST(replaceChar_WithLength_001); + CPPUNIT_TEST_SUITE_END(); + }; // class replaceChar + + +// ----------------------------------------------------------------------------- + + class toAsciiLowerCase : public CppUnit::TestFixture + { + public: + + void toAsciiLowerCase_000() + { + rtl_str_toAsciiLowerCase( NULL ); + } + + void toAsciiLowerCase_001() + { + rtl::OString aStr1 = "CHANGE THIS TO ASCII LOWER CASE."; + rtl::OString aShouldStr1 = "change this to ascii lower case."; + + sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); + CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); + strcpy(pStr, aStr1.getStr()); + + rtl_str_toAsciiLowerCase( pStr ); + + CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); + free(pStr); + } + + // 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(toAsciiLowerCase); + CPPUNIT_TEST(toAsciiLowerCase_000); + CPPUNIT_TEST(toAsciiLowerCase_001); + CPPUNIT_TEST_SUITE_END(); + }; // class replaceChar + + + class toAsciiLowerCase_WithLength : public CppUnit::TestFixture + { + public: + + void toAsciiLowerCase_WithLength_000() + { + rtl_str_toAsciiLowerCase_WithLength( NULL, 0 ); + } + + void toAsciiLowerCase_WithLength_001() + { + rtl::OString aStr1 = "CHANGE THIS TO ASCII LOWER CASE."; + rtl::OString aShouldStr1 = "change thiS TO ASCII LOWER CASE."; + + sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); + CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); + strcpy(pStr, aStr1.getStr()); + + rtl_str_toAsciiLowerCase_WithLength( pStr, 10 ); + + t_print("Lowercase with length: '%s'\n", pStr); + CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); + free(pStr); + } + + // 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(toAsciiLowerCase_WithLength); + CPPUNIT_TEST(toAsciiLowerCase_WithLength_000); + CPPUNIT_TEST(toAsciiLowerCase_WithLength_001); + CPPUNIT_TEST_SUITE_END(); + }; // class replaceChar + +// ----------------------------------------------------------------------------- + + class toAsciiUpperCase : public CppUnit::TestFixture + { + public: + + void toAsciiUpperCase_000() + { + rtl_str_toAsciiUpperCase( NULL ); + } + + void toAsciiUpperCase_001() + { + rtl::OString aStr1 = "change this to ascii upper case."; + rtl::OString aShouldStr1 = "CHANGE THIS TO ASCII UPPER CASE."; + + sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); + CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); + strcpy(pStr, aStr1.getStr()); + + rtl_str_toAsciiUpperCase( pStr ); + + CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); + free(pStr); + } + + // 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(toAsciiUpperCase); + CPPUNIT_TEST(toAsciiUpperCase_000); + CPPUNIT_TEST(toAsciiUpperCase_001); + CPPUNIT_TEST_SUITE_END(); + }; // class replaceChar + + + class toAsciiUpperCase_WithLength : public CppUnit::TestFixture + { + public: + + void toAsciiUpperCase_WithLength_000() + { + rtl_str_toAsciiUpperCase_WithLength( NULL, 0 ); + } + + void toAsciiUpperCase_WithLength_001() + { + rtl::OString aStr1 = "change this to ascii lower case."; + rtl::OString aShouldStr1 = "CHANGE THIs to ascii lower case."; + + sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); + CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); + + strcpy(pStr, aStr1.getStr()); + rtl_str_toAsciiUpperCase_WithLength( pStr, 10 ); + + t_print("Uppercase with length: '%s'\n", aStr1.getStr()); + CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); + free(pStr); + } + + // 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(toAsciiUpperCase_WithLength); + CPPUNIT_TEST(toAsciiUpperCase_WithLength_000); + CPPUNIT_TEST(toAsciiUpperCase_WithLength_001); + CPPUNIT_TEST_SUITE_END(); + }; // class replaceChar + + + // ----------------------------------------------------------------------------- + + class trim_WithLength : public CppUnit::TestFixture + { + public: + void trim_WithLength_000() + { + rtl_str_trim_WithLength(NULL, 0); + // should not GPF + } + + void trim_WithLength_000_1() + { + char pStr[] = { " trim this" }; + rtl_str_trim_WithLength( pStr, 0 ); + } + + void trim_WithLength_001() + { + char const *pStr = " trim this"; + sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); + if (pStr2) + { + strcpy(pStr2, pStr); + rtl_str_trim_WithLength( pStr2, 2 ); + + CPPUNIT_ASSERT_MESSAGE("string should be empty", strlen(pStr2) == 0); + free(pStr2); + } + } + + void trim_WithLength_002() + { + char const *pStr = "trim this"; + sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); + if (pStr2) + { + strcpy(pStr2, pStr); + rtl_str_trim_WithLength( pStr2, 5 ); + + CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 4); + free(pStr2); + } + } + + void trim_WithLength_003() + { + char const *pStr = " trim this"; + sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); + if (pStr2) + { + strcpy(pStr2, pStr); + rtl_str_trim_WithLength( pStr2, 11 ); + + CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 4); + free(pStr2); + } + } + + void trim_WithLength_004() + { + char const *pStr = "\r\n\t \n\r trim \n this"; + sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); + if (pStr2) + { + strcpy(pStr2, pStr); + rtl_str_trim_WithLength( pStr2, 17 ); + + CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 4); + free(pStr2); + } + } + + void trim_WithLength_005() + { + char const *pStr = "\r\n\t \n\r trim \t this \n\r\t\t "; + sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); + if (pStr2) + { + strcpy(pStr2, pStr); + rtl_str_trim_WithLength( pStr2, strlen(pStr2) ); + + CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 11); + free(pStr2); + } + } + + // 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(trim_WithLength); + CPPUNIT_TEST(trim_WithLength_000); + CPPUNIT_TEST(trim_WithLength_000_1); + CPPUNIT_TEST(trim_WithLength_001); + CPPUNIT_TEST(trim_WithLength_002); + CPPUNIT_TEST(trim_WithLength_003); + CPPUNIT_TEST(trim_WithLength_004); + CPPUNIT_TEST(trim_WithLength_005); + CPPUNIT_TEST_SUITE_END(); + }; + + // ----------------------------------------------------------------------------- + + class valueOfChar : public CppUnit::TestFixture + { + public: + void valueOfChar_000() + { + rtl_str_valueOfChar(NULL, 0); + // should not GPF + } + void valueOfChar_001() + { + sal_Char *pStr = (sal_Char*)malloc(RTL_STR_MAX_VALUEOFCHAR); + if (pStr) + { + rtl_str_valueOfChar(pStr, 'A'); + + CPPUNIT_ASSERT_MESSAGE("string should contain 'A'", pStr[0] == 'A'); + free(pStr); + } + } + + // 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(valueOfChar); + CPPUNIT_TEST(valueOfChar_000); + CPPUNIT_TEST(valueOfChar_001); + CPPUNIT_TEST_SUITE_END(); + }; + +// ----------------------------------------------------------------------------- +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::compare, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::compareIgnoreAsciiCase, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::shortenedCompareIgnoreAsciiCase_WithLength, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::hashCode, "rtl_str"); + +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::indexOfChar, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::lastIndexOfChar, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::indexOfStr, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::lastIndexOfStr, "rtl_str"); + +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::replaceChar, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::replaceChar_WithLength, "rtl_str"); + +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::toAsciiLowerCase, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::toAsciiLowerCase_WithLength, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::toAsciiUpperCase, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::toAsciiUpperCase_WithLength, "rtl_str"); + +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::trim_WithLength, "rtl_str"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::valueOfChar, "rtl_str"); + +} // namespace rtl_str + +// ----------------------------------------------------------------------------- + +// 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. +NOADDITIONAL; diff --git a/sal/qa/rtl/ostring/rtl_str.xsce b/sal/qa/rtl/ostring/rtl_str.xsce new file mode 100644 index 000000000000..e7a624ae2710 --- /dev/null +++ b/sal/qa/rtl/ostring/rtl_str.xsce @@ -0,0 +1,26 @@ +# signaled with SIGNAL 11 +rtl_str.compare.compare_000 +rtl_str.compare.compare_000_1 + +rtl_str.compareIgnoreAsciiCase.compare_000 +rtl_str.compareIgnoreAsciiCase.compare_000_1 + +rtl_str.hashCode.hashCode_000 + +rtl_str.indexOfChar.indexOfChar_000 + +rtl_str.lastIndexOfChar.lastIndexOfChar_000 + +rtl_str.indexOfStr.indexOfStr_000 + +rtl_str.lastIndexOfStr.lastIndexOfStr_000 + +rtl_str.replaceChar.replaceChar_000 + +rtl_str.replaceChar_WithLength.replaceChar_WithLength_000_1 + +rtl_str.toAsciiLowerCase.toAsciiLowerCase_000 + +rtl_str.toAsciiUpperCase.toAsciiUpperCase_000 + +rtl_str.valueOfChar.valueOfChar_000 diff --git a/sal/qa/rtl/ostring/rtl_string.cxx b/sal/qa/rtl/ostring/rtl_string.cxx new file mode 100644 index 000000000000..e252476f3f8c --- /dev/null +++ b/sal/qa/rtl/ostring/rtl_string.cxx @@ -0,0 +1,183 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sal.hxx" +#include <testshl/simpleheader.hxx> + +namespace rtl_string +{ + + class getLength : public CppUnit::TestFixture + { + public: + + void getLength_000() + { + rtl_string_getLength( NULL ); + // should not GPF + } + + void getLength_001() + { + rtl::OString aStr("Test Length."); + sal_Int32 nValue = rtl_string_getLength( aStr.pData ); + + CPPUNIT_ASSERT_MESSAGE("Length must equal getLength()", aStr.getLength() == nValue); + CPPUNIT_ASSERT_MESSAGE( + "Length must equal strlen()", + nValue >= 0 + && (strlen(aStr.getStr()) + == sal::static_int_cast< sal_uInt32 >(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(getLength); + CPPUNIT_TEST(getLength_000); + CPPUNIT_TEST(getLength_001); + CPPUNIT_TEST_SUITE_END(); + }; // class getLength + +// ----------------------------------------------------------------------------- + + class newFromString : public CppUnit::TestFixture + { + public: + + // void newFromString_000() + // { + // sal_Int32 nValue = rtl_string_newFromString( NULL, NULL ); + // // should not GPF + // } + + void newFromString_001() + { + rtl::OString aStr("Test Length."); + rtl_String *pStr = NULL; + + rtl_string_newFromString( &pStr, aStr.pData ); + + rtl::OString aNewStr(pStr); + CPPUNIT_ASSERT_MESSAGE("Strings must be equal", aStr.equals(aNewStr) == sal_True); + + rtl_string_release(pStr); + } + // 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(newFromString); + // CPPUNIT_TEST(newFromString_000); + CPPUNIT_TEST(newFromString_001); + CPPUNIT_TEST_SUITE_END(); + }; // class newFromString + + // ----------------------------------------------------------------------------- + + class convertUStringToString : public CppUnit::TestFixture + { + public: + + // void newFromString_000() + // { + // sal_Int32 nValue = rtl_string_newFromString( NULL, NULL ); + // // should not GPF + // } + + void convertUStringToString_001() + { + rtl::OUString suString = rtl::OUString::createFromAscii("Hello"); + rtl::OString sString; + sal_Bool bRet = rtl_convertUStringToString(&sString.pData, suString.getStr(), suString.getLength(), RTL_TEXTENCODING_ASCII_US, OUSTRING_TO_OSTRING_CVTFLAGS); + + CPPUNIT_ASSERT_MESSAGE("Strings must be equal", bRet == sal_True && sString.equals(rtl::OString("Hello")) == sal_True); + } + + void convertUStringToString_002() + { + rtl::OString sStr("H\xE4llo"); + rtl::OUString suString = rtl::OStringToOUString(sStr, RTL_TEXTENCODING_ISO_8859_15); + + rtl::OString sString; + sal_Bool bRet = rtl_convertUStringToString(&sString.pData, suString.getStr(), suString.getLength(), RTL_TEXTENCODING_ISO_8859_15, OUSTRING_TO_OSTRING_CVTFLAGS); + + CPPUNIT_ASSERT_MESSAGE("Strings must be equal", bRet == sal_True && sString.equals(rtl::OString("H\xE4llo")) == sal_True); + } + + void convertUStringToString_003() + { + rtl::OString sStr("H\xC3\xA4llo"); + rtl::OUString suString = rtl::OStringToOUString(sStr, RTL_TEXTENCODING_UTF8); + + rtl::OString sString; + sal_Bool bRet = rtl_convertUStringToString(&sString.pData, suString.getStr(), suString.getLength(), RTL_TEXTENCODING_ISO_8859_15, OUSTRING_TO_OSTRING_CVTFLAGS); + + CPPUNIT_ASSERT_MESSAGE("Strings must be equal", bRet == sal_True && sString.equals(rtl::OString("H\xE4llo")) == sal_True); + } + + void convertUStringToString_004() + { + rtl::OString sStr("Tsch\xFC\xDF"); + rtl::OUString suString = rtl::OStringToOUString(sStr, RTL_TEXTENCODING_ISO_8859_15); + rtl::OString sString; + + sal_Bool bRet = rtl_convertUStringToString(&sString.pData, suString.getStr(), suString.getLength(), RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS); + /* sal_Bool */ bRet = rtl_convertUStringToString(&sString.pData, suString.getStr(), suString.getLength(), RTL_TEXTENCODING_ISO_8859_15, OUSTRING_TO_OSTRING_CVTFLAGS); + CPPUNIT_ASSERT_MESSAGE("Strings must be equal", bRet == sal_True && sString.equals(rtl::OString("Tsch\xFC\xDF")) == sal_True); + } + + + + // 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(convertUStringToString); + CPPUNIT_TEST(convertUStringToString_001); + CPPUNIT_TEST(convertUStringToString_002); + CPPUNIT_TEST(convertUStringToString_003); + CPPUNIT_TEST(convertUStringToString_004); + CPPUNIT_TEST_SUITE_END(); + }; // class convertUStringToString + + + +} // namespace rtl_string + +// ----------------------------------------------------------------------------- +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_string::getLength, "rtl_string"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_string::newFromString, "rtl_string"); +CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_string::convertUStringToString, "rtl_string"); + +// ----------------------------------------------------------------------------- + +// 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. +NOADDITIONAL; diff --git a/sal/qa/rtl/ostring/rtl_string.xsce b/sal/qa/rtl/ostring/rtl_string.xsce new file mode 100644 index 000000000000..0e37ab00baab --- /dev/null +++ b/sal/qa/rtl/ostring/rtl_string.xsce @@ -0,0 +1 @@ +rtl_string.getLength.getLength_000 |