rtl/oustring/rtl_ustr.cxx

/**************************************************************
 *
 * 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 <rtl/ustring.hxx>

/** 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)
    {
        // Former test passed (NULL, NULL); the "should not GPF" comment was
        // wrong -- rtl_ustr_compare requires null-terminated strings and
        // unconditionally dereferences both, so NULL is undefined behaviour.
        // Verify the ordering-sign contract instead, which had no coverage.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("abc");
        rtl::OUString aStr2 = rtl::OUString::createFromAscii("abd");

        ASSERT_TRUE(rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()) < 0)
            << "\"abc\" must compare less than \"abd\".";
        ASSERT_TRUE(rtl_ustr_compare( aStr2.getStr(), aStr1.getStr()) > 0)
            << "\"abd\" must compare greater than \"abc\".";
    }

    TEST_F(compare, compare_000_1)
    {
        // Former test passed (validStr, NULL) -> undefined behaviour.
        // Verify the empty-string boundary instead.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal.");
        rtl::OUString aEmpty;

        ASSERT_TRUE(rtl_ustr_compare( aStr1.getStr(), aEmpty.getStr()) > 0)
            << "a non-empty string must be greater than the empty string.";
        ASSERT_TRUE(rtl_ustr_compare( aEmpty.getStr(), aStr1.getStr()) < 0)
            << "the empty string must be less than a non-empty string.";
    }
    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)
    {
        // Former test passed (NULL, NULL) -> undefined behaviour.  Verify the
        // case-insensitive ordering-sign contract instead.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("abc");
        rtl::OUString aStr2 = rtl::OUString::createFromAscii("ABD");

        ASSERT_TRUE(rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()) < 0)
            << "\"abc\" must compare less than \"ABD\" ignoring case.";
        ASSERT_TRUE(rtl_ustr_compareIgnoreAsciiCase( aStr2.getStr(), aStr1.getStr()) > 0)
            << "\"ABD\" must compare greater than \"abc\" ignoring case.";
    }

    TEST_F(compareIgnoreAsciiCase, compare_000_1)
    {
        // Former test passed (validStr, NULL) -> undefined behaviour.
        // Verify the empty-string boundary instead.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal.");
        rtl::OUString aEmpty;

        ASSERT_TRUE(rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aEmpty.getStr()) > 0)
            << "a non-empty string must be greater than the empty string.";
    }
    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 insensitive).";
    }

    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)
    {
        // Length-bounded: NULL data with length 0 is well-defined (the loop
        // body never runs) and must return 0.  Keep NULL+0 as a regression
        // guard, but assert it.
        sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0, 0);
        ASSERT_TRUE(nValue == 0) << "zero-length comparison must return 0, even for NULL data.";
    }

    TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_000_1)
    {
        // First string has data, second is a zero-length string (NULL data, len 0).
        // Nothing is dereferenced; the function returns the length difference.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal.");
        sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0, 1);
        ASSERT_TRUE(nValue == aStr1.getLength())
            << "comparing against a zero-length string must yield the length difference.";
    }
    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 insensitive).";
    }

    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)
    {
        // Former test passed NULL -> while(*pStr) dereferences NULL (UB).
        // Verify the empty-string boundary: nothing is ever found -> -1.
        rtl::OUString aStr1;
        sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'x' );
        ASSERT_TRUE(nIndex == -1) << "searching an empty string must return -1.";
    }

    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)
    {
        // Former test passed NULL -> getLength(NULL) dereferences NULL (UB).
        // Verify the empty-string boundary instead.
        rtl::OUString aStr1;
        sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'x' );
        ASSERT_TRUE(nIndex == -1) << "searching an empty string must return -1.";
    }

    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)
    {
        // Former test passed (NULL, NULL) -> getLength(NULL) dereferences NULL (UB).
        // Verify the empty-haystack boundary: nothing is found -> -1.
        rtl::OUString aStr1;
        rtl::OUString suSearch = rtl::OUString::createFromAscii("x");
        sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() );
        ASSERT_TRUE(nIndex == -1) << "searching in an empty string must return -1.";
    }

    TEST_F(indexOfStr, indexOfStr_000_1)
    {
        // Former test passed a NULL needle -> getLength(NULL) (UB).
        // Verify the empty-needle boundary: an empty search string is never found.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr.");
        rtl::OUString suSearch;
        sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() );
        ASSERT_TRUE(nIndex == -1) << "an empty search string is never found -> -1.";
    }

    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)
    {
        // Former test passed (NULL, NULL) -> getLength(NULL) dereferences NULL (UB).
        // Verify the empty-haystack boundary instead.
        rtl::OUString aStr1;
        rtl::OUString aSearchStr = rtl::OUString::createFromAscii("Line");
        sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
        ASSERT_TRUE(nIndex == -1) << "searching in an empty string must return -1.";
    }

    TEST_F(lastIndexOfStr, lastIndexOfStr_000_1)
    {
        // Former test passed a NULL needle -> getLength(NULL) (UB).
        // Verify the empty-needle boundary: an empty search string is never found.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr.");
        rtl::OUString aSearchStr;
        sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
        ASSERT_TRUE(nIndex == -1) << "an empty search string is never found -> -1.";
    }

    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)
    {
        // Former test passed NULL -> while(*pStr) dereferences NULL (UB).
        // Verify the empty-string boundary: replacing in "" is a no-op.
        sal_Unicode pStr[] = { 0 };
        rtl_ustr_replaceChar( pStr, 'a', 'b' );
        ASSERT_TRUE(pStr[0] == 0) << "replacing in an empty string must leave it empty.";
    }

    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)
    {
        // Length-bounded: NULL data with length 0 never dereferences -> no-op.
        rtl_ustr_replaceChar_WithLength( NULL, 0, 0, 0 );
        SUCCEED() << "NULL data with zero length must be tolerated (no dereference).";
    }

    TEST_F(replaceChar_WithLength, replaceChar_WithLength_000_1)
    {
        // Former test passed (NULL, 1, ...) -> the loop runs once and
        // dereferences NULL (UB).  Verify the length bound instead: only the
        // first nLen characters are touched, the rest are left intact.
        sal_Unicode pStr[]       = { 'a', 'a', 'a', 'a', 0 };
        sal_Unicode pExpected[]  = { 'b', 'b', 'a', 'a', 0 };
        rtl_ustr_replaceChar_WithLength( pStr, 2, 'a', 'b' );
        ASSERT_TRUE(rtl::OUString(pStr).equals(rtl::OUString(pExpected)) == sal_True)
            << "only the first nLen characters must be replaced.";
    }
    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)
    {
        // Former test passed NULL -> while(*pStr) dereferences NULL (UB).
        // Verify the empty-string boundary: lowercasing "" is a no-op.
        sal_Unicode pStr[] = { 0 };
        rtl_ustr_toAsciiLowerCase( pStr );
        ASSERT_TRUE(pStr[0] == 0) << "lowercasing an empty string must leave it empty.";
    }

    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)
    {
        // Length-bounded: NULL data with length 0 never dereferences -> no-op.
        rtl_ustr_toAsciiLowerCase_WithLength( NULL, 0 );
        SUCCEED() << "NULL data with zero length must be tolerated (no dereference).";
    }

    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)
    {
        // Former test passed NULL -> while(*pStr) dereferences NULL (UB).
        // Verify the empty-string boundary: uppercasing "" is a no-op.
        sal_Unicode pStr[] = { 0 };
        rtl_ustr_toAsciiUpperCase( pStr );
        ASSERT_TRUE(pStr[0] == 0) << "uppercasing an empty string must leave it empty.";
    }

    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)
    {
        // Length-bounded: NULL data with length 0 never dereferences -> no-op.
        rtl_ustr_toAsciiUpperCase_WithLength( NULL, 0 );
        SUCCEED() << "NULL data with zero length must be tolerated (no dereference).";
    }

    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)
    {
        // Length-bounded: NULL data with length 0 never dereferences and
        // returns the resulting length 0.
        sal_Int32 nLen = rtl_ustr_trim_WithLength(NULL, 0);
        ASSERT_TRUE(nLen == 0) << "trimming a zero-length string must return 0 (and 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)
    {
        // Former test passed NULL -> the function writes through NULL (UB);
        // the "should not GPF" comment was wrong, it always did.
        // Verify the documented behaviour on a real buffer.
        sal_Unicode pStr[RTL_USTR_MAX_VALUEOFCHAR];
        sal_Int32 nLen = rtl_ustr_valueOfChar(pStr, 'Z');
        ASSERT_TRUE(nLen == 1) << "valueOfChar must return 1.";
        ASSERT_TRUE(pStr[0] == L'Z') << "valueOfChar must write the character.";
        ASSERT_TRUE(pStr[1] == 0) << "valueOfChar must NUL-terminate.";
    }
    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)
    {
        // A shortened length of 0 means "compare nothing"; the loop never runs
        // and the function returns 0 without dereferencing the (NULL) data.
        sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0);
        ASSERT_TRUE(nValue == 0) << "a shortened length of 0 must return 0, even for NULL data.";
    }

    TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_1)
    {
        // Shortened length 0 -> return 0 without touching the NULL ascii string.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal.");
        sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0);
        ASSERT_TRUE(nValue == 0) << "a shortened length of 0 must return 0.";
    }
    TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_2)
    {
        // Shortened length 0 -> return 0, even though both strings have data.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal.");
        rtl::OString sStr2 =                                 "Line is shorter.";
        sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), sStr2.getLength(), sStr2.getStr(), 0);
        ASSERT_TRUE(nValue == 0) << "a shortened length of 0 must return 0.";
    }
    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)
    {
        // Former test passed a NULL ascii string.  Even with nStr1Len 0 this is
        // undefined behaviour: the "!nStr1Len" branch returns "*pStr2 == '\0' ?
        // 0 : -1", which dereferences the (NULL) ascii pointer.  Use a valid
        // (empty) ascii string instead: an empty-vs-empty comparison is 0.
        rtl::OUString aEmpty;
        sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aEmpty.getStr(), 0, "");
        ASSERT_TRUE(nValue == 0) << "comparing two empty strings must return 0.";
    }

    TEST_F(ascii_compareIgnoreAsciiCase_WithLength, ascii_compareIgnoreAsciiCase_WithLength_000_1)
    {
        // Former test passed (validStr, 0, NULL) -> the "!nStr1Len" branch
        // dereferences the NULL ascii pointer.  Verify the documented boundary
        // instead: a zero-length first string vs. a non-empty ascii string is
        // "less" (-1).
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal.");
        sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aStr1.getStr(), 0, "x");
        ASSERT_TRUE(nValue == -1) << "a zero-length string is less than a non-empty ascii string.";
    }
    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)
    {
        // Former test passed (NULL, NULL); the "should not GPF" comment was
        // wrong -- rtl_ustr_ascii_compare unconditionally dereferences both
        // pointers.  Verify the ordering-sign contract instead.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("abc");

        ASSERT_TRUE(rtl_ustr_ascii_compare( aStr1.getStr(), "abd") < 0)
            << "\"abc\" must compare less than \"abd\".";
        ASSERT_TRUE(rtl_ustr_ascii_compare( aStr1.getStr(), "abb") > 0)
            << "\"abc\" must compare greater than \"abb\".";
    }

    TEST_F(ascii_compare, ascii_compare_000_1)
    {
        // Former test passed (validStr, NULL) -> undefined behaviour.
        // Verify the empty-string boundary instead.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal.");
        ASSERT_TRUE(rtl_ustr_ascii_compare( aStr1.getStr(), "") > 0)
            << "a non-empty string must be greater than the empty string.";
    }
    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)
    {
        // Former test passed (NULL, NULL) -> undefined behaviour (both pointers
        // are dereferenced).  Verify the case-insensitive ordering-sign contract.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("abc");

        ASSERT_TRUE(rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), "ABD") < 0)
            << "\"abc\" must compare less than \"ABD\" ignoring case.";
        ASSERT_TRUE(rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), "ABB") > 0)
            << "\"abc\" must compare greater than \"ABB\" ignoring case.";
    }

    TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_000_1)
    {
        // Former test passed (validStr, NULL) -> undefined behaviour.
        // Verify the empty-string boundary instead.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal.");
        ASSERT_TRUE(rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), "") > 0)
            << "a non-empty string must be greater than the empty string.";
    }
    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 insensitive).";
    }

    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)
    {
        // Former test passed (NULL, NULL) -> undefined behaviour.  Verify the
        // case-insensitive ordering-sign contract instead.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("abc");

        ASSERT_TRUE(rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), "ABD") < 0)
            << "\"abc\" must compare less than \"ABD\" ignoring case.";
        ASSERT_TRUE(rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), "ABB") > 0)
            << "\"abc\" must compare greater than \"ABB\" ignoring case.";
    }

    TEST_F(getToken, ascii_compareIgnoreAsciiCase_000_1)
    {
        // Former test passed (validStr, NULL) -> undefined behaviour.
        // Verify the empty-string boundary instead.
        rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal.");
        ASSERT_TRUE(rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), "") > 0)
            << "a non-empty string must be greater than the empty string.";
    }
    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 insensitive).";
    }

    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();
}