1*87d2adbcSAndrew Rist /************************************************************** 2cdf0e10cSrcweir * 3*87d2adbcSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one 4*87d2adbcSAndrew Rist * or more contributor license agreements. See the NOTICE file 5*87d2adbcSAndrew Rist * distributed with this work for additional information 6*87d2adbcSAndrew Rist * regarding copyright ownership. The ASF licenses this file 7*87d2adbcSAndrew Rist * to you under the Apache License, Version 2.0 (the 8*87d2adbcSAndrew Rist * "License"); you may not use this file except in compliance 9*87d2adbcSAndrew Rist * with the License. You may obtain a copy of the License at 10*87d2adbcSAndrew Rist * 11*87d2adbcSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0 12*87d2adbcSAndrew Rist * 13*87d2adbcSAndrew Rist * Unless required by applicable law or agreed to in writing, 14*87d2adbcSAndrew Rist * software distributed under the License is distributed on an 15*87d2adbcSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16*87d2adbcSAndrew Rist * KIND, either express or implied. See the License for the 17*87d2adbcSAndrew Rist * specific language governing permissions and limitations 18*87d2adbcSAndrew Rist * under the License. 19*87d2adbcSAndrew Rist * 20*87d2adbcSAndrew Rist *************************************************************/ 21*87d2adbcSAndrew Rist 22*87d2adbcSAndrew Rist 23cdf0e10cSrcweir 24cdf0e10cSrcweir 25cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 26cdf0e10cSrcweir #include "precompiled_sal.hxx" 27cdf0e10cSrcweir #include <testshl/simpleheader.hxx> 28cdf0e10cSrcweir 29cdf0e10cSrcweir namespace rtl_str 30cdf0e10cSrcweir { 31cdf0e10cSrcweir 32cdf0e10cSrcweir class compare : public CppUnit::TestFixture 33cdf0e10cSrcweir { 34cdf0e10cSrcweir public: 35cdf0e10cSrcweir compare_000()36cdf0e10cSrcweir void compare_000() 37cdf0e10cSrcweir { 38cdf0e10cSrcweir rtl_str_compare( NULL, NULL); 39cdf0e10cSrcweir } 40cdf0e10cSrcweir compare_000_1()41cdf0e10cSrcweir void compare_000_1() 42cdf0e10cSrcweir { 43cdf0e10cSrcweir rtl::OString aStr1 = "Line must be equal."; 44cdf0e10cSrcweir rtl_str_compare( aStr1.getStr(), NULL); 45cdf0e10cSrcweir } compare_001()46cdf0e10cSrcweir void compare_001() 47cdf0e10cSrcweir { 48cdf0e10cSrcweir rtl::OString aStr1 = ""; 49cdf0e10cSrcweir rtl::OString aStr2 = ""; 50cdf0e10cSrcweir 51cdf0e10cSrcweir sal_Int32 nValue = rtl_str_compare( aStr1.getStr(), aStr2.getStr()); 52cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 53cdf0e10cSrcweir } 54cdf0e10cSrcweir compare_002()55cdf0e10cSrcweir void compare_002() 56cdf0e10cSrcweir { 57cdf0e10cSrcweir rtl::OString aStr1 = "Line must be equal."; 58cdf0e10cSrcweir rtl::OString aStr2 = "Line must be equal."; 59cdf0e10cSrcweir 60cdf0e10cSrcweir sal_Int32 nValue = rtl_str_compare( aStr1.getStr(), aStr2.getStr()); 61cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 62cdf0e10cSrcweir } 63cdf0e10cSrcweir compare_003()64cdf0e10cSrcweir void compare_003() 65cdf0e10cSrcweir { 66cdf0e10cSrcweir rtl::OString aStr1 = "Line must differ."; 67cdf0e10cSrcweir rtl::OString aStr2 = "Line foo bar, ok, differ."; 68cdf0e10cSrcweir 69cdf0e10cSrcweir sal_Int32 nValue = rtl_str_compare( aStr1.getStr(), aStr2.getStr()); 70cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 71cdf0e10cSrcweir } 72cdf0e10cSrcweir 73cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 74cdf0e10cSrcweir // member functions of the current class, 75cdf0e10cSrcweir // because these macros are need by auto register mechanism. 76cdf0e10cSrcweir 77cdf0e10cSrcweir CPPUNIT_TEST_SUITE(compare); 78cdf0e10cSrcweir CPPUNIT_TEST(compare_000); 79cdf0e10cSrcweir CPPUNIT_TEST(compare_000_1); 80cdf0e10cSrcweir CPPUNIT_TEST(compare_001); 81cdf0e10cSrcweir CPPUNIT_TEST(compare_002); 82cdf0e10cSrcweir CPPUNIT_TEST(compare_003); 83cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 84cdf0e10cSrcweir }; // class compare 85cdf0e10cSrcweir 86cdf0e10cSrcweir 87cdf0e10cSrcweir class compareIgnoreAsciiCase : public CppUnit::TestFixture 88cdf0e10cSrcweir { 89cdf0e10cSrcweir public: 90cdf0e10cSrcweir compare_000()91cdf0e10cSrcweir void compare_000() 92cdf0e10cSrcweir { 93cdf0e10cSrcweir rtl_str_compareIgnoreAsciiCase( NULL, NULL); 94cdf0e10cSrcweir } 95cdf0e10cSrcweir compare_000_1()96cdf0e10cSrcweir void compare_000_1() 97cdf0e10cSrcweir { 98cdf0e10cSrcweir rtl::OString aStr1 = "Line must be equal."; 99cdf0e10cSrcweir rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), NULL); 100cdf0e10cSrcweir } compare_001()101cdf0e10cSrcweir void compare_001() 102cdf0e10cSrcweir { 103cdf0e10cSrcweir rtl::OString aStr1 = ""; 104cdf0e10cSrcweir rtl::OString aStr2 = ""; 105cdf0e10cSrcweir 106cdf0e10cSrcweir sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 107cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 108cdf0e10cSrcweir } 109cdf0e10cSrcweir compare_002()110cdf0e10cSrcweir void compare_002() 111cdf0e10cSrcweir { 112cdf0e10cSrcweir rtl::OString aStr1 = "Line must be equal."; 113cdf0e10cSrcweir rtl::OString aStr2 = "Line must be equal."; 114cdf0e10cSrcweir 115cdf0e10cSrcweir sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 116cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 117cdf0e10cSrcweir } 118cdf0e10cSrcweir compare_002_1()119cdf0e10cSrcweir void compare_002_1() 120cdf0e10cSrcweir { 121cdf0e10cSrcweir rtl::OString aStr1 = "Line must be equal."; 122cdf0e10cSrcweir rtl::OString aStr2 = "LINE MUST BE EQUAL."; 123cdf0e10cSrcweir 124cdf0e10cSrcweir sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 125cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); 126cdf0e10cSrcweir } 127cdf0e10cSrcweir compare_003()128cdf0e10cSrcweir void compare_003() 129cdf0e10cSrcweir { 130cdf0e10cSrcweir rtl::OString aStr1 = "Line must differ."; 131cdf0e10cSrcweir rtl::OString aStr2 = "Line foo bar, ok, differ."; 132cdf0e10cSrcweir 133cdf0e10cSrcweir sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 134cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 135cdf0e10cSrcweir } 136cdf0e10cSrcweir 137cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 138cdf0e10cSrcweir // member functions of the current class, 139cdf0e10cSrcweir // because these macros are need by auto register mechanism. 140cdf0e10cSrcweir 141cdf0e10cSrcweir CPPUNIT_TEST_SUITE(compareIgnoreAsciiCase); 142cdf0e10cSrcweir CPPUNIT_TEST(compare_000); 143cdf0e10cSrcweir CPPUNIT_TEST(compare_000_1); 144cdf0e10cSrcweir CPPUNIT_TEST(compare_001); 145cdf0e10cSrcweir CPPUNIT_TEST(compare_002); 146cdf0e10cSrcweir CPPUNIT_TEST(compare_002_1); 147cdf0e10cSrcweir CPPUNIT_TEST(compare_003); 148cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 149cdf0e10cSrcweir }; // class compareIgnoreAsciiCase 150cdf0e10cSrcweir 151cdf0e10cSrcweir // ----------------------------------------------------------------------------- 152cdf0e10cSrcweir 153cdf0e10cSrcweir class shortenedCompareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture 154cdf0e10cSrcweir { 155cdf0e10cSrcweir public: 156cdf0e10cSrcweir compare_000()157cdf0e10cSrcweir void compare_000() 158cdf0e10cSrcweir { 159cdf0e10cSrcweir rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0, 0); 160cdf0e10cSrcweir } 161cdf0e10cSrcweir compare_000_1()162cdf0e10cSrcweir void compare_000_1() 163cdf0e10cSrcweir { 164cdf0e10cSrcweir rtl::OString aStr1 = "Line must be equal."; 165cdf0e10cSrcweir rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0, 1); 166cdf0e10cSrcweir } compare_001()167cdf0e10cSrcweir void compare_001() 168cdf0e10cSrcweir { 169cdf0e10cSrcweir rtl::OString aStr1 = ""; 170cdf0e10cSrcweir rtl::OString aStr2 = ""; 171cdf0e10cSrcweir 172cdf0e10cSrcweir sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), aStr2.getStr(), aStr2.getLength(), aStr1.getLength()); 173cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 174cdf0e10cSrcweir } 175cdf0e10cSrcweir compare_002()176cdf0e10cSrcweir void compare_002() 177cdf0e10cSrcweir { 178cdf0e10cSrcweir rtl::OString aStr1 = "Line must be equal."; 179cdf0e10cSrcweir rtl::OString aStr2 = "Line must be equal."; 180cdf0e10cSrcweir 181cdf0e10cSrcweir sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 182cdf0e10cSrcweir aStr2.getStr(), aStr2.getLength(), 183cdf0e10cSrcweir aStr1.getLength()); 184cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 185cdf0e10cSrcweir } 186cdf0e10cSrcweir compare_002_1()187cdf0e10cSrcweir void compare_002_1() 188cdf0e10cSrcweir { 189cdf0e10cSrcweir rtl::OString aStr1 = "Line must be equal."; 190cdf0e10cSrcweir rtl::OString aStr2 = "LINE MUST BE EQUAL."; 191cdf0e10cSrcweir 192cdf0e10cSrcweir sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 193cdf0e10cSrcweir aStr2.getStr(), aStr2.getLength(), 194cdf0e10cSrcweir aStr1.getLength()); 195cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); 196cdf0e10cSrcweir } 197cdf0e10cSrcweir compare_003()198cdf0e10cSrcweir void compare_003() 199cdf0e10cSrcweir { 200cdf0e10cSrcweir rtl::OString aStr1 = "Line must differ."; 201cdf0e10cSrcweir rtl::OString aStr2 = "Line foo bar, ok, differ."; 202cdf0e10cSrcweir 203cdf0e10cSrcweir sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 204cdf0e10cSrcweir aStr2.getStr(), aStr2.getLength(), 205cdf0e10cSrcweir 5); 206cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal first 5 characters.", nValue == 0); 207cdf0e10cSrcweir } 208cdf0e10cSrcweir compare_004()209cdf0e10cSrcweir void compare_004() 210cdf0e10cSrcweir { 211cdf0e10cSrcweir rtl::OString aStr1 = "Line must differ."; 212cdf0e10cSrcweir rtl::OString aStr2 = "Line foo bar, ok, differ."; 213cdf0e10cSrcweir 214cdf0e10cSrcweir sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 215cdf0e10cSrcweir aStr2.getStr(), aStr2.getLength(), 216cdf0e10cSrcweir aStr1.getLength()); 217cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 218cdf0e10cSrcweir } 219cdf0e10cSrcweir 220cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 221cdf0e10cSrcweir // member functions of the current class, 222cdf0e10cSrcweir // because these macros are need by auto register mechanism. 223cdf0e10cSrcweir 224cdf0e10cSrcweir CPPUNIT_TEST_SUITE(shortenedCompareIgnoreAsciiCase_WithLength); 225cdf0e10cSrcweir CPPUNIT_TEST(compare_000); 226cdf0e10cSrcweir CPPUNIT_TEST(compare_000_1); 227cdf0e10cSrcweir CPPUNIT_TEST(compare_001); 228cdf0e10cSrcweir CPPUNIT_TEST(compare_002); 229cdf0e10cSrcweir CPPUNIT_TEST(compare_002_1); 230cdf0e10cSrcweir CPPUNIT_TEST(compare_003); 231cdf0e10cSrcweir CPPUNIT_TEST(compare_004); 232cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 233cdf0e10cSrcweir }; // class compare 234cdf0e10cSrcweir 235cdf0e10cSrcweir 236cdf0e10cSrcweir // ----------------------------------------------------------------------------- 237cdf0e10cSrcweir 238cdf0e10cSrcweir class hashCode : public CppUnit::TestFixture 239cdf0e10cSrcweir { 240cdf0e10cSrcweir public: 241cdf0e10cSrcweir hashCode_000()242cdf0e10cSrcweir void hashCode_000() 243cdf0e10cSrcweir { 244cdf0e10cSrcweir rtl_str_hashCode( NULL ); 245cdf0e10cSrcweir } 246cdf0e10cSrcweir hashCode_001()247cdf0e10cSrcweir void hashCode_001() 248cdf0e10cSrcweir { 249cdf0e10cSrcweir rtl::OString aStr1 = "Line for a hashCode."; 250cdf0e10cSrcweir sal_Int32 nHashCode = rtl_str_hashCode( aStr1.getStr() ); 251cdf0e10cSrcweir t_print("hashcode: %d\n", nHashCode); 252cdf0e10cSrcweir // CPPUNIT_ASSERT_MESSAGE("failed.", nValue == 0); 253cdf0e10cSrcweir } 254cdf0e10cSrcweir hashCode_002()255cdf0e10cSrcweir void hashCode_002() 256cdf0e10cSrcweir { 257cdf0e10cSrcweir rtl::OString aStr1 = "Line for a hashCode."; 258cdf0e10cSrcweir sal_Int32 nHashCode1 = rtl_str_hashCode( aStr1.getStr() ); 259cdf0e10cSrcweir 260cdf0e10cSrcweir rtl::OString aStr2 = "Line for a hashCode."; 261cdf0e10cSrcweir sal_Int32 nHashCode2 = rtl_str_hashCode( aStr2.getStr() ); 262cdf0e10cSrcweir 263cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("hashcodes must be equal.", nHashCode1 == nHashCode2 ); 264cdf0e10cSrcweir } 265cdf0e10cSrcweir hashCode_003()266cdf0e10cSrcweir void hashCode_003() 267cdf0e10cSrcweir { 268cdf0e10cSrcweir rtl::OString aStr1 = "Line for a hashCode."; 269cdf0e10cSrcweir sal_Int32 nHashCode1 = rtl_str_hashCode( aStr1.getStr() ); 270cdf0e10cSrcweir 271cdf0e10cSrcweir rtl::OString aStr2 = "Line for an other hashcode."; 272cdf0e10cSrcweir sal_Int32 nHashCode2 = rtl_str_hashCode( aStr2.getStr() ); 273cdf0e10cSrcweir 274cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("hashcodes must differ.", nHashCode1 != nHashCode2 ); 275cdf0e10cSrcweir } 276cdf0e10cSrcweir 277cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 278cdf0e10cSrcweir // member functions of the current class, 279cdf0e10cSrcweir // because these macros are need by auto register mechanism. 280cdf0e10cSrcweir 281cdf0e10cSrcweir CPPUNIT_TEST_SUITE(hashCode); 282cdf0e10cSrcweir CPPUNIT_TEST(hashCode_000); 283cdf0e10cSrcweir CPPUNIT_TEST(hashCode_001); 284cdf0e10cSrcweir CPPUNIT_TEST(hashCode_002); 285cdf0e10cSrcweir CPPUNIT_TEST(hashCode_003); 286cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 287cdf0e10cSrcweir }; // class compare 288cdf0e10cSrcweir 289cdf0e10cSrcweir 290cdf0e10cSrcweir // ----------------------------------------------------------------------------- 291cdf0e10cSrcweir 292cdf0e10cSrcweir class indexOfChar : public CppUnit::TestFixture 293cdf0e10cSrcweir { 294cdf0e10cSrcweir public: 295cdf0e10cSrcweir indexOfChar_000()296cdf0e10cSrcweir void indexOfChar_000() 297cdf0e10cSrcweir { 298cdf0e10cSrcweir rtl_str_indexOfChar( NULL, 0 ); 299cdf0e10cSrcweir } 300cdf0e10cSrcweir indexOfChar_001()301cdf0e10cSrcweir void indexOfChar_001() 302cdf0e10cSrcweir { 303cdf0e10cSrcweir rtl::OString aStr1 = "Line for a indexOfChar."; 304cdf0e10cSrcweir 305cdf0e10cSrcweir sal_Int32 nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'L' ); 306cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); 307cdf0e10cSrcweir 308cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'i' ); 309cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 1); 310cdf0e10cSrcweir 311cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'n' ); 312cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 2); 313cdf0e10cSrcweir 314cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'e' ); 315cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 3); 316cdf0e10cSrcweir } 317cdf0e10cSrcweir indexOfChar_002()318cdf0e10cSrcweir void indexOfChar_002() 319cdf0e10cSrcweir { 320cdf0e10cSrcweir rtl::OString aStr1 = "Line for a indexOfChar."; 321cdf0e10cSrcweir sal_Int32 nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'y' ); 322cdf0e10cSrcweir 323cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); 324cdf0e10cSrcweir } 325cdf0e10cSrcweir 326cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 327cdf0e10cSrcweir // member functions of the current class, 328cdf0e10cSrcweir // because these macros are need by auto register mechanism. 329cdf0e10cSrcweir 330cdf0e10cSrcweir CPPUNIT_TEST_SUITE(indexOfChar); 331cdf0e10cSrcweir CPPUNIT_TEST(indexOfChar_000); 332cdf0e10cSrcweir CPPUNIT_TEST(indexOfChar_001); 333cdf0e10cSrcweir CPPUNIT_TEST(indexOfChar_002); 334cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 335cdf0e10cSrcweir }; // class compare 336cdf0e10cSrcweir 337cdf0e10cSrcweir // ----------------------------------------------------------------------------- 338cdf0e10cSrcweir class lastIndexOfChar : public CppUnit::TestFixture 339cdf0e10cSrcweir { 340cdf0e10cSrcweir public: 341cdf0e10cSrcweir lastIndexOfChar_000()342cdf0e10cSrcweir void lastIndexOfChar_000() 343cdf0e10cSrcweir { 344cdf0e10cSrcweir rtl_str_lastIndexOfChar( NULL, 0 ); 345cdf0e10cSrcweir } 346cdf0e10cSrcweir lastIndexOfChar_001()347cdf0e10cSrcweir void lastIndexOfChar_001() 348cdf0e10cSrcweir { 349cdf0e10cSrcweir rtl::OString aStr1 = "Line for a lastIndexOfChar."; 350cdf0e10cSrcweir 351cdf0e10cSrcweir sal_Int32 nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'C' ); 352cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 22); 353cdf0e10cSrcweir 354cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'h' ); 355cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 23); 356cdf0e10cSrcweir 357cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'a' ); 358cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 24); 359cdf0e10cSrcweir 360cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'r' ); 361cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 25); 362cdf0e10cSrcweir } 363cdf0e10cSrcweir lastIndexOfChar_002()364cdf0e10cSrcweir void lastIndexOfChar_002() 365cdf0e10cSrcweir { 366cdf0e10cSrcweir rtl::OString aStr1 = "Line for a lastIndexOfChar."; 367cdf0e10cSrcweir sal_Int32 nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'y' ); 368cdf0e10cSrcweir 369cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); 370cdf0e10cSrcweir } 371cdf0e10cSrcweir 372cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 373cdf0e10cSrcweir // member functions of the current class, 374cdf0e10cSrcweir // because these macros are need by auto register mechanism. 375cdf0e10cSrcweir 376cdf0e10cSrcweir CPPUNIT_TEST_SUITE(lastIndexOfChar); 377cdf0e10cSrcweir CPPUNIT_TEST(lastIndexOfChar_000); 378cdf0e10cSrcweir CPPUNIT_TEST(lastIndexOfChar_001); 379cdf0e10cSrcweir CPPUNIT_TEST(lastIndexOfChar_002); 380cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 381cdf0e10cSrcweir }; // class lastIndexOfChar 382cdf0e10cSrcweir 383cdf0e10cSrcweir 384cdf0e10cSrcweir // ----------------------------------------------------------------------------- 385cdf0e10cSrcweir 386cdf0e10cSrcweir class indexOfStr : public CppUnit::TestFixture 387cdf0e10cSrcweir { 388cdf0e10cSrcweir public: 389cdf0e10cSrcweir indexOfStr_000()390cdf0e10cSrcweir void indexOfStr_000() 391cdf0e10cSrcweir { 392cdf0e10cSrcweir rtl_str_indexOfStr( NULL, 0 ); 393cdf0e10cSrcweir } 394cdf0e10cSrcweir indexOfStr_000_1()395cdf0e10cSrcweir void indexOfStr_000_1() 396cdf0e10cSrcweir { 397cdf0e10cSrcweir rtl::OString aStr1 = "Line for a indexOfStr."; 398cdf0e10cSrcweir rtl_str_indexOfStr( aStr1.getStr(), 0 ); 399cdf0e10cSrcweir } 400cdf0e10cSrcweir indexOfStr_001()401cdf0e10cSrcweir void indexOfStr_001() 402cdf0e10cSrcweir { 403cdf0e10cSrcweir rtl::OString aStr1 = "Line for a indexOfStr."; 404cdf0e10cSrcweir 405cdf0e10cSrcweir sal_Int32 nIndex = rtl_str_indexOfStr( aStr1.getStr(), "Line" ); 406cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); 407cdf0e10cSrcweir 408cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_indexOfStr( aStr1.getStr(), "for" ); 409cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 5); 410cdf0e10cSrcweir 411cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_indexOfStr( aStr1.getStr(), "a" ); 412cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 9); 413cdf0e10cSrcweir 414cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_indexOfStr( aStr1.getStr(), "a index" ); 415cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex ==9); 416cdf0e10cSrcweir } 417cdf0e10cSrcweir indexOfStr_002()418cdf0e10cSrcweir void indexOfStr_002() 419cdf0e10cSrcweir { 420cdf0e10cSrcweir rtl::OString aStr1 = "Line for a indexOfStr."; 421cdf0e10cSrcweir sal_Int32 nIndex = rtl_str_indexOfStr( aStr1.getStr(), "not exist" ); 422cdf0e10cSrcweir 423cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); 424cdf0e10cSrcweir } 425cdf0e10cSrcweir 426cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 427cdf0e10cSrcweir // member functions of the current class, 428cdf0e10cSrcweir // because these macros are need by auto register mechanism. 429cdf0e10cSrcweir 430cdf0e10cSrcweir CPPUNIT_TEST_SUITE(indexOfStr); 431cdf0e10cSrcweir CPPUNIT_TEST(indexOfStr_000); 432cdf0e10cSrcweir CPPUNIT_TEST(indexOfStr_001); 433cdf0e10cSrcweir CPPUNIT_TEST(indexOfStr_002); 434cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 435cdf0e10cSrcweir }; // class compare 436cdf0e10cSrcweir // ----------------------------------------------------------------------------- 437cdf0e10cSrcweir 438cdf0e10cSrcweir 439cdf0e10cSrcweir class lastIndexOfStr : public CppUnit::TestFixture 440cdf0e10cSrcweir { 441cdf0e10cSrcweir public: 442cdf0e10cSrcweir lastIndexOfStr_000()443cdf0e10cSrcweir void lastIndexOfStr_000() 444cdf0e10cSrcweir { 445cdf0e10cSrcweir rtl_str_lastIndexOfStr( NULL, NULL ); 446cdf0e10cSrcweir } 447cdf0e10cSrcweir lastIndexOfStr_000_1()448cdf0e10cSrcweir void lastIndexOfStr_000_1() 449cdf0e10cSrcweir { 450cdf0e10cSrcweir rtl::OString aStr1 = "Line for a lastIndexOfStr."; 451cdf0e10cSrcweir rtl_str_lastIndexOfStr( aStr1.getStr(), NULL ); 452cdf0e10cSrcweir } 453cdf0e10cSrcweir lastIndexOfStr_001()454cdf0e10cSrcweir void lastIndexOfStr_001() 455cdf0e10cSrcweir { 456cdf0e10cSrcweir rtl::OString aStr1 = "Line for a lastIndexOfStr."; 457cdf0e10cSrcweir rtl::OString aSearchStr = "Index"; 458cdf0e10cSrcweir 459cdf0e10cSrcweir sal_Int32 nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 460cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 15); 461cdf0e10cSrcweir 462cdf0e10cSrcweir /* rtl::OString */ aSearchStr = "Line"; 463cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 464cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); 465cdf0e10cSrcweir 466cdf0e10cSrcweir /* rtl::OString */ aSearchStr = ""; 467cdf0e10cSrcweir /* sal_Int32 */ nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 468cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1); 469cdf0e10cSrcweir } 470cdf0e10cSrcweir lastIndexOfStr_002()471cdf0e10cSrcweir void lastIndexOfStr_002() 472cdf0e10cSrcweir { 473cdf0e10cSrcweir rtl::OString aStr1 = "Line for a lastIndexOfStr."; 474cdf0e10cSrcweir rtl::OString aSearchStr = "foo"; 475cdf0e10cSrcweir sal_Int32 nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 476cdf0e10cSrcweir 477cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); 478cdf0e10cSrcweir } 479cdf0e10cSrcweir lastIndexOfStr_003()480cdf0e10cSrcweir void lastIndexOfStr_003() 481cdf0e10cSrcweir { 482cdf0e10cSrcweir rtl::OString aStr1 = "Line for a lastIndexOfStr."; 483cdf0e10cSrcweir rtl::OString aSearchStr = "O"; 484cdf0e10cSrcweir sal_Int32 nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 485cdf0e10cSrcweir 486cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 20 ); 487cdf0e10cSrcweir } 488cdf0e10cSrcweir 489cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 490cdf0e10cSrcweir // member functions of the current class, 491cdf0e10cSrcweir // because these macros are need by auto register mechanism. 492cdf0e10cSrcweir 493cdf0e10cSrcweir CPPUNIT_TEST_SUITE(lastIndexOfStr); 494cdf0e10cSrcweir CPPUNIT_TEST(lastIndexOfStr_000); 495cdf0e10cSrcweir CPPUNIT_TEST(lastIndexOfStr_001); 496cdf0e10cSrcweir CPPUNIT_TEST(lastIndexOfStr_002); 497cdf0e10cSrcweir CPPUNIT_TEST(lastIndexOfStr_003); 498cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 499cdf0e10cSrcweir }; // class lastIndexOfStr 500cdf0e10cSrcweir 501cdf0e10cSrcweir // ----------------------------------------------------------------------------- 502cdf0e10cSrcweir 503cdf0e10cSrcweir class replaceChar : public CppUnit::TestFixture 504cdf0e10cSrcweir { 505cdf0e10cSrcweir public: 506cdf0e10cSrcweir replaceChar_000()507cdf0e10cSrcweir void replaceChar_000() 508cdf0e10cSrcweir { 509cdf0e10cSrcweir rtl_str_replaceChar( NULL, 0, 0 ); 510cdf0e10cSrcweir } 511cdf0e10cSrcweir replaceChar_001()512cdf0e10cSrcweir void replaceChar_001() 513cdf0e10cSrcweir { 514cdf0e10cSrcweir rtl::OString aStr1 = "replace char."; 515cdf0e10cSrcweir rtl::OString aShouldStr1 = "ruplacu char."; 516cdf0e10cSrcweir 517cdf0e10cSrcweir sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); 518cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 519cdf0e10cSrcweir strcpy(pStr, aStr1.getStr()); 520cdf0e10cSrcweir 521cdf0e10cSrcweir rtl_str_replaceChar( pStr, 'e', 'u' ); 522cdf0e10cSrcweir 523cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); 524cdf0e10cSrcweir free(pStr); 525cdf0e10cSrcweir } 526cdf0e10cSrcweir 527cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 528cdf0e10cSrcweir // member functions of the current class, 529cdf0e10cSrcweir // because these macros are need by auto register mechanism. 530cdf0e10cSrcweir 531cdf0e10cSrcweir CPPUNIT_TEST_SUITE(replaceChar); 532cdf0e10cSrcweir CPPUNIT_TEST(replaceChar_000); 533cdf0e10cSrcweir CPPUNIT_TEST(replaceChar_001); 534cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 535cdf0e10cSrcweir }; // class replaceChar 536cdf0e10cSrcweir 537cdf0e10cSrcweir // ----------------------------------------------------------------------------- 538cdf0e10cSrcweir 539cdf0e10cSrcweir class replaceChar_WithLength : public CppUnit::TestFixture 540cdf0e10cSrcweir { 541cdf0e10cSrcweir public: 542cdf0e10cSrcweir replaceChar_WithLength_000()543cdf0e10cSrcweir void replaceChar_WithLength_000() 544cdf0e10cSrcweir { 545cdf0e10cSrcweir rtl_str_replaceChar_WithLength( NULL, 0, 0, 0 ); 546cdf0e10cSrcweir } 547cdf0e10cSrcweir replaceChar_WithLength_000_1()548cdf0e10cSrcweir void replaceChar_WithLength_000_1() 549cdf0e10cSrcweir { 550cdf0e10cSrcweir rtl_str_replaceChar_WithLength( NULL, 1, 0, 0 ); 551cdf0e10cSrcweir } replaceChar_WithLength_001()552cdf0e10cSrcweir void replaceChar_WithLength_001() 553cdf0e10cSrcweir { 554cdf0e10cSrcweir rtl::OString aStr1 = "replace char."; 555cdf0e10cSrcweir rtl::OString aShouldStr1 = "ruplace char."; 556cdf0e10cSrcweir 557cdf0e10cSrcweir sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); 558cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 559cdf0e10cSrcweir strcpy(pStr, aStr1.getStr()); 560cdf0e10cSrcweir 561cdf0e10cSrcweir rtl_str_replaceChar_WithLength( pStr, 6, 'e', 'u' ); 562cdf0e10cSrcweir 563cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); 564cdf0e10cSrcweir free(pStr); 565cdf0e10cSrcweir } 566cdf0e10cSrcweir 567cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 568cdf0e10cSrcweir // member functions of the current class, 569cdf0e10cSrcweir // because these macros are need by auto register mechanism. 570cdf0e10cSrcweir 571cdf0e10cSrcweir CPPUNIT_TEST_SUITE(replaceChar_WithLength); 572cdf0e10cSrcweir CPPUNIT_TEST(replaceChar_WithLength_000); 573cdf0e10cSrcweir CPPUNIT_TEST(replaceChar_WithLength_000_1); 574cdf0e10cSrcweir CPPUNIT_TEST(replaceChar_WithLength_001); 575cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 576cdf0e10cSrcweir }; // class replaceChar 577cdf0e10cSrcweir 578cdf0e10cSrcweir 579cdf0e10cSrcweir // ----------------------------------------------------------------------------- 580cdf0e10cSrcweir 581cdf0e10cSrcweir class toAsciiLowerCase : public CppUnit::TestFixture 582cdf0e10cSrcweir { 583cdf0e10cSrcweir public: 584cdf0e10cSrcweir toAsciiLowerCase_000()585cdf0e10cSrcweir void toAsciiLowerCase_000() 586cdf0e10cSrcweir { 587cdf0e10cSrcweir rtl_str_toAsciiLowerCase( NULL ); 588cdf0e10cSrcweir } 589cdf0e10cSrcweir toAsciiLowerCase_001()590cdf0e10cSrcweir void toAsciiLowerCase_001() 591cdf0e10cSrcweir { 592cdf0e10cSrcweir rtl::OString aStr1 = "CHANGE THIS TO ASCII LOWER CASE."; 593cdf0e10cSrcweir rtl::OString aShouldStr1 = "change this to ascii lower case."; 594cdf0e10cSrcweir 595cdf0e10cSrcweir sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); 596cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 597cdf0e10cSrcweir strcpy(pStr, aStr1.getStr()); 598cdf0e10cSrcweir 599cdf0e10cSrcweir rtl_str_toAsciiLowerCase( pStr ); 600cdf0e10cSrcweir 601cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); 602cdf0e10cSrcweir free(pStr); 603cdf0e10cSrcweir } 604cdf0e10cSrcweir 605cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 606cdf0e10cSrcweir // member functions of the current class, 607cdf0e10cSrcweir // because these macros are need by auto register mechanism. 608cdf0e10cSrcweir 609cdf0e10cSrcweir CPPUNIT_TEST_SUITE(toAsciiLowerCase); 610cdf0e10cSrcweir CPPUNIT_TEST(toAsciiLowerCase_000); 611cdf0e10cSrcweir CPPUNIT_TEST(toAsciiLowerCase_001); 612cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 613cdf0e10cSrcweir }; // class replaceChar 614cdf0e10cSrcweir 615cdf0e10cSrcweir 616cdf0e10cSrcweir class toAsciiLowerCase_WithLength : public CppUnit::TestFixture 617cdf0e10cSrcweir { 618cdf0e10cSrcweir public: 619cdf0e10cSrcweir toAsciiLowerCase_WithLength_000()620cdf0e10cSrcweir void toAsciiLowerCase_WithLength_000() 621cdf0e10cSrcweir { 622cdf0e10cSrcweir rtl_str_toAsciiLowerCase_WithLength( NULL, 0 ); 623cdf0e10cSrcweir } 624cdf0e10cSrcweir toAsciiLowerCase_WithLength_001()625cdf0e10cSrcweir void toAsciiLowerCase_WithLength_001() 626cdf0e10cSrcweir { 627cdf0e10cSrcweir rtl::OString aStr1 = "CHANGE THIS TO ASCII LOWER CASE."; 628cdf0e10cSrcweir rtl::OString aShouldStr1 = "change thiS TO ASCII LOWER CASE."; 629cdf0e10cSrcweir 630cdf0e10cSrcweir sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); 631cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 632cdf0e10cSrcweir strcpy(pStr, aStr1.getStr()); 633cdf0e10cSrcweir 634cdf0e10cSrcweir rtl_str_toAsciiLowerCase_WithLength( pStr, 10 ); 635cdf0e10cSrcweir 636cdf0e10cSrcweir t_print("Lowercase with length: '%s'\n", pStr); 637cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); 638cdf0e10cSrcweir free(pStr); 639cdf0e10cSrcweir } 640cdf0e10cSrcweir 641cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 642cdf0e10cSrcweir // member functions of the current class, 643cdf0e10cSrcweir // because these macros are need by auto register mechanism. 644cdf0e10cSrcweir 645cdf0e10cSrcweir CPPUNIT_TEST_SUITE(toAsciiLowerCase_WithLength); 646cdf0e10cSrcweir CPPUNIT_TEST(toAsciiLowerCase_WithLength_000); 647cdf0e10cSrcweir CPPUNIT_TEST(toAsciiLowerCase_WithLength_001); 648cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 649cdf0e10cSrcweir }; // class replaceChar 650cdf0e10cSrcweir 651cdf0e10cSrcweir // ----------------------------------------------------------------------------- 652cdf0e10cSrcweir 653cdf0e10cSrcweir class toAsciiUpperCase : public CppUnit::TestFixture 654cdf0e10cSrcweir { 655cdf0e10cSrcweir public: 656cdf0e10cSrcweir toAsciiUpperCase_000()657cdf0e10cSrcweir void toAsciiUpperCase_000() 658cdf0e10cSrcweir { 659cdf0e10cSrcweir rtl_str_toAsciiUpperCase( NULL ); 660cdf0e10cSrcweir } 661cdf0e10cSrcweir toAsciiUpperCase_001()662cdf0e10cSrcweir void toAsciiUpperCase_001() 663cdf0e10cSrcweir { 664cdf0e10cSrcweir rtl::OString aStr1 = "change this to ascii upper case."; 665cdf0e10cSrcweir rtl::OString aShouldStr1 = "CHANGE THIS TO ASCII UPPER CASE."; 666cdf0e10cSrcweir 667cdf0e10cSrcweir sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); 668cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 669cdf0e10cSrcweir strcpy(pStr, aStr1.getStr()); 670cdf0e10cSrcweir 671cdf0e10cSrcweir rtl_str_toAsciiUpperCase( pStr ); 672cdf0e10cSrcweir 673cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); 674cdf0e10cSrcweir free(pStr); 675cdf0e10cSrcweir } 676cdf0e10cSrcweir 677cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 678cdf0e10cSrcweir // member functions of the current class, 679cdf0e10cSrcweir // because these macros are need by auto register mechanism. 680cdf0e10cSrcweir 681cdf0e10cSrcweir CPPUNIT_TEST_SUITE(toAsciiUpperCase); 682cdf0e10cSrcweir CPPUNIT_TEST(toAsciiUpperCase_000); 683cdf0e10cSrcweir CPPUNIT_TEST(toAsciiUpperCase_001); 684cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 685cdf0e10cSrcweir }; // class replaceChar 686cdf0e10cSrcweir 687cdf0e10cSrcweir 688cdf0e10cSrcweir class toAsciiUpperCase_WithLength : public CppUnit::TestFixture 689cdf0e10cSrcweir { 690cdf0e10cSrcweir public: 691cdf0e10cSrcweir toAsciiUpperCase_WithLength_000()692cdf0e10cSrcweir void toAsciiUpperCase_WithLength_000() 693cdf0e10cSrcweir { 694cdf0e10cSrcweir rtl_str_toAsciiUpperCase_WithLength( NULL, 0 ); 695cdf0e10cSrcweir } 696cdf0e10cSrcweir toAsciiUpperCase_WithLength_001()697cdf0e10cSrcweir void toAsciiUpperCase_WithLength_001() 698cdf0e10cSrcweir { 699cdf0e10cSrcweir rtl::OString aStr1 = "change this to ascii lower case."; 700cdf0e10cSrcweir rtl::OString aShouldStr1 = "CHANGE THIs to ascii lower case."; 701cdf0e10cSrcweir 702cdf0e10cSrcweir sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1); 703cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 704cdf0e10cSrcweir 705cdf0e10cSrcweir strcpy(pStr, aStr1.getStr()); 706cdf0e10cSrcweir rtl_str_toAsciiUpperCase_WithLength( pStr, 10 ); 707cdf0e10cSrcweir 708cdf0e10cSrcweir t_print("Uppercase with length: '%s'\n", aStr1.getStr()); 709cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(rtl::OString(pStr)) == sal_True); 710cdf0e10cSrcweir free(pStr); 711cdf0e10cSrcweir } 712cdf0e10cSrcweir 713cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 714cdf0e10cSrcweir // member functions of the current class, 715cdf0e10cSrcweir // because these macros are need by auto register mechanism. 716cdf0e10cSrcweir 717cdf0e10cSrcweir CPPUNIT_TEST_SUITE(toAsciiUpperCase_WithLength); 718cdf0e10cSrcweir CPPUNIT_TEST(toAsciiUpperCase_WithLength_000); 719cdf0e10cSrcweir CPPUNIT_TEST(toAsciiUpperCase_WithLength_001); 720cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 721cdf0e10cSrcweir }; // class replaceChar 722cdf0e10cSrcweir 723cdf0e10cSrcweir 724cdf0e10cSrcweir // ----------------------------------------------------------------------------- 725cdf0e10cSrcweir 726cdf0e10cSrcweir class trim_WithLength : public CppUnit::TestFixture 727cdf0e10cSrcweir { 728cdf0e10cSrcweir public: trim_WithLength_000()729cdf0e10cSrcweir void trim_WithLength_000() 730cdf0e10cSrcweir { 731cdf0e10cSrcweir rtl_str_trim_WithLength(NULL, 0); 732cdf0e10cSrcweir // should not GPF 733cdf0e10cSrcweir } 734cdf0e10cSrcweir trim_WithLength_000_1()735cdf0e10cSrcweir void trim_WithLength_000_1() 736cdf0e10cSrcweir { 737cdf0e10cSrcweir char pStr[] = { " trim this" }; 738cdf0e10cSrcweir rtl_str_trim_WithLength( pStr, 0 ); 739cdf0e10cSrcweir } 740cdf0e10cSrcweir trim_WithLength_001()741cdf0e10cSrcweir void trim_WithLength_001() 742cdf0e10cSrcweir { 743cdf0e10cSrcweir char const *pStr = " trim this"; 744cdf0e10cSrcweir sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); 745cdf0e10cSrcweir if (pStr2) 746cdf0e10cSrcweir { 747cdf0e10cSrcweir strcpy(pStr2, pStr); 748cdf0e10cSrcweir rtl_str_trim_WithLength( pStr2, 2 ); 749cdf0e10cSrcweir 750cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("string should be empty", strlen(pStr2) == 0); 751cdf0e10cSrcweir free(pStr2); 752cdf0e10cSrcweir } 753cdf0e10cSrcweir } 754cdf0e10cSrcweir trim_WithLength_002()755cdf0e10cSrcweir void trim_WithLength_002() 756cdf0e10cSrcweir { 757cdf0e10cSrcweir char const *pStr = "trim this"; 758cdf0e10cSrcweir sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); 759cdf0e10cSrcweir if (pStr2) 760cdf0e10cSrcweir { 761cdf0e10cSrcweir strcpy(pStr2, pStr); 762cdf0e10cSrcweir rtl_str_trim_WithLength( pStr2, 5 ); 763cdf0e10cSrcweir 764cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 4); 765cdf0e10cSrcweir free(pStr2); 766cdf0e10cSrcweir } 767cdf0e10cSrcweir } 768cdf0e10cSrcweir trim_WithLength_003()769cdf0e10cSrcweir void trim_WithLength_003() 770cdf0e10cSrcweir { 771cdf0e10cSrcweir char const *pStr = " trim this"; 772cdf0e10cSrcweir sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); 773cdf0e10cSrcweir if (pStr2) 774cdf0e10cSrcweir { 775cdf0e10cSrcweir strcpy(pStr2, pStr); 776cdf0e10cSrcweir rtl_str_trim_WithLength( pStr2, 11 ); 777cdf0e10cSrcweir 778cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 4); 779cdf0e10cSrcweir free(pStr2); 780cdf0e10cSrcweir } 781cdf0e10cSrcweir } 782cdf0e10cSrcweir trim_WithLength_004()783cdf0e10cSrcweir void trim_WithLength_004() 784cdf0e10cSrcweir { 785cdf0e10cSrcweir char const *pStr = "\r\n\t \n\r trim \n this"; 786cdf0e10cSrcweir sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); 787cdf0e10cSrcweir if (pStr2) 788cdf0e10cSrcweir { 789cdf0e10cSrcweir strcpy(pStr2, pStr); 790cdf0e10cSrcweir rtl_str_trim_WithLength( pStr2, 17 ); 791cdf0e10cSrcweir 792cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 4); 793cdf0e10cSrcweir free(pStr2); 794cdf0e10cSrcweir } 795cdf0e10cSrcweir } 796cdf0e10cSrcweir trim_WithLength_005()797cdf0e10cSrcweir void trim_WithLength_005() 798cdf0e10cSrcweir { 799cdf0e10cSrcweir char const *pStr = "\r\n\t \n\r trim \t this \n\r\t\t "; 800cdf0e10cSrcweir sal_Char *pStr2 = (sal_Char*)malloc(strlen(pStr) + 1); 801cdf0e10cSrcweir if (pStr2) 802cdf0e10cSrcweir { 803cdf0e10cSrcweir strcpy(pStr2, pStr); 804cdf0e10cSrcweir rtl_str_trim_WithLength( pStr2, strlen(pStr2) ); 805cdf0e10cSrcweir 806cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 11); 807cdf0e10cSrcweir free(pStr2); 808cdf0e10cSrcweir } 809cdf0e10cSrcweir } 810cdf0e10cSrcweir 811cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 812cdf0e10cSrcweir // member functions of the current class, 813cdf0e10cSrcweir // because these macros are need by auto register mechanism. 814cdf0e10cSrcweir 815cdf0e10cSrcweir CPPUNIT_TEST_SUITE(trim_WithLength); 816cdf0e10cSrcweir CPPUNIT_TEST(trim_WithLength_000); 817cdf0e10cSrcweir CPPUNIT_TEST(trim_WithLength_000_1); 818cdf0e10cSrcweir CPPUNIT_TEST(trim_WithLength_001); 819cdf0e10cSrcweir CPPUNIT_TEST(trim_WithLength_002); 820cdf0e10cSrcweir CPPUNIT_TEST(trim_WithLength_003); 821cdf0e10cSrcweir CPPUNIT_TEST(trim_WithLength_004); 822cdf0e10cSrcweir CPPUNIT_TEST(trim_WithLength_005); 823cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 824cdf0e10cSrcweir }; 825cdf0e10cSrcweir 826cdf0e10cSrcweir // ----------------------------------------------------------------------------- 827cdf0e10cSrcweir 828cdf0e10cSrcweir class valueOfChar : public CppUnit::TestFixture 829cdf0e10cSrcweir { 830cdf0e10cSrcweir public: valueOfChar_000()831cdf0e10cSrcweir void valueOfChar_000() 832cdf0e10cSrcweir { 833cdf0e10cSrcweir rtl_str_valueOfChar(NULL, 0); 834cdf0e10cSrcweir // should not GPF 835cdf0e10cSrcweir } valueOfChar_001()836cdf0e10cSrcweir void valueOfChar_001() 837cdf0e10cSrcweir { 838cdf0e10cSrcweir sal_Char *pStr = (sal_Char*)malloc(RTL_STR_MAX_VALUEOFCHAR); 839cdf0e10cSrcweir if (pStr) 840cdf0e10cSrcweir { 841cdf0e10cSrcweir rtl_str_valueOfChar(pStr, 'A'); 842cdf0e10cSrcweir 843cdf0e10cSrcweir CPPUNIT_ASSERT_MESSAGE("string should contain 'A'", pStr[0] == 'A'); 844cdf0e10cSrcweir free(pStr); 845cdf0e10cSrcweir } 846cdf0e10cSrcweir } 847cdf0e10cSrcweir 848cdf0e10cSrcweir // Change the following lines only, if you add, remove or rename 849cdf0e10cSrcweir // member functions of the current class, 850cdf0e10cSrcweir // because these macros are need by auto register mechanism. 851cdf0e10cSrcweir 852cdf0e10cSrcweir CPPUNIT_TEST_SUITE(valueOfChar); 853cdf0e10cSrcweir CPPUNIT_TEST(valueOfChar_000); 854cdf0e10cSrcweir CPPUNIT_TEST(valueOfChar_001); 855cdf0e10cSrcweir CPPUNIT_TEST_SUITE_END(); 856cdf0e10cSrcweir }; 857cdf0e10cSrcweir 858cdf0e10cSrcweir // ----------------------------------------------------------------------------- 859cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::compare, "rtl_str"); 860cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::compareIgnoreAsciiCase, "rtl_str"); 861cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::shortenedCompareIgnoreAsciiCase_WithLength, "rtl_str"); 862cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::hashCode, "rtl_str"); 863cdf0e10cSrcweir 864cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::indexOfChar, "rtl_str"); 865cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::lastIndexOfChar, "rtl_str"); 866cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::indexOfStr, "rtl_str"); 867cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::lastIndexOfStr, "rtl_str"); 868cdf0e10cSrcweir 869cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::replaceChar, "rtl_str"); 870cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::replaceChar_WithLength, "rtl_str"); 871cdf0e10cSrcweir 872cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::toAsciiLowerCase, "rtl_str"); 873cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::toAsciiLowerCase_WithLength, "rtl_str"); 874cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::toAsciiUpperCase, "rtl_str"); 875cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::toAsciiUpperCase_WithLength, "rtl_str"); 876cdf0e10cSrcweir 877cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::trim_WithLength, "rtl_str"); 878cdf0e10cSrcweir CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_str::valueOfChar, "rtl_str"); 879cdf0e10cSrcweir 880cdf0e10cSrcweir } // namespace rtl_str 881cdf0e10cSrcweir 882cdf0e10cSrcweir // ----------------------------------------------------------------------------- 883cdf0e10cSrcweir 884cdf0e10cSrcweir // this macro creates an empty function, which will called by the RegisterAllFunctions() 885cdf0e10cSrcweir // to let the user the possibility to also register some functions by hand. 886cdf0e10cSrcweir NOADDITIONAL; 887