| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sal.hxx" |
| #include <testshl/simpleheader.hxx> |
| |
| /** print a UNI_CODE file name. |
| */ |
| inline void printOUString( ::rtl::OUString const & _suStr ) |
| { |
| rtl::OString aString; |
| |
| t_print( "OUString: " ); |
| aString = ::rtl::OUStringToOString( _suStr, RTL_TEXTENCODING_ASCII_US ); |
| t_print( "%s\n", aString.getStr( ) ); |
| } |
| |
| |
| namespace rtl_ustr |
| { |
| |
| class compare : public CppUnit::TestFixture |
| { |
| public: |
| |
| |
| void compare_000() |
| { |
| rtl_ustr_compare( NULL, NULL); |
| // should not GPF |
| } |
| |
| void compare_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl_ustr_compare( aStr1.getStr(), NULL); |
| // should not GPF |
| } |
| void compare_001() |
| { |
| rtl::OUString aStr1; |
| rtl::OUString aStr2; |
| |
| sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void compare_002() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line must be equal."); |
| |
| sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void compare_003() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); |
| rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); |
| |
| sal_Int32 nValue = rtl_ustr_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_ustr_compareIgnoreAsciiCase( NULL, NULL); |
| } |
| |
| void compare_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), NULL); |
| } |
| void compare_001() |
| { |
| rtl::OUString aStr1; |
| rtl::OUString aStr2; |
| |
| sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void compare_002() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line must be equal."); |
| |
| sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void compare_002_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OUString aStr2 = rtl::OUString::createFromAscii("LINE MUST BE EQUAL."); |
| |
| sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); |
| } |
| |
| void compare_003() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); |
| rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); |
| |
| sal_Int32 nValue = rtl_ustr_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_ustr_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0, 0); |
| } |
| |
| void compare_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0, 1); |
| } |
| void compare_001() |
| { |
| rtl::OUString aStr1; |
| rtl::OUString aStr2; |
| |
| sal_Int32 nValue = rtl_ustr_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::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line must be equal."); |
| |
| sal_Int32 nValue = rtl_ustr_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::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OUString aStr2 = rtl::OUString::createFromAscii("LINE MUST BE EQUAL."); |
| |
| sal_Int32 nValue = rtl_ustr_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::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); |
| rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); |
| |
| sal_Int32 nValue = rtl_ustr_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::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); |
| rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); |
| |
| sal_Int32 nValue = rtl_ustr_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() |
| // { |
| // sal_Int32 nHashCode = rtl_ustr_hashCode( NULL ); |
| // volatile int dummy = 0; |
| // } |
| // |
| // void hashCode_001() |
| // { |
| // rtl::OString aStr1 = "Line for a hashCode."; |
| // sal_Int32 nHashCode = rtl_ustr_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_ustr_hashCode( aStr1.getStr() ); |
| // |
| // rtl::OString aStr2 = "Line for a hashCode."; |
| // sal_Int32 nHashCode2 = rtl_ustr_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_ustr_hashCode( aStr1.getStr() ); |
| // |
| // rtl::OString aStr2 = "Line for an other hashcode."; |
| // sal_Int32 nHashCode2 = rtl_ustr_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_ustr_indexOfChar( NULL, 0 ); |
| } |
| |
| void indexOfChar_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfChar."); |
| |
| sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'L' ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); |
| |
| /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'i' ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 1); |
| |
| /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'n' ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 2); |
| |
| /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'e' ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 3); |
| } |
| |
| void indexOfChar_002() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfChar."); |
| sal_Int32 nIndex = rtl_ustr_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 indexOfChar |
| |
| // // ----------------------------------------------------------------------------- |
| class lastIndexOfChar : public CppUnit::TestFixture |
| { |
| public: |
| |
| void lastIndexOfChar_000() |
| { |
| rtl_ustr_lastIndexOfChar( NULL, 0 ); |
| } |
| |
| void lastIndexOfChar_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfChar."); |
| |
| sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'C' ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 22); |
| |
| /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'h' ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 23); |
| |
| /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'a' ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 24); |
| |
| /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'r' ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 25); |
| } |
| |
| void lastIndexOfChar_002() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfChar."); |
| sal_Int32 nIndex = rtl_ustr_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_ustr_indexOfStr( NULL, 0 ); |
| } |
| |
| void indexOfStr_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); |
| rtl_ustr_indexOfStr( aStr1.getStr(), 0 ); |
| } |
| |
| void indexOfStr_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); |
| |
| rtl::OUString suSearch = rtl::OUString::createFromAscii("Line"); |
| sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); |
| |
| /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("for"); |
| /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 5); |
| |
| /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("a"); |
| /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 9); |
| |
| /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("a index"); |
| /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex ==9); |
| } |
| |
| void indexOfStr_002() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); |
| rtl::OUString suSearch = rtl::OUString::createFromAscii("not exist"); |
| sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); |
| |
| 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_ustr_lastIndexOfStr( NULL, NULL ); |
| } |
| |
| void lastIndexOfStr_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); |
| rtl_ustr_lastIndexOfStr( aStr1.getStr(), NULL ); |
| } |
| |
| void lastIndexOfStr_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("Index"); |
| |
| sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 15); |
| |
| /* rtl::OString */ aSearchStr = rtl::OUString::createFromAscii("Line"); |
| /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); |
| |
| /* rtl::OString */ aSearchStr = rtl::OUString::createFromAscii(""); |
| /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1); |
| } |
| |
| void lastIndexOfStr_002() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("foo"); |
| sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); |
| |
| CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); |
| } |
| |
| void lastIndexOfStr_003() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); |
| rtl::OUString aSearchStr = rtl::OUString::createFromAscii("O"); |
| sal_Int32 nIndex = rtl_ustr_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_ustr_replaceChar( NULL, 0, 0 ); |
| } |
| |
| void replaceChar_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("replace char."); |
| rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("ruplacu char."); |
| |
| sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); |
| sal_Unicode* pStr = (sal_Unicode*) malloc( nLength + sizeof(sal_Unicode)); // length + 1 (null terminator) |
| CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); |
| memset(pStr, 0, nLength + sizeof(sal_Unicode)); |
| memcpy(pStr, aStr1.getStr(), nLength); |
| |
| rtl_ustr_replaceChar( pStr, 'e', 'u' ); |
| rtl::OUString suStr(pStr, aStr1.getLength()); |
| |
| CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(suStr) == 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_ustr_replaceChar_WithLength( NULL, 0, 0, 0 ); |
| } |
| |
| void replaceChar_WithLength_000_1() |
| { |
| rtl_ustr_replaceChar_WithLength( NULL, 1, 0, 0 ); |
| } |
| void replaceChar_WithLength_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("replace char."); |
| rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("ruplace char."); |
| |
| sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); |
| sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); |
| CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); |
| memcpy(pStr, aStr1.getStr(), nLength); |
| |
| rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' ); |
| rtl::OUString suStr(pStr, aStr1.getLength()); |
| |
| CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(suStr) == sal_True); |
| free(pStr); |
| } |
| |
| void replaceChar_WithLength_002() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("eeeeeeeeeeeee"); |
| rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("uuuuuueeeeeee"); |
| |
| sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); |
| sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); // no null terminator is need |
| CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); |
| memcpy(pStr, aStr1.getStr(), nLength); |
| |
| rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' ); |
| rtl::OUString suStr(pStr, aStr1.getLength()); |
| |
| CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(suStr) == 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(replaceChar_WithLength_002); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class replaceChar |
| |
| |
| // ----------------------------------------------------------------------------- |
| |
| class toAsciiLowerCase : public CppUnit::TestFixture |
| { |
| public: |
| |
| void toAsciiLowerCase_000() |
| { |
| rtl_ustr_toAsciiLowerCase( NULL ); |
| } |
| |
| void toAsciiLowerCase_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII LOWER CASE."); |
| rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("change this to ascii lower case."); |
| |
| sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); |
| sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode) ); // we need to add '\0' so one more |
| CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); |
| memset(pStr, 0, nLength + sizeof(sal_Unicode)); // empty the sal_Unicode array |
| memcpy(pStr, aStr1.getStr(), nLength); |
| |
| rtl_ustr_toAsciiLowerCase( pStr ); |
| rtl::OUString suStr(pStr, aStr1.getLength()); |
| |
| CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == 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_ustr_toAsciiLowerCase_WithLength( NULL, 0 ); |
| } |
| |
| void toAsciiLowerCase_WithLength_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII LOWER CASE."); |
| rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("change thiS TO ASCII LOWER CASE."); |
| |
| sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); |
| sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); |
| CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); |
| memcpy(pStr, aStr1.getStr(), nLength); |
| |
| rtl_ustr_toAsciiLowerCase_WithLength( pStr, 10 ); |
| |
| rtl::OUString suStr(pStr, aStr1.getLength()); |
| sal_Bool bResult = aShouldStr1.equals(suStr); |
| |
| printOUString(suStr); |
| t_print("Result length: %d\n", suStr.getLength() ); |
| t_print("Result: %d\n", bResult); |
| |
| CPPUNIT_ASSERT_MESSAGE("failed", bResult == 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_ustr_toAsciiUpperCase( NULL ); |
| } |
| |
| void toAsciiUpperCase_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("change this to ascii upper case."); |
| rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII UPPER CASE."); |
| |
| sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); |
| sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator |
| CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); |
| memset(pStr, 0, nLength + sizeof(sal_Unicode)); |
| memcpy(pStr, aStr1.getStr(), nLength); |
| |
| rtl_ustr_toAsciiUpperCase( pStr ); |
| rtl::OUString suStr(pStr, aStr1.getLength()); |
| |
| CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == 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_ustr_toAsciiUpperCase_WithLength( NULL, 0 ); |
| } |
| |
| void toAsciiUpperCase_WithLength_001() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("change this to ascii lower case."); |
| rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIs to ascii lower case."); |
| |
| sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); |
| sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); |
| CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); |
| |
| memcpy(pStr, aStr1.getStr(), nLength); |
| rtl_ustr_toAsciiUpperCase_WithLength( pStr, 10 ); |
| rtl::OUString suStr(pStr, aStr1.getLength()); |
| |
| // t_print("Uppercase with length: '%s'\n", aStr1.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == 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_ustr_trim_WithLength(NULL, 0); |
| // should not GPF |
| } |
| |
| void trim_WithLength_000_1() |
| { |
| rtl::OUString suStr = rtl::OUString::createFromAscii(" trim this"); |
| |
| sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); |
| sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); |
| memcpy(pStr, suStr.getStr(), nLength); |
| |
| rtl_ustr_trim_WithLength( pStr, 0 ); |
| free(pStr); |
| } |
| |
| void trim_WithLength_001() |
| { |
| rtl::OUString suStr = rtl::OUString::createFromAscii(" trim this"); |
| sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); |
| sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); |
| memcpy(pStr, suStr.getStr(), nLength); |
| |
| rtl_ustr_trim_WithLength( pStr, 2 ); |
| |
| CPPUNIT_ASSERT_MESSAGE("string should be empty", rtl::OUString(pStr).getLength() == 0); |
| free(pStr); |
| } |
| |
| |
| void trim_WithLength_002() |
| { |
| rtl::OUString suStr = rtl::OUString::createFromAscii("trim this"); |
| |
| sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); |
| sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); |
| memcpy(pStr, suStr.getStr(), nLength); |
| |
| rtl_ustr_trim_WithLength( pStr, 5 ); |
| |
| CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", rtl::OUString(pStr).getLength() == 4); |
| free(pStr); |
| } |
| |
| |
| void trim_WithLength_003() |
| { |
| rtl::OUString suStr = rtl::OUString::createFromAscii(" trim this"); |
| |
| sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); |
| sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); |
| memcpy(pStr, suStr.getStr(), nLength); |
| |
| rtl_ustr_trim_WithLength( pStr, 11 ); |
| |
| CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", rtl::OUString(pStr).getLength() == 4); |
| free(pStr); |
| } |
| |
| void trim_WithLength_004() |
| { |
| rtl::OUString suStr = rtl::OUString::createFromAscii("\r\n\t \n\r trim \n this"); |
| |
| sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); |
| sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); |
| memcpy(pStr, suStr.getStr(), nLength); |
| |
| rtl_ustr_trim_WithLength( pStr, 17 ); |
| |
| CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", rtl::OUString(pStr).getLength() == 4); |
| free(pStr); |
| } |
| |
| void trim_WithLength_005() |
| { |
| rtl::OUString suStr = rtl::OUString::createFromAscii("\r\n\t \n\r trim \t this \n\r\t\t "); |
| |
| sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); |
| sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); |
| memcpy(pStr, suStr.getStr(), nLength); |
| |
| rtl_ustr_trim_WithLength( pStr, suStr.getLength() ); |
| |
| CPPUNIT_ASSERT_MESSAGE("string should contain 'trim \\t this'", rtl::OUString(pStr).getLength() == 11); |
| 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(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_ustr_valueOfChar(NULL, 0); |
| // should not GPF |
| } |
| void valueOfChar_001() |
| { |
| sal_Unicode *pStr = (sal_Unicode*)malloc(RTL_USTR_MAX_VALUEOFCHAR); |
| if (pStr) |
| { |
| rtl_ustr_valueOfChar(pStr, 'A'); |
| |
| CPPUNIT_ASSERT_MESSAGE("string should contain 'A'", pStr[0] == L'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(); |
| }; |
| |
| |
| |
| |
| class ascii_compare_WithLength : public CppUnit::TestFixture |
| { |
| public: |
| void zero_length() |
| { |
| sal_Unicode pUnicode[] = {0xffff, 0xffff}; |
| char const * pAscii = "reference"; |
| |
| sal_Int32 value = rtl_ustr_ascii_compare_WithLength(pUnicode, 0, pAscii); |
| CPPUNIT_ASSERT_MESSAGE("ref string is empty, compare failed, needs to be <0.", value < 0); |
| } |
| |
| void equal_ascii_shorter() |
| { |
| rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("referenceString")); |
| char const * pAscii = "reference"; |
| |
| sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); |
| CPPUNIT_ASSERT_MESSAGE("ref string is bigger, compare failed, needs to be >0.", value > 0); |
| } |
| |
| void equal_ascii_shorter_asciiLength() |
| { |
| rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("referenceString")); |
| char const * pAscii = "reference"; |
| |
| sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, rtl_str_getLength(pAscii), pAscii); |
| CPPUNIT_ASSERT_MESSAGE("ref string is bigger despite ascii length, compare failed, needs to be == 0.", value == 0); |
| } |
| |
| void equal_ref_shorter() |
| { |
| rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("reference")); |
| char const * pAscii = "referenceString"; |
| |
| sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); |
| CPPUNIT_ASSERT_MESSAGE("ascii string is bigger, but only compared to ref length, needs to be 0.", value < 0); |
| } |
| |
| void equal() |
| { |
| rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("reference")); |
| char const * pAscii = "reference"; |
| |
| sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); |
| CPPUNIT_ASSERT_MESSAGE("strings are equal, compare failed, needs to be 0.", value == 0); |
| } |
| |
| void unequal_reference_bigger() |
| { |
| rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("defghi")); |
| char const * pAscii = "abc"; |
| |
| sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); |
| CPPUNIT_ASSERT_MESSAGE("strings are unequal and ref is bigger, needs to be >0.", value > 0); |
| } |
| |
| void unequal_ascii_bigger() |
| { |
| rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("abc")); |
| char const * pAscii = "defghi"; |
| |
| sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); |
| |
| CPPUNIT_ASSERT_MESSAGE("strings are unequal and ascii is bigger, needs to be <0.", value < 0); |
| } |
| |
| CPPUNIT_TEST_SUITE(ascii_compare_WithLength); |
| CPPUNIT_TEST(zero_length); |
| CPPUNIT_TEST(equal_ascii_shorter); |
| CPPUNIT_TEST(equal_ascii_shorter_asciiLength); |
| CPPUNIT_TEST(equal_ref_shorter); |
| CPPUNIT_TEST(equal); |
| CPPUNIT_TEST(unequal_reference_bigger); |
| CPPUNIT_TEST(unequal_ascii_bigger); |
| CPPUNIT_TEST_SUITE_END(); |
| }; |
| |
| |
| |
| |
| class ascii_shortenedCompareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture |
| { |
| public: |
| |
| void ascii_shortenedCompareIgnoreAsciiCase_WithLength_000() |
| { |
| rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0); |
| // should not GPF |
| } |
| |
| void ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0); |
| // should not GPF |
| } |
| void ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_2() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OString sStr2 = "Line is shorter."; |
| rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), sStr2.getLength(), sStr2.getStr(), 0); |
| // should not GPF |
| } |
| void ascii_shortenedCompareIgnoreAsciiCase_WithLength_001() |
| { |
| rtl::OUString suStr1; |
| rtl::OString sStr2; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1, 0, sStr2.getStr(), 0); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_shortenedCompareIgnoreAsciiCase_WithLength_002() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OString sStr2 = "Line must be equal."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr(), sStr2.getLength()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_shortenedCompareIgnoreAsciiCase_WithLength_003() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); |
| rtl::OString sStr2 = "Line must be differ and longer."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr(), sStr2.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(ascii_shortenedCompareIgnoreAsciiCase_WithLength); |
| CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_000); |
| CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_1); |
| CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_2); |
| CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_001); |
| CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_002); |
| CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_003); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class ascii_shortenedCompareIgnoreAsciiCase_WithLength |
| |
| // ----------------------------------------------------------------------------- |
| |
| class ascii_compareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture |
| { |
| public: |
| |
| void ascii_compareIgnoreAsciiCase_WithLength_000() |
| { |
| rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( NULL, 0, NULL); |
| // should not GPF |
| } |
| |
| void ascii_compareIgnoreAsciiCase_WithLength_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aStr1.getStr(), 0, NULL); |
| // should not GPF |
| } |
| void ascii_compareIgnoreAsciiCase_WithLength_000_2() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OString sStr2 = "Line is shorter."; |
| rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aStr1.getStr(), sStr2.getLength(), sStr2.getStr()); |
| // should not GPF |
| } |
| void ascii_compareIgnoreAsciiCase_WithLength_001() |
| { |
| rtl::OUString suStr1; |
| rtl::OString sStr2; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1, 0, sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compareIgnoreAsciiCase_WithLength failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_compareIgnoreAsciiCase_WithLength_002() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OString sStr2 = "Line must be equal."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_compareIgnoreAsciiCase_WithLength_003() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); |
| rtl::OString sStr2 = "Line must be differ and longer."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.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(ascii_compareIgnoreAsciiCase_WithLength); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_000); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_000_1); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_000_2); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_001); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_002); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_003); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class ascii_compareIgnoreAsciiCase_WithLength |
| |
| // ----------------------------------------------------------------------------- |
| |
| class ascii_compare : public CppUnit::TestFixture |
| { |
| public: |
| |
| void ascii_compare_000() |
| { |
| rtl_ustr_ascii_compare( NULL, NULL); |
| // should not GPF |
| } |
| |
| void ascii_compare_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl_ustr_ascii_compare( aStr1.getStr(), NULL); |
| // should not GPF |
| } |
| void ascii_compare_001() |
| { |
| rtl::OUString suStr1; |
| rtl::OString sStr2; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1, sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_compare_002() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OString sStr2 = "Line must be equal."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_compare_003() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); |
| rtl::OString sStr2 = "Line foo bar, ok, differ."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.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(ascii_compare); |
| CPPUNIT_TEST(ascii_compare_000); |
| CPPUNIT_TEST(ascii_compare_000_1); |
| CPPUNIT_TEST(ascii_compare_001); |
| CPPUNIT_TEST(ascii_compare_002); |
| CPPUNIT_TEST(ascii_compare_003); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class ascii_compare |
| |
| // ----------------------------------------------------------------------------- |
| |
| class ascii_compareIgnoreAsciiCase : public CppUnit::TestFixture |
| { |
| public: |
| |
| void ascii_compareIgnoreAsciiCase_000() |
| { |
| rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL); |
| // should not GPF |
| } |
| |
| void ascii_compareIgnoreAsciiCase_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL); |
| // should not GPF |
| } |
| void ascii_compareIgnoreAsciiCase_001() |
| { |
| rtl::OUString suStr1; |
| rtl::OString sStr2; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1, sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_compareIgnoreAsciiCase_002() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OString sStr2 = "Line must be equal."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_compareIgnoreAsciiCase_002_1() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal, when ignore case."); |
| rtl::OString sStr2 = "LINE MUST BE EQUAL, WHEN IGNORE CASE."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); |
| } |
| |
| void ascii_compareIgnoreAsciiCase_003() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); |
| rtl::OString sStr2 = "Line foo bar, ok, differ."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); |
| } |
| |
| //! LLA: some more tests with some high level strings |
| |
| // void ascii_compareIgnoreAsciiCase_001() |
| // { |
| // rtl::OUString suStr1 = rtl::OUString::createFromAscii("change this to ascii upper case."); |
| // rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII UPPER CASE."); |
| // |
| // sal_uInt32 nLength = suStr1.getLength() * sizeof(sal_Unicode); |
| // sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator |
| // CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); |
| // memset(pStr, 0, nLength + sizeof(sal_Unicode)); |
| // memcpy(pStr, suStr1.getStr(), nLength); |
| // |
| // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr ); |
| // rtl::OUString suStr(pStr, suStr1.getLength()); |
| // |
| // CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == 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(ascii_compareIgnoreAsciiCase); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000_1); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_001); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002_1); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_003); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class ascii_compareIgnoreAsciiCase |
| |
| |
| // sample out of inc/rtl/ustring.hxx |
| // rtl_uString * pToken = NULL; |
| // sal_Int32 nIndex = 0; |
| // do |
| // { |
| // ... |
| // nIndex = rtl_uString_getToken(&pToken, pStr, 0, ';', nIndex); |
| // ... |
| // } |
| // while (nIndex >= 0); |
| |
| class getToken : public CppUnit::TestFixture |
| { |
| public: |
| |
| void getToken_000() |
| { |
| rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL); |
| // should not GPF |
| } |
| |
| void ascii_compareIgnoreAsciiCase_000_1() |
| { |
| rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL); |
| // should not GPF |
| } |
| void ascii_compareIgnoreAsciiCase_001() |
| { |
| rtl::OUString suStr1; |
| rtl::OString sStr2; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1, sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_compareIgnoreAsciiCase_002() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); |
| rtl::OString sStr2 = "Line must be equal."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); |
| } |
| |
| void ascii_compareIgnoreAsciiCase_002_1() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal, when ignore case."); |
| rtl::OString sStr2 = "LINE MUST BE EQUAL, WHEN IGNORE CASE."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); |
| } |
| |
| void ascii_compareIgnoreAsciiCase_003() |
| { |
| rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); |
| rtl::OString sStr2 = "Line foo bar, ok, differ."; |
| |
| sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); |
| CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); |
| } |
| |
| //! LLA: some more tests with some high level strings |
| |
| // void ascii_compareIgnoreAsciiCase_001() |
| // { |
| // rtl::OUString suStr1 = rtl::OUString::createFromAscii("change this to ascii upper case."); |
| // rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII UPPER CASE."); |
| // |
| // sal_uInt32 nLength = suStr1.getLength() * sizeof(sal_Unicode); |
| // sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator |
| // CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); |
| // memset(pStr, 0, nLength + sizeof(sal_Unicode)); |
| // memcpy(pStr, suStr1.getStr(), nLength); |
| // |
| // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr ); |
| // rtl::OUString suStr(pStr, suStr1.getLength()); |
| // |
| // CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == 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(ascii_compareIgnoreAsciiCase); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000_1); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_001); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002_1); |
| CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_003); |
| CPPUNIT_TEST_SUITE_END(); |
| }; // class ascii_compareIgnoreAsciiCase |
| |
| // ----------------------------------------------------------------------------- |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::compare, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::compareIgnoreAsciiCase, "rtl_ustr"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_compare_WithLength, "rtl_ustr"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::shortenedCompareIgnoreAsciiCase_WithLength, "rtl_ustr"); |
| // CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::hashCode, "rtl_ustr"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::indexOfChar, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::lastIndexOfChar, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::indexOfStr, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::lastIndexOfStr, "rtl_ustr"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::replaceChar, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::replaceChar_WithLength, "rtl_ustr"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::toAsciiLowerCase, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::toAsciiLowerCase_WithLength, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::toAsciiUpperCase, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::toAsciiUpperCase_WithLength, "rtl_ustr"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::trim_WithLength, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::valueOfChar, "rtl_ustr"); |
| |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_compare, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_compareIgnoreAsciiCase, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_compareIgnoreAsciiCase_WithLength, "rtl_ustr"); |
| CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_shortenedCompareIgnoreAsciiCase_WithLength, "rtl_ustr"); |
| |
| } // namespace rtl_ustr |
| |
| // ----------------------------------------------------------------------------- |
| |
| // 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; |
| |
| |
