xref: /trunk/main/sal/qa/rtl/oustring/rtl_ustr.cxx (revision cf6516809c57e1bb0a940545cca99cdad54d4ce2)

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