/************************************************************** * * 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 "gtest/gtest.h" #include /** print a UNI_CODE file name. */ inline void printOUString( ::rtl::OUString const & _suStr ) { rtl::OString aString; printf( "OUString: " ); aString = ::rtl::OUStringToOString( _suStr, RTL_TEXTENCODING_ASCII_US ); printf( "%s\n", aString.getStr( ) ); } namespace rtl_ustr { class compare : public ::testing::Test { public: }; // class compare TEST_F(compare, compare_000) { rtl_ustr_compare( NULL, NULL); // should not GPF } TEST_F(compare, compare_000_1) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); rtl_ustr_compare( aStr1.getStr(), NULL); // should not GPF } TEST_F(compare, compare_001) { rtl::OUString aStr1; rtl::OUString aStr2; sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(compare, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(compare, 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()); ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; } class compareIgnoreAsciiCase : public ::testing::Test { public: }; // class compareIgnoreAsciiCase TEST_F(compareIgnoreAsciiCase, compare_000) { rtl_ustr_compareIgnoreAsciiCase( NULL, NULL); } TEST_F(compareIgnoreAsciiCase, compare_000_1) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), NULL); } TEST_F(compareIgnoreAsciiCase, compare_001) { rtl::OUString aStr1; rtl::OUString aStr2; sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(compareIgnoreAsciiCase, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(compareIgnoreAsciiCase, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal (if case insensitve)."; } TEST_F(compareIgnoreAsciiCase, 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()); ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; } // ----------------------------------------------------------------------------- class shortenedCompareIgnoreAsciiCase_WithLength : public ::testing::Test { public: }; // class compare TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_000) { rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0, 0); } TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_000_1) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0, 1); } TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal (if case insensitve)."; } TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, 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); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal first 5 characters."; } TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, 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()); ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; } // // ----------------------------------------------------------------------------- // // class hashCode : public ::testing::Test // { // public: // }; // // TEST_F(hashCode, hashCode_000) // { // sal_Int32 nHashCode = rtl_ustr_hashCode( NULL ); // volatile int dummy = 0; // } // // TEST_F(hashCode, hashCode_001) // { // rtl::OString aStr1 = "Line for a hashCode."; // sal_Int32 nHashCode = rtl_ustr_hashCode( aStr1.getStr() ); // printf("hashcode: %d\n", nHashCode); // // ASSERT_TRUE(nValue == 0) << "failed."; // } // // TEST_F(hashCode, 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() ); // // ASSERT_TRUE(nHashCode1 == nHashCode2) << "hashcodes must be equal."; // } // // TEST_F(hashCode, 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() ); // // ASSERT_TRUE(nHashCode1 != nHashCode2) << "hashcodes must differ."; // } // // // // ----------------------------------------------------------------------------- // class indexOfChar : public ::testing::Test { public: }; // class indexOfChar TEST_F(indexOfChar, indexOfChar_000) { rtl_ustr_indexOfChar( NULL, 0 ); } TEST_F(indexOfChar, indexOfChar_001) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfChar."); sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'L' ); ASSERT_TRUE(nIndex == 0) << "index is wrong."; /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'i' ); ASSERT_TRUE(nIndex == 1) << "index is wrong."; /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'n' ); ASSERT_TRUE(nIndex == 2) << "index is wrong."; /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'e' ); ASSERT_TRUE(nIndex == 3) << "index is wrong."; } TEST_F(indexOfChar, indexOfChar_002) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfChar."); sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'y' ); ASSERT_TRUE(nIndex == -1) << "index is wrong."; } // // ----------------------------------------------------------------------------- class lastIndexOfChar : public ::testing::Test { public: }; // class lastIndexOfChar TEST_F(lastIndexOfChar, lastIndexOfChar_000) { rtl_ustr_lastIndexOfChar( NULL, 0 ); } TEST_F(lastIndexOfChar, lastIndexOfChar_001) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfChar."); sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'C' ); ASSERT_TRUE(nIndex == 22) << "index is wrong."; /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'h' ); ASSERT_TRUE(nIndex == 23) << "index is wrong."; /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'a' ); ASSERT_TRUE(nIndex == 24) << "index is wrong."; /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'r' ); ASSERT_TRUE(nIndex == 25) << "index is wrong."; } TEST_F(lastIndexOfChar, lastIndexOfChar_002) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfChar."); sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'y' ); ASSERT_TRUE(nIndex == -1) << "index is wrong."; } // ----------------------------------------------------------------------------- class indexOfStr : public ::testing::Test { public: }; // class compare TEST_F(indexOfStr, indexOfStr_000) { rtl_ustr_indexOfStr( NULL, 0 ); } TEST_F(indexOfStr, indexOfStr_000_1) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); rtl_ustr_indexOfStr( aStr1.getStr(), 0 ); } TEST_F(indexOfStr, 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.getStr() ); ASSERT_TRUE(nIndex == 0) << "index is wrong."; /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("for"); /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() ); ASSERT_TRUE(nIndex == 5) << "index is wrong."; /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("a"); /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() ); ASSERT_TRUE(nIndex == 9) << "index is wrong."; /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("a index"); /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() ); ASSERT_TRUE(nIndex ==9) << "index is wrong."; } TEST_F(indexOfStr, 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.getStr() ); ASSERT_TRUE(nIndex == -1) << "index is wrong."; } // ----------------------------------------------------------------------------- class lastIndexOfStr : public ::testing::Test { public: }; // class lastIndexOfStr TEST_F(lastIndexOfStr, lastIndexOfStr_000) { rtl_ustr_lastIndexOfStr( NULL, NULL ); } TEST_F(lastIndexOfStr, lastIndexOfStr_000_1) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); rtl_ustr_lastIndexOfStr( aStr1.getStr(), NULL ); } TEST_F(lastIndexOfStr, 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() ); ASSERT_TRUE(nIndex == 15) << "index is wrong."; /* rtl::OString */ aSearchStr = rtl::OUString::createFromAscii("Line"); /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); ASSERT_TRUE(nIndex == 0) << "index is wrong."; /* rtl::OString */ aSearchStr = rtl::OUString::createFromAscii(""); /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); ASSERT_TRUE(nIndex == -1) << "index is wrong."; } TEST_F(lastIndexOfStr, 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() ); ASSERT_TRUE(nIndex == -1) << "index is wrong."; } TEST_F(lastIndexOfStr, 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() ); ASSERT_TRUE(nIndex == 20) << "index is wrong."; } // ----------------------------------------------------------------------------- class replaceChar : public ::testing::Test { public: }; // class replaceChar TEST_F(replaceChar, replaceChar_000) { rtl_ustr_replaceChar( NULL, 0, 0 ); } TEST_F(replaceChar, 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) ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; memset(pStr, 0, nLength + sizeof(sal_Unicode)); memcpy(pStr, aStr1.getStr(), nLength); rtl_ustr_replaceChar( pStr, 'e', 'u' ); rtl::OUString suStr(pStr, aStr1.getLength()); ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "replace failed"; free(pStr); } // ----------------------------------------------------------------------------- class replaceChar_WithLength : public ::testing::Test { public: }; // class replaceChar TEST_F(replaceChar_WithLength, replaceChar_WithLength_000) { rtl_ustr_replaceChar_WithLength( NULL, 0, 0, 0 ); } TEST_F(replaceChar_WithLength, replaceChar_WithLength_000_1) { rtl_ustr_replaceChar_WithLength( NULL, 1, 0, 0 ); } TEST_F(replaceChar_WithLength, 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); ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; memcpy(pStr, aStr1.getStr(), nLength); rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' ); rtl::OUString suStr(pStr, aStr1.getLength()); ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "replace failed"; free(pStr); } TEST_F(replaceChar_WithLength, 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 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; memcpy(pStr, aStr1.getStr(), nLength); rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' ); rtl::OUString suStr(pStr, aStr1.getLength()); ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "replace failed"; free(pStr); } // ----------------------------------------------------------------------------- class toAsciiLowerCase : public ::testing::Test { public: }; // class replaceChar TEST_F(toAsciiLowerCase, toAsciiLowerCase_000) { rtl_ustr_toAsciiLowerCase( NULL ); } TEST_F(toAsciiLowerCase, 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 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 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()); ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; free(pStr); } class toAsciiLowerCase_WithLength : public ::testing::Test { }; // class replaceChar TEST_F(toAsciiLowerCase, toAsciiLowerCase_WithLength_000) { rtl_ustr_toAsciiLowerCase_WithLength( NULL, 0 ); } TEST_F(toAsciiLowerCase, 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); ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 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); printf("Result length: %d\n", suStr.getLength() ); printf("Result: %d\n", bResult); ASSERT_TRUE(bResult == sal_True) << "failed"; free(pStr); } // ----------------------------------------------------------------------------- class toAsciiUpperCase : public ::testing::Test { public: }; // class replaceChar TEST_F(toAsciiUpperCase, toAsciiUpperCase_000) { rtl_ustr_toAsciiUpperCase( NULL ); } TEST_F(toAsciiUpperCase, 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 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; memset(pStr, 0, nLength + sizeof(sal_Unicode)); memcpy(pStr, aStr1.getStr(), nLength); rtl_ustr_toAsciiUpperCase( pStr ); rtl::OUString suStr(pStr, aStr1.getLength()); ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; free(pStr); } class toAsciiUpperCase_WithLength : public ::testing::Test { public: }; // class replaceChar TEST_F(toAsciiUpperCase_WithLength, toAsciiUpperCase_WithLength_000) { rtl_ustr_toAsciiUpperCase_WithLength( NULL, 0 ); } TEST_F(toAsciiUpperCase_WithLength, 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); ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; memcpy(pStr, aStr1.getStr(), nLength); rtl_ustr_toAsciiUpperCase_WithLength( pStr, 10 ); rtl::OUString suStr(pStr, aStr1.getLength()); // printf("Uppercase with length: '%s'\n", aStr1.getStr()); ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; free(pStr); } // ----------------------------------------------------------------------------- class trim_WithLength : public ::testing::Test { public: }; TEST_F(trim_WithLength, trim_WithLength_000) { rtl_ustr_trim_WithLength(NULL, 0); // should not GPF } TEST_F(trim_WithLength, 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); } TEST_F(trim_WithLength, 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 ); ASSERT_TRUE(rtl::OUString(pStr).getLength() == 0) << "string should be empty"; free(pStr); } TEST_F(trim_WithLength, 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 ); ASSERT_TRUE(rtl::OUString(pStr).getLength() == 4) << "string should contain 'trim'"; free(pStr); } TEST_F(trim_WithLength, 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 ); ASSERT_TRUE(rtl::OUString(pStr).getLength() == 4) << "string should contain 'trim'"; free(pStr); } TEST_F(trim_WithLength, 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 ); ASSERT_TRUE(rtl::OUString(pStr).getLength() == 4) << "string should contain 'trim'"; free(pStr); } TEST_F(trim_WithLength, 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() ); ASSERT_TRUE(rtl::OUString(pStr).getLength() == 11) << "string should contain 'trim \\t this'"; free(pStr); } // ----------------------------------------------------------------------------- class valueOfChar : public ::testing::Test { public: }; TEST_F(valueOfChar, valueOfChar_000) { rtl_ustr_valueOfChar(NULL, 0); // should not GPF } TEST_F(valueOfChar, valueOfChar_001) { sal_Unicode *pStr = (sal_Unicode*)malloc(RTL_USTR_MAX_VALUEOFCHAR); if (pStr) { rtl_ustr_valueOfChar(pStr, 'A'); ASSERT_TRUE(pStr[0] == L'A') << "string should contain 'A'"; free(pStr); } } class ascii_compare_WithLength : public ::testing::Test { public: }; TEST_F(ascii_compare_WithLength, zero_length) { sal_Unicode pUnicode[] = {0xffff, 0xffff}; char const * pAscii = "reference"; sal_Int32 value = rtl_ustr_ascii_compare_WithLength(pUnicode, 0, pAscii); ASSERT_TRUE(value < 0) << "ref string is empty, compare failed, needs to be <0."; } TEST_F(ascii_compare_WithLength, 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); ASSERT_TRUE(value > 0) << "ref string is bigger, compare failed, needs to be >0."; } TEST_F(ascii_compare_WithLength, 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); ASSERT_TRUE(value == 0) << "ref string is bigger despite ascii length, compare failed, needs to be == 0."; } TEST_F(ascii_compare_WithLength, 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); ASSERT_TRUE(value < 0) << "ascii string is bigger, but only compared to ref length, needs to be 0."; } TEST_F(ascii_compare_WithLength, 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); ASSERT_TRUE(value == 0) << "strings are equal, compare failed, needs to be 0."; } TEST_F(ascii_compare_WithLength, 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); ASSERT_TRUE(value > 0) << "strings are unequal and ref is bigger, needs to be >0."; } TEST_F(ascii_compare_WithLength, 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); ASSERT_TRUE(value < 0) << "strings are unequal and ascii is bigger, needs to be <0."; } class ascii_shortenedCompareIgnoreAsciiCase_WithLength : public ::testing::Test { public: }; // class ascii_shortenedCompareIgnoreAsciiCase_WithLength TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_000) { rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0); // should not GPF } TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, 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 } TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, 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 } TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_001) { rtl::OUString suStr1; rtl::OString sStr2; sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), 0, sStr2.getStr(), 0); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, 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()); ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; } // ----------------------------------------------------------------------------- class ascii_compareIgnoreAsciiCase_WithLength : public ::testing::Test { public: }; // class ascii_compareIgnoreAsciiCase_WithLength TEST_F(ascii_compareIgnoreAsciiCase_WithLength, ascii_compareIgnoreAsciiCase_WithLength_000) { rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( NULL, 0, NULL); // should not GPF } TEST_F(ascii_compareIgnoreAsciiCase_WithLength, 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 } TEST_F(ascii_compareIgnoreAsciiCase_WithLength, 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 } TEST_F(ascii_compareIgnoreAsciiCase_WithLength, ascii_compareIgnoreAsciiCase_WithLength_001) { rtl::OUString suStr1; rtl::OString sStr2; sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), 0, sStr2.getStr()); ASSERT_TRUE(nValue == 0) << "compareIgnoreAsciiCase_WithLength failed, strings are equal."; } TEST_F(ascii_compareIgnoreAsciiCase_WithLength, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(ascii_compareIgnoreAsciiCase_WithLength, 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()); ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; } // ----------------------------------------------------------------------------- class ascii_compare : public ::testing::Test { public: }; // class ascii_compare TEST_F(ascii_compare, ascii_compare_000) { rtl_ustr_ascii_compare( NULL, NULL); // should not GPF } TEST_F(ascii_compare, ascii_compare_000_1) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); rtl_ustr_ascii_compare( aStr1.getStr(), NULL); // should not GPF } TEST_F(ascii_compare, ascii_compare_001) { rtl::OUString suStr1; rtl::OString sStr2; sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.getStr()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(ascii_compare, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(ascii_compare, 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()); ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; } // ----------------------------------------------------------------------------- class ascii_compareIgnoreAsciiCase : public ::testing::Test { public: }; // class ascii_compareIgnoreAsciiCase TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_000) { rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL); // should not GPF } TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_000_1) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL); // should not GPF } TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_001) { rtl::OUString suStr1; rtl::OString sStr2; sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(ascii_compareIgnoreAsciiCase, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(ascii_compareIgnoreAsciiCase, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal (if case insensitve)."; } TEST_F(ascii_compareIgnoreAsciiCase, 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()); ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; } //! LLA: some more tests with some high level strings // TEST_F(ascii_compareIgnoreAsciiCase, 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 // ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; // memset(pStr, 0, nLength + sizeof(sal_Unicode)); // memcpy(pStr, suStr1.getStr(), nLength); // // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr ); // rtl::OUString suStr(pStr, suStr1.getLength()); // // ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; // free(pStr); // } // 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 ::testing::Test { public: }; // class ascii_compareIgnoreAsciiCase TEST_F(getToken, getToken_000) { rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL); // should not GPF } TEST_F(getToken, ascii_compareIgnoreAsciiCase_000_1) { rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL); // should not GPF } TEST_F(getToken, ascii_compareIgnoreAsciiCase_001) { rtl::OUString suStr1; rtl::OString sStr2; sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(getToken, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; } TEST_F(getToken, 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()); ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal (if case insensitve)."; } TEST_F(getToken, 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()); ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; } //! LLA: some more tests with some high level strings // TEST_F(getToken, 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 // ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; // memset(pStr, 0, nLength + sizeof(sal_Unicode)); // memcpy(pStr, suStr1.getStr(), nLength); // // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr ); // rtl::OUString suStr(pStr, suStr1.getLength()); // // ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; // free(pStr); // } } // namespace rtl_ustr int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); }