/**************************************************************
 * 
 * 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 <sal/types.h>

//# #ifndef _RTL_TRES_H_
//#     #include <rtl/tres.h>
//# #endif
#include <testshl/tresstatewrapper.hxx>
#include "stringhelper.hxx"
#include <rtl/string.hxx>
#include <rtl/ustring.h>
#include <rtl/ustring.hxx>

//------------------------------------------------------------------------
//------------------------------------------------------------------------
#include <osl/thread.h>
#include <rtl_String_Const.h>
#include <rtl_String_Utils.hxx>


    using namespace rtl;

//------------------------------------------------------------------------
// test classes
//------------------------------------------------------------------------
const int MAXBUFLENGTH = 255;
//------------------------------------------------------------------------
// helper functions
//------------------------------------------------------------------------
static void unused()
{
    // NEVER CALL SUCH FUNCTION!!!
    (void)input1StrLastDefault;
    (void)input1StrLastNormal;
    unused();
}

//------------------------------------------------------------------------
// testing constructors
//------------------------------------------------------------------------
static sal_Bool test_rtl_OUString_ctor_001( hTestResult hRtlTestResult )
{

	::rtl::OUString aUStr;
    rtl_uString * pData = aUStr.pData;

    return
        (
            c_rtl_tres_state
            (
                hRtlTestResult,
                pData->length == 0 &&
                ! *pData->buffer,
                "New OUString containing no characters",
                "ctor_001"
                )
            );
}

//------------------------------------------------------------------------

static sal_Bool SAL_CALL test_rtl_OUString_ctor_002(
    hTestResult hRtlTestResult )
{
    ::rtl::OUString aUStr( kTestStr1,
                           kTestStr1Len,
                           kEncodingRTLTextUSASCII,
                           kConvertFlagsOStringToOUString
                           );
      
    return
        (
            c_rtl_tres_state
            (
                hRtlTestResult,
                aUStr == aUStr1,
                "OUString from an ascii string",
                "ctor_002"
                )
            );
}
//------------------------------------------------------------------------

static sal_Bool SAL_CALL test_rtl_OUString_ctor_003(
    hTestResult hRtlTestResult )
{
	rtl_uString  *rtlUStr =NULL ;
    rtl_uString_newFromAscii( &rtlUStr, kTestStr1 );
	::rtl::OUString aUStr( rtlUStr );
	
	return
        (
            c_rtl_tres_state
            (
                hRtlTestResult,
                aUStr == aUStr1,
                "New OUString from a rtl_uString",
                "ctor_003"
                )
            );
}

//------------------------------------------------------------------------

static sal_Bool SAL_CALL test_rtl_OUString_ctor_004(
    hTestResult hRtlTestResult)
{
    ::rtl::OUString aUStr( aUStr1 );

    return
        (
            c_rtl_tres_state
            (
                hRtlTestResult,
                aUStr == aUStr1,
                "New OUString from unicode string",
                "ctor_004"
                )
            );
}
//------------------------------------------------------------------------

static sal_Bool test_rtl_OUString_ctor_005( hTestResult hRtlTestResult )
{
    ::rtl::OUString aUStr( aUStr2, kTestStr1Len );

    return
        (
            c_rtl_tres_state
            (
                hRtlTestResult,
                aUStr == aUStr1,
                "New OUString from the first n characters of unicode string",
                "ctor_004"
                )
            );
    
}
    

//------------------------------------------------------------------------

static sal_Bool test_rtl_OUString_ctor_006( hTestResult hRtlTestResult )
{
	::rtl::OUString aUStrtmp( aUStr1 );
    ::rtl::OUString aUStr( aUStrtmp );

    return
        (
            c_rtl_tres_state
            (
                hRtlTestResult,
                aUStr==aUStrtmp,
                "New OUString from another OUString",
                "ctor_006"
                )
            );
}

extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_ctors( 
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "ctors");
    sal_Bool DCState = test_ini_uString();      
    (void)DCState;
    sal_Bool bTSState = test_rtl_OUString_ctor_001( hRtlTestResult );
    bTSState &= test_rtl_OUString_ctor_002( hRtlTestResult);
    bTSState &= test_rtl_OUString_ctor_003( hRtlTestResult);
    bTSState &= test_rtl_OUString_ctor_004( hRtlTestResult);
    bTSState &= test_rtl_OUString_ctor_005( hRtlTestResult);
    bTSState &= test_rtl_OUString_ctor_006( hRtlTestResult);
    c_rtl_tres_state_end( hRtlTestResult, "ctors");     
//    return( bTSState );
}


//------------------------------------------------------------------------
// testing the method getLength
//------------------------------------------------------------------------

extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_getLength(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "getLength");
	sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
		sal_Int32 		expVal;
    	OUString*        input;
    	~TestCase() 	{ delete input;}
	} TestCase;

	TestCase arrTestCase[]={

		{"length of ascii string", kTestStr1Len, 
         new OUString( kTestStr1,
                       kTestStr1Len,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString)},
    	{"length of ascci string of size 1", 1, 
         new OUString( "1",
                       1,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString)},
    	{"length of empty string (default constructor)", 0, new OUString()},
		{"length of empty string (empty ascii string arg)",0, 
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString)},
		{"length of empty string (string arg = '\\0')", 0, 
         new OUString( "\0",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString)}
	};


	sal_Bool res = sal_True;
	sal_uInt32 i;

    for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
		sal_Int32 length = arrTestCase[i].input->getLength();
        sal_Bool lastRes = (length == arrTestCase[i].expVal);
        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "getLength", i )

                );
		res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "getLength");
//    return ( res );
}

//------------------------------------------------------------------------
// testing the method equals( const OString & aStr )
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_equals(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "equals");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
		sal_Bool         expVal;
    	OUString*        input1;
		OUString*        input2;
		~TestCase()		{ delete input1;delete input2;}
	} TestCase;

	TestCase arrTestCase[]={

		{"same size", sal_True, new OUString(aUStr1), new OUString(aUStr1)},
		{"different size", sal_False, new OUString(aUStr1),
         new OUString(aUStr2)
		},
		{"same size, no case match", sal_False, new OUString(aUStr1),
         new OUString(aUStr3)
	    },
		{"two empty strings(def. constructor)", sal_True, new OUString(),
         new OUString()
	    },
		{"empty(def.constructor) and non empty", sal_False, new OUString(),
         new OUString(aUStr2)
	    },
		{"non empty and empty(def. constructor)", sal_False, 
         new OUString(aUStr1),
         new OUString()
	    },
		{"two empty strings(string arg = '\\0')", sal_True, 
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString), 
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString)
	    },
		{"empty(string arg = '\\0') and non empty", sal_False, 
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString),
         new OUString(aUStr2)
	    },
		{"non empty and empty(string arg = '\\0')", sal_False, 
         new OUString(aUStr1),
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString)
	    }
	};

    sal_Bool res = sal_True;
    sal_uInt32 i;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        sal_Bool lastRes =
            ( arrTestCase[i].input1->equals(*(arrTestCase[i].input2)) ==  
              arrTestCase[i].expVal );

        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "equals", i )
                );

        res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "equals"); 
//    return (res);
}

//------------------------------------------------------------------------
// testing the method equalsIgnoreAsciiCase( const OString & aStr )
//------------------------------------------------------------------------

extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_equalsIgnoreAsciiCase(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "equalsIgnoreAsciiCase");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
		sal_Bool         expVal;
    	OUString*        input1;
		OUString*        input2;
		~TestCase()		{ delete input1;delete input2;}
	} TestCase;

	TestCase arrTestCase[]={
        {"same strings but different cases",sal_True,new OUString(aUStr4), 
         new OUString(aUStr5)
        },
        {"same strings",sal_True,new OUString(aUStr4), 
         new OUString(aUStr4)},
        {"with equal beginning",sal_False,new OUString(aUStr2), 
         new OUString(aUStr4)
        },
        {"empty(def.constructor) and non empty",sal_False,new OUString(), 
         new OUString(aUStr5)
        },
        {"non empty and empty(def.constructor)",sal_False,
         new OUString(aUStr4), 
         new OUString()
        },
        {"two empty strings(def.constructor)",sal_True,new OUString(), 
         new OUString()
        },
        {"different strings with equal length",sal_False,
         new OUString(aUStr10), 
         new OUString(aUStr11)
        }
    };

    sal_Bool res = sal_True;
	sal_uInt32 i;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        sal_Bool lastRes =
            (arrTestCase[i].input1->equalsIgnoreAsciiCase(*arrTestCase[i].input2) == 
             arrTestCase[i].expVal);

        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "equalsIgnoreAsciiCase", i )
                );

        res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "equalsIgnoreAsciiCase");
//    return (res);
}


static sal_Bool SAL_CALL test_rtl_OUString_compareTo_001(
    hTestResult hRtlTestResult )
{
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
		sal_Int32         expVal;
    	OUString*        input1;
		OUString*        input2;
		~TestCase()		{ delete input1;delete input2;}
	} TestCase;

	TestCase arrTestCase[]={

        {"simple compare, str1 to str5",-1,new OUString(aUStr1), 
         new OUString(aUStr5)
        },
        {"simple compare, str2 to str5",-1,new OUString(aUStr2), 
         new OUString(aUStr5)
        },
        {"simple compare, str1 to str9",-1,new OUString(aUStr1), 
         new OUString(aUStr9)
        },
        {"simple compare, str1 to str2",-1,new OUString(aUStr1), 
         new OUString(aUStr2)
        },
        {"simple compare, str4 to str5",-1,new OUString(aUStr4), 
         new OUString(aUStr5)
        },
        {"simple compare, str1 to str3",-1,new OUString(aUStr1), 
         new OUString(aUStr3)
        },
        {"simple compare, str5 to str1",+1,new OUString(aUStr5), 
         new OUString(aUStr1)
        },
        {"simple compare, str2 to str1",+1,new OUString(aUStr2), 
         new OUString(aUStr1)
        },
        {"simple compare, str9 to str5",+1,new OUString(aUStr9), 
         new OUString(aUStr5)
        },
        {"simple compare, str5 to str4",+1,new OUString(aUStr5), 
         new OUString(aUStr4)
        },
        {"simple compare, str1 to str1",0,new OUString(aUStr1), 
         new OUString(aUStr1)
        },
        {"simple compare, nullString to nullString",0,new OUString(), 
         new OUString()
        },
        {"simple compare, nullString to str2",-1,new OUString(), 
         new OUString(aUStr2)
        },
        {"simple compare, str1 to nullString",+1,new OUString(aUStr1), 
         new OUString()
        }
    };

    sal_Bool res = sal_True;
	sal_uInt32 i;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        sal_Int32 cmpRes = arrTestCase[i].input1->compareTo
            (*arrTestCase[i].input2);
        cmpRes = ( cmpRes == 0 ) ? 0 : ( cmpRes > 0 ) ? +1 : -1 ;
        sal_Bool lastRes = ( cmpRes == arrTestCase[i].expVal);

    
        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "compareTo_001(const OString&)", i )
                );

        res &= lastRes;
    }

    return (res);
}


//------------------------------------------------------------------------
//  testing the method compareTo( const OString & rObj, sal_Int32 length )
//------------------------------------------------------------------------
static sal_Bool SAL_CALL test_rtl_OUString_compareTo_002(
    hTestResult hRtlTestResult )
{
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
		sal_Int32		expVal;
		sal_Int32		maxLength;
   		OUString*		input1;
		OUString*		input2;
		~TestCase()		{ delete input1;delete input2;}
	} TestCase;

	TestCase arrTestCase[] =
    {
        {"compare with maxlength, str1 to str9, 16",-1,16,
         new OUString(aUStr1), new OUString(aUStr9)},
        {"compare with maxlength, str2 to str9, 32",-1,32,
         new OUString(aUStr2), new OUString(aUStr9)},
        {"compare with maxlength, str9 to str4, 16",+1,16,
         new OUString(aUStr9), new OUString(aUStr4)},
        {"compare with maxlength, str9 to str22, 32",+1,32,
         new OUString(aUStr9), new OUString(aUStr22)},
        {"compare with maxlength, str9 to str5, 16",0,16,
         new OUString(aUStr9), new OUString(aUStr5)},
        {"compare with maxlength, str9 to str9, 32",0,32,
         new OUString(aUStr9), new OUString(aUStr9)},
        {"compare with maxlength, str1 to str2, 32",-1,32,
         new OUString(aUStr1), new OUString(aUStr2)},
        {"compare with maxlength, str1 to str2, 32",-1,32,
         new OUString(aUStr1), new OUString(aUStr2)},
        {"compare with maxlength, str1 to str2", 0,-1,
         new OUString(aUStr1), new OUString(aUStr2)}
    };

    sal_Bool res = sal_True;
	sal_uInt32 i;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        sal_Int32 cmpRes = arrTestCase[i].input1->compareTo
            (*arrTestCase[i].input2, arrTestCase[i].maxLength);
        cmpRes = (cmpRes == 0) ? 0 : (cmpRes > 0) ? +1 : -1 ;
        sal_Bool lastRes = (cmpRes == arrTestCase[i].expVal);

        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "compareTo_002(const OString&, sal_Int32)", i )
                );

        res &= lastRes;
    }

    return (res);
}

extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_compareTo(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "compareTo");
    sal_Bool res = test_rtl_OUString_compareTo_001(hRtlTestResult);
    res &= test_rtl_OUString_compareTo_002(hRtlTestResult);
    c_rtl_tres_state_end( hRtlTestResult, "compareTo");
//    return (res);
}

//------------------------------------------------------------------------
// testing the method match( const OUString & str, sal_Int32 fromIndex = 0 )
//------------------------------------------------------------------------
static sal_Bool SAL_CALL test_rtl_OUString_match_001(
    hTestResult hRtlTestResult)

{
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
		sal_Bool         expVal;
		OUString*        input1;
		OUString*        input2;
		~TestCase() 	{ delete input1;delete input2;}
	} TestCase;

	TestCase arrTestCase[]={

		{"aUStr2 and aUStr1", sal_True, new OUString(aUStr2),
         new OUString(aUStr1)},
		{"aUStr1 and aUStr2", sal_False, new OUString(aUStr1),
         new OUString(aUStr2)},
		{"aUStr5 and aUStr6", sal_False, new OUString(aUStr5),
         new OUString(aUStr6)},
		{"null and aUStr1", sal_False, new OUString( "",
                                                     0,
                                                     kEncodingRTLTextUSASCII,
                                                     kConvertFlagsOStringToOUString), 
         new OUString(aUStr1)}
	
	};

    sal_Bool res = sal_True;
    sal_uInt32 i;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        sal_Bool lastRes = ( arrTestCase[i].input1->match(
        	*(arrTestCase[i].input2)) == arrTestCase[i].expVal );

        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "match(const OUString & str)", i  )
                );

        res &= lastRes;
    }
    return (res);
}

static sal_Bool SAL_CALL test_rtl_OUString_match_002(
    hTestResult hRtlTestResult )

{
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
		sal_Bool         expVal;
		sal_Int32		fromIndex;
    	OUString*		input1;
		OUString*		input2;
		~TestCase()		{ delete input1;delete input2;}
	} TestCase;

	TestCase arrTestCase[]={

		{"aUStr2 from 17 and aUStr6", sal_True, 17, 
         new OUString(aUStr2),new OUString(aUStr6)},
		{"aUStr2 from 5 and aUStr6", sal_False, 5, 
         new OUString(aUStr2),new OUString(aUStr6)},
		{"aUStr2 from 0 and aUStr1", sal_True, 0, 
         new OUString(aUStr2),new OUString(aUStr1)},
		{"aUStr1 from 16 and null", sal_True, 16, 
         new OUString(aUStr1),
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString
                       )
	    },
		{"aUStr1 from 5 and null", sal_True, 5, 
         new OUString(aUStr1),
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString
                       )
	    },
		{"aUStr2 from -1 and aUStr1", sal_False, -1, 
         new OUString(aUStr2),new OUString(aUStr1)},
		{"aUStr5 from 2 and aUStr4", sal_False, 2, 
         new OUString(aUStr5),new OUString(aUStr4)},
		{"aUStr2 from 18 and aUStr1", sal_False, 18, 
         new OUString(aUStr2),new OUString(aUStr1)}
	};

    sal_Bool res = sal_True;
    sal_uInt32 i;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        sal_Bool lastRes = ( arrTestCase[i].input1->match
                             (*(arrTestCase[i].input2),arrTestCase[i].fromIndex) == 
                             arrTestCase[i].expVal );

        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, 
                            "match(const OUString & str,sal_Int32 fromIndex = 0)", i  )  
            					
                );

        res &= lastRes;
    }
    return (res);
}

extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_match(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "match");
    sal_Bool res = test_rtl_OUString_match_001(hRtlTestResult);
    res &= test_rtl_OUString_match_002(hRtlTestResult);
    c_rtl_tres_state_end( hRtlTestResult, "match");
//    return (res);
}                    

//------------------------------------------------------------------------
// testing the operator +=
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_op_eq(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "eq");
	sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
	   	OUString*        input1;
    	OUString*        input2;
    	~TestCase() 	{ delete input1; delete input2;}
	} TestCase;

	TestCase arrTestCase[]={
		{"null and Ustr1", new OUString, new OUString(aUStr1)},
		{"Ustr2 and Ustr1", new OUString(aUStr2), 
         new OUString(aUStr1)},
		{""" and Ustr1 from bit character buffer",  
         new OUString(aUStr1),
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString
                       )},
		{"Ustr1 and Ustr2 from value and length",   
         new OUString( aUStr2, kTestStr2Len ), 
         new OUString(aUStr1)} 
	};


	sal_Bool res = sal_True;
	sal_uInt32 i;

    for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
		*(arrTestCase[i].input1) = *(arrTestCase[i].input2);
        sal_Bool lastRes = (*(arrTestCase[i].input1) ==
                            *(arrTestCase[i].input2));
        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "op_eq", i )

                );
		res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "eq");
//    return ( res );
}

//------------------------------------------------------------------------
// testing the operator +=
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_op_peq(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "peq");
	sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
		OUString*		expVal;
	   	OUString*        input1;
    	OUString*        input2;
    	~TestCase() 	{ delete input1; delete input2;}
	} TestCase;

	TestCase arrTestCase[]={
		{" ' '= ''+='' ", new OUString( "",
                                        0,
                                        kEncodingRTLTextUSASCII,
                                        kConvertFlagsOStringToOUString
                                        ),
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString
                       ),
         new OUString( "",
                       0,
                       kEncodingRTLTextUSASCII,
                       kConvertFlagsOStringToOUString
                       )},
		{"Ustr1= null += Ustr1", new OUString(aUStr1),
         new OUString(), new OUString(aUStr1)},
		{"Ustr1= '' += Ustr1", new OUString(aUStr1),
		 /*new OUString( "",
           0,
           kEncodingRTLTextUSASCII,
           kConvertFlagsOStringToOUString
           )*/
		 new OUString(),
         new OUString(aUStr1)},
		{"Ustr1PlusUStr6 = Ustr1 += Ustr6",  
         new OUString(aUStr1PlusUStr6), new OUString(aUStr1),
         new OUString(aUStr6)},
	};


	sal_Bool res = sal_True;
	sal_uInt32 i;

    for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {   
		*(arrTestCase[i].input1) += *(arrTestCase[i].input2);
        sal_Bool lastRes = (*(arrTestCase[i].expVal) == 
                            *(arrTestCase[i].input1));
        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "op_peq", i )

                );
		res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "peq");
//    return ( res );
}

//------------------------------------------------------------------------
// testing the operator const sal_Unicode * (csuc for short)
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_csuc(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "csuc");
	sal_Char methName[MAXBUFLENGTH];
	sal_Char* pMeth = methName;

	const sal_Unicode tmpUC=0x0;
	rtl_uString* tmpUstring = NULL;
	const sal_Char *tmpStr=kTestStr1;
	sal_Int32 tmpLen=(sal_Int32) kTestStr1Len;
	// sal_Int32 cmpLen = 0;

	rtl_string2UString( &tmpUstring, tmpStr,  tmpLen,                                
                        osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS );
    OSL_ASSERT(tmpUstring != NULL);


	typedef struct TestCase
    {
        sal_Char*				comments;
        const sal_Unicode*		expVal;
        sal_Int32				cmpLen;
        OUString*                input1;
        ~TestCase() {  delete input1;}
 	} TestCase;

    TestCase arrTestCase[] =
    {
      	{"test normal ustring",(*tmpUstring).buffer,kTestStr1Len, 
         new OUString(aUStr1)},
        {"test empty ustring",&tmpUC, 1, new OUString()}
    };

    sal_Bool res = sal_True;
    sal_uInt32 i;
    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        const sal_Unicode* pstr = *arrTestCase[i].input1;

        res &= c_rtl_tres_state
            (
                hRtlTestResult,
                cmpstr((sal_Char*)pstr,
                       (sal_Char*)arrTestCase[i].expVal,
                       arrTestCase[i].cmpLen),
                arrTestCase[i].comments,
                createName( pMeth, "const sal_Unicode*", i )
                );
    }
    c_rtl_tres_state_end( hRtlTestResult, "csuc");
//    return ( res );
}

//------------------------------------------------------------------------
// testing the method const sal_Unicode * getStr()
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_getStr(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "getStr");
	sal_Char methName[MAXBUFLENGTH];
	sal_Char* pMeth = methName;

	const sal_Unicode tmpUC=0x0;
	rtl_uString* tmpUstring = NULL;
	const sal_Char *tmpStr=kTestStr1;
	sal_Int32 tmpLen=(sal_Int32) kTestStr1Len;
	// sal_Int32 cmpLen = 0;

	rtl_string2UString( &tmpUstring, tmpStr,  tmpLen,                                
                        osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS );
    OSL_ASSERT(tmpUstring != NULL);


	typedef struct TestCase
    {
        sal_Char*				comments;
        const sal_Unicode*		expVal;
        sal_Int32				cmpLen;
        OUString*                input1;
        ~TestCase() {  delete input1;}
 	} TestCase;

    TestCase arrTestCase[] =
    {
      	{"test normal ustring",(*tmpUstring).buffer,kTestStr1Len, 
         new OUString(aUStr1)},
        {"test empty ustring",&tmpUC, 1, new OUString()}
    };

    sal_Bool res = sal_True;
    sal_uInt32 i;
    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        const sal_Unicode* pstr = arrTestCase[i].input1->getStr();

        res &= c_rtl_tres_state
            (
                hRtlTestResult,
                cmpstr((sal_Char*)pstr,
                       (sal_Char*)arrTestCase[i].expVal,
                       arrTestCase[i].cmpLen),
                arrTestCase[i].comments,
                createName( pMeth, "getStr", i )
                );
    }
    c_rtl_tres_state_end( hRtlTestResult, "getStr");
//    return ( res );
}


//------------------------------------------------------------------------
// testing the method sal_Int32 reverseCompareTo( const OUString & str )
//-------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_reverseCompareTo(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "reverseCompareTo");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

	typedef struct TestCase
	{
		sal_Char*		comments;
		sal_Int32         expVal;
    	OUString*        input1;
		OUString*        input2;
		~TestCase()		{ delete input1;delete input2;}
	} TestCase;

	TestCase arrTestCase[]={

        {"simple compare, str1 to str5",-1,new OUString(aUStr1), 
         new OUString(aUStr5)
        },
        {"simple compare, str2 to str5",1,new OUString(aUStr2), 
         new OUString(aUStr5)
        },
        {"simple compare, str1 to str9",-1,new OUString(aUStr1), 
         new OUString(aUStr9)
        },
        {"simple compare, str4 to str5",-1,new OUString(aUStr4), 
         new OUString(aUStr5)
        },
        {"simple compare, str5 to str1",+1,new OUString(aUStr5), 
         new OUString(aUStr1)
        },
        {"simple compare, str2 to str1",+1,new OUString(aUStr2), 
         new OUString(aUStr1)
        },
        {"simple compare, str1 to str1",0,new OUString(aUStr1), 
         new OUString(aUStr1)
        },
        {"simple compare, nullString to nullString",0,new OUString(), 
         new OUString()
        },
        {"simple compare, nullString to str2",-1,new OUString(), 
         new OUString(aUStr2)
        },
        {"simple compare, str1 to nullString",+1,new OUString(aUStr1), 
         new OUString()
        }
    };

    sal_Bool res = sal_True;
	sal_uInt32 i;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        sal_Int32 cmpRes = arrTestCase[i].input1->reverseCompareTo
            (*arrTestCase[i].input2);
        cmpRes = ( cmpRes == 0 ) ? 0 : ( cmpRes > 0 ) ? +1 : -1 ;
        sal_Bool lastRes = ( cmpRes == arrTestCase[i].expVal);

    
        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "compareTo(const OString&)", i )
                );

        res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "reverseCompareTo");
//    return (res);
}

//------------------------------------------------------------------------
//       testing the method sal_Bool equalsAscii( const sal_Char* asciiStr )
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_equalsAscii(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "equalsAscii");
	sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

    const sal_Char *tmpAstr1="Sun Microsystems\0";
    const sal_Char *tmpAstr2="\0";
   
    
	typedef struct TestCase
	{
		sal_Char*		 comments;
		sal_Bool		 expVal;
	   	OUString*         input1;
        const sal_Char*    input2;
    	~TestCase() 	{ delete input1;}
	} TestCase;

	TestCase arrTestCase[]={
		{"str1 with str1 ", sal_True, new OUString( kTestStr1,
                                                    kTestStr1Len,
                                                    kEncodingRTLTextUSASCII,
                                                    kConvertFlagsOStringToOUString
                                                    ), tmpAstr1},
		{"str2 with str1 ", sal_False,new OUString( kTestStr2,
                                                    kTestStr2Len,
                                                    kEncodingRTLTextUSASCII,
                                                    kConvertFlagsOStringToOUString
                                                    ), tmpAstr1},	
	    {"null with str1  ", sal_False, new OUString(), tmpAstr1},
	    {"null with '' ", sal_True, new OUString(), tmpAstr2},
	    {"'' with ''", sal_True, new OUString( "",
                                               0,
                                               kEncodingRTLTextUSASCII,
                                               kConvertFlagsOStringToOUString
                                               ),
         tmpAstr2}
	       
	};


	sal_Bool res = sal_True;
	sal_uInt32 i;

    for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {   
    
		sal_Bool lastRes = (arrTestCase[i].expVal == 
                            arrTestCase[i].input1->equalsAscii(arrTestCase[i].input2));
        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "equalsAscii", i )

                );
		res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "equalsAscii");
//    return ( res );
}


//------------------------------------------------------------------------
//       testing the method sal_Bool equalsAsciiL( 
//							const sal_Char* asciiStr, sal_Int32 asciiStrLength )
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_equalsAsciiL(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "equalsAsciiL");
	sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

    const sal_Char *tmpAstr1="Sun Microsystems\0";
    const sal_Char *tmpAstr2="\0";
    const sal_Char *tmpAstr3="Sun Microsystems Java Technology\0";
   
    
	typedef struct TestCase
	{
		sal_Char*		 comments;
		sal_Bool		 expVal;
	   	OUString*         input1;
        const sal_Char*    input2;
        sal_Int32          cmpLen;
    	~TestCase() 	{ delete input1;}
	} TestCase;

	TestCase arrTestCase[]={
		{"str1 with str1,str1Len ", sal_True, new OUString( kTestStr1,
                                                            kTestStr1Len,
                                                            kEncodingRTLTextUSASCII,
                                                            kConvertFlagsOStringToOUString
                                                            ), tmpAstr1, kTestStr1Len},
		{"str2 with str1,str1Len", sal_False,new OUString( kTestStr2,
                                                           kTestStr2Len,
                                                           kEncodingRTLTextUSASCII,
                                                           kConvertFlagsOStringToOUString
                                                           ), tmpAstr1, kTestStr1Len},	
	    {"str1 with str2,str1Len", sal_True,new OUString( kTestStr1,
                                                          kTestStr1Len,
                                                          kEncodingRTLTextUSASCII,
                                                          kConvertFlagsOStringToOUString
                                                          ), tmpAstr3, kTestStr1Len},                    
	    {"null with str1,1  ", sal_False, new OUString(), tmpAstr1, 1},
	    {"null with '',1 ", sal_False, new OUString(), tmpAstr2, 1},
	    {"'' with '', 1", sal_False, new OUString( "",
                                                   0,
                                                   kEncodingRTLTextUSASCII,
                                                   kConvertFlagsOStringToOUString
                                                   ),
         tmpAstr2, 1}
	       
	};


	sal_Bool res = sal_True;
	sal_uInt32 i;

    for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {   
		
		sal_Bool lastRes = (arrTestCase[i].expVal == 
                            arrTestCase[i].input1->equalsAsciiL(arrTestCase[i].input2,
                                                                arrTestCase[i].cmpLen)
                            );
        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "equalsAsciiL", i )

                );
		res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "equalsAsciiL");
//    return ( res );
}

//------------------------------------------------------------------------
//       testing the method sal_Int32 compareToAscii( const sal_Char* asciiStr )
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_compareToAscii(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "compareToAscii");
	sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

    const sal_Char *tmpAstr1="Sun Microsystems\0";
    const sal_Char *tmpAstr2="\0";
    const sal_Char *tmpAstr3="sun microsystems java technology\0";
    const sal_Char *tmpAstr4="Sun Microsystems Java Technology\0";
    

	typedef struct TestCase
	{
		sal_Char*		 comments;
		sal_Int32		 expVal;
	   	OUString*         input1;
        const sal_Char*    input2;
    	~TestCase() 	{ delete input1;}
	} TestCase;

	TestCase arrTestCase[]={
		{"str1 with str1 ", 0, new OUString( kTestStr1,
                                             kTestStr1Len,
                                             kEncodingRTLTextUSASCII,
                                             kConvertFlagsOStringToOUString
                                             ), tmpAstr1},
		{"str1 with '' ", 83, new OUString( kTestStr1,
                                            kTestStr1Len,
                                            kEncodingRTLTextUSASCII,
                                            kConvertFlagsOStringToOUString
                                            ), tmpAstr2},	
	    {"null with str1  ", -83 , new OUString(), tmpAstr1},
	    {"null with '' ", 0, new OUString(), tmpAstr2},
	    {"str1 with str9", -32, new OUString( kTestStr1,
                                              kTestStr1Len,
                                              kEncodingRTLTextUSASCII,
                                              kConvertFlagsOStringToOUString
                                              ),
         tmpAstr3},
	    {"str1 with str2", -32, new OUString( kTestStr1,
                                              kTestStr1Len,
                                              kEncodingRTLTextUSASCII,
                                              kConvertFlagsOStringToOUString
                                              ),
         tmpAstr4}
	       
	};


	sal_Bool res = sal_True;
	sal_uInt32 i;

    for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {   
		sal_Bool lastRes = (arrTestCase[i].expVal == 
                            arrTestCase[i].input1->compareToAscii(arrTestCase[i].input2));
		
        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "equalsAscii", i )

                );
		res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "compareToAscii");
//    return ( res );
}


//------------------------------------------------------------------------
//       testing the method valueOf( sal_Bool b )
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_valueOf_sal_Bool(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "Bool");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

    typedef struct TestCase
    {
        sal_Char*       comments;
        OUString*       expVal;
        sal_Bool        input1;
        
        ~TestCase()     {delete expVal;}
    }TestCase;

    TestCase arrTestCase[]=
    {
        {"input Bool 'true' and return OUString 'true'",
         new OUString("true",4,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString),
         sal_True
        },
        {"input Bool 'false' and return OUString 'false'",
         new OUString("false",5,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString),
         sal_False
        }
    };

    sal_Bool    res;
    sal_uInt32   i;

    for(i=0;i<(sizeof(arrTestCase))/(sizeof(TestCase));i++)
    {
        sal_Bool lastRes=(*arrTestCase[i].expVal==
                          OUString::valueOf(arrTestCase[i].input1)

                          );

        c_rtl_tres_state(hRtlTestResult,
                         lastRes,
                         arrTestCase[i].comments,
                         createName( pMeth, "valueOf( sal_Bool b )", i )
                         );

        res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "Bool");   
//    return(res);
}

//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_valueOf_sal_Unicode(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "Unicode");
    sal_Char    methName[MAXBUFLENGTH];
    sal_Char*   pMeth = methName;

    sal_Unicode tmpchar1=97;
    sal_Unicode tmpchar2=53;
    sal_Unicode tmpchar3=0;
    sal_Unicode tmpchar4=32;
    sal_Unicode tmpchar5=47;

    typedef struct TestCase
    {
        sal_Char*       comments;
        OUString*       expVal;
        sal_Unicode     input1;
        
        ~TestCase()     {delete expVal;}
    }TestCase;

    TestCase arrTestCase[]=
    {
        {"input Unicode 'a' and return OUString 'a'",
         new OUString(&tmpchar1,1),tmpchar1
        },
        {"input Unicode '5' and return OUString '5'",
         new OUString(&tmpchar2,1), tmpchar2
        },
        {"input Unicode 0 and return OUString 0",
         new OUString(&tmpchar3,1),tmpchar3
        },
        {"input Unicode ' ' and return OUString ' '",
         new OUString(&tmpchar4,1),tmpchar4
        },
        {"input Unicode '/' and return OUString ' '",
         new OUString(&tmpchar5,1),tmpchar5
        }
    };
    
    sal_Bool    res=sal_True;
    sal_uInt32   i;

    for(i=0;i<(sizeof(arrTestCase))/(sizeof(TestCase));i++)
    {
        sal_Bool lastRes=(*(arrTestCase[i].expVal)==
                          OUString::valueOf(arrTestCase[i].input1));
       
        c_rtl_tres_state(hRtlTestResult,
                         lastRes,
                         arrTestCase[i].comments,
                         createName( pMeth, "valueOf( sal_Unicode c )", i )
                         );

        res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "Unicode");   
//    return(res);
}


/**
 * Calls the method valueOf(T, radix) and compares
 * returned ustrings with ustrings that passed in the array resArray.
 *
 * @param T, type of argument, passed to valueOf
 * @param resArray, array of result ustrings to compare to
 * @param n the number of elements in the array resArray (testcases)
 * @param pTestResult the instance of the class TestResult
 * @param inArray [optional], array of value that is passed as first argument
 *                            to valueOf
 *
 * @return true, if all returned ustrings are equal to corresponding ustring in
 *               resArray else, false.
 */
template <class T>
sal_Bool test_valueOf( const char** resArray, int n, sal_Int16 radix,
                       hTestResult hRtlTestResult, const T *inArray )
{
    sal_Bool    bRes = sal_True;

    sal_Char    methName[MAXBUFLENGTH];
    sal_Char*   pMeth = methName;
    sal_Int32   i;
//    static sal_Unicode aUchar[50]={0x12};

    for (i = 0; i < n; i++)
    {
        ::rtl::OUString aStr1;
        
		OSL_ENSURE( i < 50, "ERROR: leave aUchar bound");

//        AStringToUStringCopy(aUchar,resArray[i]);
//        ::rtl::OUString aStr2(aUchar);
        rtl::OUString aStr2;
        aStr2 = OUString::createFromAscii(resArray[i]);

        ::rtl::OUString aStr3( "-",1,kEncodingRTLTextUSASCII,
                               kConvertFlagsOStringToOUString);

        if (inArray == 0)
		{
			aStr1 = ::rtl::OUString::valueOf((T)i, radix);
		}
        else
        {
            if ( inArray[i] < 0 )
            {
                sal_Unicode   aStr4[100];
                OSL_ASSERT(strlen(resArray[i]) < 100);

                if(AStringToUStringCopy(aStr4,resArray[i]))
                {
                    aStr2 = aStr3;
                    aStr2 += aStr4;
                }
                                 
            }
            aStr1 = ::rtl::OUString::valueOf((T)inArray[i], radix);
        }

        bRes &= c_rtl_tres_state
            (
                hRtlTestResult,
                aStr2.compareTo(aStr1) == 0,
                (sal_Char*)resArray[i],
                createName( pMeth, "valueOf", i )
                );
    }

    return (bRes);
}


#define test_valueOf_Int32      test_valueOf<sal_Int32>
#define test_valueOf_Int64      test_valueOf<sal_Int64>
// LLA: #define test_valueOf_float      test_valueOf<float>
// LLA: #define test_valueOf_double     test_valueOf<double>

//------------------------------------------------------------------------
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=2 )
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=8 )
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=10 )
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=16 )
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=36 )
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int32(
    hTestResult hRtlTestResult )
{
    sal_Bool bRes = sal_False;

    bRes = c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kBinaryNumsStr,
                               kBinaryNumsCount, kRadixBinary, hRtlTestResult, 0 ),
            "kRadixBinary",
            "valueOf(sal_Int32, radix 2)"
            );


    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kOctolNumsStr,
                               kOctolNumsCount, kRadixOctol, hRtlTestResult, 0),
            "kRadixOctol",
            "valueOf(sal_Int32, radix 8)"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kDecimalNumsStr,
                               kDecimalNumsCount, kRadixDecimal, hRtlTestResult, 0),
            "kRadixDecimal",
            "valueOf(sal_Int32, radix 10)"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kHexDecimalNumsStr,
                               kHexDecimalNumsCount, kRadixHexdecimal, hRtlTestResult, 0),
            "kRadixHexdecimal",
            "valueOf(sal_Int32, radix 16)"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kBase36NumsStr,
                               kBase36NumsCount, kRadixBase36, hRtlTestResult, 0),
            "kRadixBase36",
            "valueOf(sal_Int32, radix 36)"
            );


    return ( bRes );
}

//------------------------------------------------------------------------
// testing the method valueOf( sal_Int32 l, sal_Int32 radix=2 )
// where l = large constants
// testing the method valueOf( sal_Int32 l, sal_Int32 radix=8 )
// where l = large constants
// testing the method valueOf( sal_Int32 l, sal_Int32 radix=10 )
// where l = large constants
// testing the method valueOf( sal_Int32 l, sal_Int32 radix=16 )
// where l = large constants
// testing the method valueOf( sal_Int32 l, sal_Int32 radix=36 )
// where l = large constants
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int32_Bounderies(
    hTestResult hRtlTestResult )
{
    sal_Bool bRes = sal_False;

    bRes =  c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kBinaryMaxNumsStr,
                               kInt32MaxNumsCount, kRadixBinary, 
                               hRtlTestResult, kInt32MaxNums),
            "kRadixBinary",
            "valueOf(salInt32, radix 2) Bounderies"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kOctolMaxNumsStr,
                               kInt32MaxNumsCount, kRadixOctol, 
                               hRtlTestResult, kInt32MaxNums),
            "kRadixOctol",
            "valueOf(salInt32, radix 8) Bounderies"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kDecimalMaxNumsStr,
                               kInt32MaxNumsCount, kRadixDecimal,
                               hRtlTestResult, kInt32MaxNums),
            "kRadixDecimal",
            "valueOf(salInt32, radix 10) Bounderies"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kHexDecimalMaxNumsStr,
                               kInt32MaxNumsCount, kRadixHexdecimal,
                               hRtlTestResult, kInt32MaxNums),
            "kRadixHexdecimal",
            "valueOf(salInt32, radix 16) Bounderies"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32((const char**)kBase36MaxNumsStr,
                               kInt32MaxNumsCount, kRadixBase36,
                               hRtlTestResult, kInt32MaxNums),
            "kRadixBase36",
            "valueOf(salInt32, radix 36) Bounderies"
            );

    return ( bRes );
}

//------------------------------------------------------------------------
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=2 )
// for negative value
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=8 )
// for negative value
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=10 )
// for negative value
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=16 )
// for negative value
// testing the method valueOf( sal_Int32 i, sal_Int16 radix=36 )
// for negative value
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int32_Negative(
    hTestResult hRtlTestResult )
{
    sal_Bool bRes = sal_False;
    sal_Int32 inArr[kBase36NumsCount];
    sal_Int32 i;

    for (i = 0; i < kBase36NumsCount; i++ )
        inArr[i] = -i;

    bRes =  c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32( kBinaryNumsStr, kBinaryNumsCount,
                                kRadixBinary, hRtlTestResult, inArr ),
            "negative Int32, kRadixBinary",
            "valueOf( negative Int32, radix 2 )"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32( kOctolNumsStr, kOctolNumsCount,
                                kRadixOctol, hRtlTestResult, inArr ),
            "negative Int32, kRadixOctol",
            "valueOf( negative Int32, radix 8 )"
            );


    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32( kDecimalNumsStr, kDecimalNumsCount,
                                kRadixDecimal, hRtlTestResult, inArr ),
            "negative Int32, kRadixDecimal",
            "valueOf( negative Int32, radix 10 )"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32( kHexDecimalNumsStr, kHexDecimalNumsCount,
                                kRadixHexdecimal, hRtlTestResult, inArr ),
            "negative Int32, kRadixHexdecimal",
            "valueOf( negative Int32, radix 16 )"
            );


    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int32( kBase36NumsStr, kBase36NumsCount,
                                kRadixBase36, hRtlTestResult, inArr ),
            "negative Int32, kRadixBase36",
            "valueOf( negative Int32, radix 36 )"
            );

    return ( bRes );
}
//------------------------------------------------------------------------
// testing the method valueOf( sal_Int32 l, sal_Int32 radix ) where radix = -5
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int32_WrongRadix(
    hTestResult hRtlTestResult )
{
    sal_Bool bRes = sal_False;

    sal_Int32 intVal = 11;

    ::rtl::OUString aStr1;
    ::rtl::OUString aStr2("11",2,kEncodingRTLTextUSASCII,
                          kConvertFlagsOStringToOUString);

    aStr1 = aStr1.valueOf( intVal, -5 );

    bRes = c_rtl_tres_state
        (
            hRtlTestResult,
            aStr2.compareTo( aStr1 ) == 0,
            "if radix not valid then radix must be 10",
            "valueOf(sal_Int32, sal_Int32 radix): radix = -5"
            );

    return (bRes);
}


//------------------------------------------------------------------------
static sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int32_defaultParam(
    hTestResult hRtlTestResult )
{    
    sal_Char     methName[MAXBUFLENGTH];
    sal_Char*    pMeth = methName;

    sal_Char*    newUChar1="15";
    sal_Char*    newUChar2="0";
    sal_Char*    newUChar3="-15";
    sal_Char*    newUChar4="2147483647";
    sal_Char*    newUChar5="-2147483648";

    typedef struct TestCase
    {
        sal_Char*       comments;
        sal_Int32       input1;
        OUString*       expVal;
        ~TestCase()     {delete expVal;}
    }TestCase;

    TestCase arrTestCase[]=
    {
        {"input Int32 15 and return OUString 15",15,
         new OUString(newUChar1,2,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        },
        {"input Int32 0 and return OUString 0",0,
         new OUString(newUChar2,1,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        },
        {"input Int32 -15 and return OUString -15",-15,
         new OUString(newUChar3,3,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        },
        {"input Int32 2147483647 and return OUString 2147483647", SAL_MAX_INT32 /* 2147483647 */,
         new OUString(newUChar4,10,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        },
        {"input Int32 -2147483648 and return OUString -2147483648", 
         SAL_MIN_INT32 /* 2-2147483648 */,
         new OUString(newUChar5,11,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        }
    };

    sal_Bool    res=sal_True;
    sal_uInt32   i;

    for(i=0;i<(sizeof(arrTestCase))/(sizeof(TestCase));i++)
    {
        sal_Bool lastRes=(*(arrTestCase[i].expVal)==
                          OUString::valueOf(arrTestCase[i].input1));

        c_rtl_tres_state(hRtlTestResult,
                         lastRes,
                         arrTestCase[i].comments,
                         createName( pMeth, 
                                     "valueOf( sal_Int32 i, sal_Int16 radix = 10 )", i )
                         );

        res &= lastRes;
    }
    
    return(res);

}
//------------------------------------------------------------------------
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=2 )
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=8 )
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=10 )
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=16 )
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=36 )
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int64(
    hTestResult hRtlTestResult )
{
    sal_Bool bRes = sal_False;

    bRes =  c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kBinaryNumsStr,
                               kBinaryNumsCount, kRadixBinary, hRtlTestResult, 0),
            "kRadixBinary",
            "valueOf(sal_Int64, radix 2)_"
            );

    bRes &=  c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kOctolNumsStr,
                               kOctolNumsCount, kRadixOctol, hRtlTestResult, 0),
            "kRadixOctol",
            "valueOf(sal_Int64, radix 8)_"
            );

    bRes &=  c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kDecimalNumsStr,
                               kDecimalNumsCount, kRadixDecimal, hRtlTestResult, 0),
            "kRadixDecimal",
            "valueOf(sal_Int64, radix 10)_"
            );
    bRes &=  c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kHexDecimalNumsStr,
                               kHexDecimalNumsCount, kRadixHexdecimal, hRtlTestResult, 0),
            "kRadixHexdecimal",
            "valueOf(sal_Int64, radix 16)_"
            );

    bRes &=  c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kBase36NumsStr,
                               kBase36NumsCount, kRadixBase36, hRtlTestResult, 0),
            "kRadixBase36",
            "valueOf(sal_Int64, radix 36)_"
            );

    return (bRes);
}

//------------------------------------------------------------------------
// testing the method valueOf( sal_Int64 l, sal_Int32 radix=2 )
// where l = large constants
// testing the method valueOf( sal_Int64 l, sal_Int32 radix=8 )
// where l = large constants
// testing the method valueOf( sal_Int64 l, sal_Int32 radix=10 )
// where l = large constants
// testing the method valueOf( sal_Int64 l, sal_Int32 radix=16 )
// where l = large constants
// testing the method valueOf( sal_Int64 l, sal_Int32 radix=36 )
// where l = large constants
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int64_Bounderies(
    hTestResult hRtlTestResult )
{
    sal_Bool bRes = sal_False;

    bRes =  c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kBinaryMaxNumsStr,
                               kInt64MaxNumsCount, kRadixBinary,
                               hRtlTestResult, kInt64MaxNums),
            "kRadixBinary",
            "valueOf(salInt64, radix 2) Bounderies"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kOctolMaxNumsStr,
                               kInt64MaxNumsCount, kRadixOctol,
                               hRtlTestResult, kInt64MaxNums),
            "kRadixOctol",
            "valueOf(salInt64, radix 8) Bounderies"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kDecimalMaxNumsStr,
                               kInt64MaxNumsCount, kRadixDecimal,
                               hRtlTestResult, kInt64MaxNums),
            "kRadixDecimal",
            "valueOf(salInt64, radix 10) Bounderies"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kHexDecimalMaxNumsStr,
                               kInt64MaxNumsCount, kRadixHexdecimal,
                               hRtlTestResult, kInt64MaxNums),
            "kRadixHexdecimal",
            "valueOf(salInt64, radix 16) Bounderies"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64((const char**)kBase36MaxNumsStr,
                               kInt64MaxNumsCount, kRadixBase36,
                               hRtlTestResult, kInt64MaxNums),
            "kRadixBase36",
            "valueOf(salInt64, radix 36) Bounderies"
            );

    return ( bRes );
}

//------------------------------------------------------------------------
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=2 )
// for negative value
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=8 )
// for negative value
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=10 )
// for negative value
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=16 )
// for negative value
// testing the method valueOf( sal_Int64 l, sal_Int16 radix=36 )
// for negative value
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int64_Negative(
    hTestResult hRtlTestResult )
{
    sal_Bool bRes = sal_False;

    sal_Int64 inArr[36];
	sal_Int32 i;

    for (i = 0; i < 36; i++) {
        inArr[i] = -i;
    }


    bRes = c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64( kBinaryNumsStr, kBinaryNumsCount,
                                kRadixBinary, hRtlTestResult, inArr ),
            "negative Int64, kRadixBinary",
            "valueOf( negative Int64, radix 2 )"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64( kOctolNumsStr, kOctolNumsCount,
                                kRadixOctol, hRtlTestResult, inArr ),
            "negative Int64, kRadixOctol",
            "valueOf( negative Int64, radix 8 )"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64( kDecimalNumsStr, kDecimalNumsCount,
                                kRadixDecimal, hRtlTestResult, inArr ),
            "negative Int64, kRadixDecimal",
            "valueOf( negative Int64, radix 10 )"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64( kHexDecimalNumsStr, kHexDecimalNumsCount,
                                kRadixHexdecimal, hRtlTestResult, inArr ),
            "negative Int64, kRadixHexDecimal",
            "valueOf( negative Int64, radix 16 )"
            );

    bRes &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_valueOf_Int64( kBase36NumsStr, kBase36NumsCount,
                                kRadixBase36, hRtlTestResult, inArr),
            "negative Int64, kRadixBase36",
            "valueOf( negative Int64, radix 36 )"
            );

    return (bRes);
}
//------------------------------------------------------------------------
// testing the method valueOf( sal_Int64 l, sal_Int32 radix )
// where radix = -5
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int64_WrongRadix(
    hTestResult hRtlTestResult )
{
    sal_Bool bRes = sal_False;

    sal_Int64 intVal = 11;

    ::rtl::OUString aStr1;
    ::rtl::OUString aStr2("11",2,kEncodingRTLTextUSASCII,
                          kConvertFlagsOStringToOUString);

    aStr1 = aStr1.valueOf( intVal, -5 );

    bRes = c_rtl_tres_state
        (
            hRtlTestResult,
            aStr2.compareTo(aStr1) == 0,
            "if radix not valid then radix must be 10",
            "valueOf(sal_Int64, sal_Int32 radix): radix = -5"
            );

    return (bRes);
}

//------------------------------------------------------------------------
static sal_Bool SAL_CALL test_rtl_OUString_valueOf_Int64_defaultParam(
    hTestResult hRtlTestResult )
{    
    sal_Char     methName[MAXBUFLENGTH];
    sal_Char*    pMeth = methName;
    
    sal_Char*    newUChar1="15";
    sal_Char*    newUChar2="0";
    sal_Char*    newUChar3="-15";
    sal_Char*    newUChar4= "9223372036854775807";
    sal_Char*    newUChar5="-9223372036854775808";

    typedef struct TestCase
    {
        sal_Char*       comments;
        sal_Int64       input1;
        OUString*       expVal;
        ~TestCase()     {delete expVal;}
    }TestCase;

    TestCase arrTestCase[]=
    {
        {"input Int64 15 and return OUString 15",15,
         new OUString(newUChar1,2,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        },
        {"input Int64 0 and return OUString 0",0,
         new OUString(newUChar2,1,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        },
        {"input Int64 -15 and return OUString -15",-15,
         new OUString(newUChar3,3,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        },
        {"input Int64 9223372036854775807 and return 9223372036854775807",
         SAL_MAX_INT64 /* 9223372036854775807*/,
         new OUString(newUChar4,19,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        },
        {"input Int64 -9223372036854775808 and return -9223372036854775808",
         SAL_MIN_INT64 /* 9223372036854775808*/,
         new OUString(newUChar5,20,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)
        }
    };

    sal_Bool    res=sal_True;
    sal_uInt32   i;

    for(i=0;i<(sizeof(arrTestCase))/(sizeof(TestCase));i++)
    {
        sal_Bool lastRes=(*(arrTestCase[i].expVal)==
                          OUString::valueOf(arrTestCase[i].input1));

        c_rtl_tres_state(hRtlTestResult,
                         lastRes,
                         arrTestCase[i].comments,
                         createName( pMeth, 
                                     "valueOf( sal_Int64 i, sal_Int16 radix = 10 )", i )
                         );

        res &= lastRes;
    }
    
    return(res);

}
//------------------------------------------------------------------------
// testing the method valueOf( float f )
//------------------------------------------------------------------------
// LLA: sal_Bool SAL_CALL test_rtl_OUString_valueOf_float(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA:     sal_Char methName[MAXBUFLENGTH];
// LLA:     sal_Char* pMeth =methName;
// LLA: 
// LLA:     typedef struct TestCase
// LLA: 	{
// LLA:         sal_Char*                    comments;
// LLA:         float                         input1;
// LLA:         OUString*                     expVal;
// LLA: 
// LLA:         ~TestCase() {delete expVal;}
// LLA: 	} TestCase;
// LLA: 
// LLA: 	TestCase arrTestCase[] =
// LLA:     {
// LLA:         { "3.0", 3.0, new OUString("3.0",3,kEncodingRTLTextUSASCII,
// LLA:                                    kConvertFlagsOStringToOUString) },
// LLA:         { "3.5", 3.5f, new OUString("3.5",3,kEncodingRTLTextUSASCII,
// LLA:                                     kConvertFlagsOStringToOUString)},
// LLA:         { "3.0625", 3.0625f, new OUString("3.0625",6,kEncodingRTLTextUSASCII,
// LLA:                                           kConvertFlagsOStringToOUString)},
// LLA:         { "3.502525", 3.502525f, new OUString("3.502525",8,
// LLA:                                               kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString) },
// LLA:         { "3.141592", 3.141592f, new OUString("3.141592",8,
// LLA:                                               kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString) },
// LLA:         { "3.5025255", 3.5025255f, new OUString("3.5025255",9,
// LLA:                                                 kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString) },
// LLA:         { "3.0039062", 3.00390625f, new OUString("3.0039062",9,
// LLA:                                                  kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString) }
// LLA:     };
// LLA: 
// LLA:     sal_Bool res = sal_True;
// LLA:     sal_Int32 i;
// LLA: 
// LLA:     for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
// LLA:     {
// LLA:         ::rtl::OUString aStr1;
// LLA:         aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
// LLA:         sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
// LLA: 
// LLA:         c_rtl_tres_state
// LLA:             (
// LLA:                 hRtlTestResult,
// LLA:                 lastRes,
// LLA:                 arrTestCase[i].comments,
// LLA:                 createName( pMeth, "valueof_float", i)
// LLA:                 );
// LLA: 
// LLA:         res &= lastRes;
// LLA: 
// LLA:     }
// LLA: 
// LLA:     return ( res );
// LLA: }

//------------------------------------------------------------------------
// testing the method valueOf( float f ) for negative value
//------------------------------------------------------------------------
// LLA: sal_Bool SAL_CALL test_rtl_OUString_valueOf_Float_Negative(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA:     sal_Char methName[MAXBUFLENGTH];
// LLA:     sal_Char* pMeth =methName;
// LLA: 
// LLA:     typedef struct TestCase
// LLA: 	{
// LLA:         sal_Char*                    comments;
// LLA:         float                         input1;
// LLA:         OUString*                     expVal;
// LLA: 
// LLA:         ~TestCase() {delete expVal;}
// LLA: 	} TestCase;
// LLA: 
// LLA: 	TestCase arrTestCase[] =
// LLA:     {
// LLA:         { "-3.0", -3.0, new OUString("-3.0",4,kEncodingRTLTextUSASCII,
// LLA:                                      kConvertFlagsOStringToOUString) },
// LLA:         { "-3.5", -3.5f, new OUString("-3.5",4,kEncodingRTLTextUSASCII,
// LLA:                                       kConvertFlagsOStringToOUString)},
// LLA:         { "-3.0625", -3.0625f, new OUString("-3.0625",7,
// LLA:                                             kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString)},
// LLA:         { "-3.502525", -3.502525f, new OUString("-3.502525",9,
// LLA:                                                 kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString) },
// LLA:         { "-3.141592", -3.141592f, new OUString("-3.141592",9,
// LLA:                                                 kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString) },
// LLA:         { "-3.5025255", -3.5025255f, new OUString("-3.5025255",10,
// LLA:                                                   kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString) },
// LLA:         { "-3.0039062", -3.00390625f, new OUString("-3.0039062",10,
// LLA:                                                    kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString) }
// LLA:     };
// LLA: 
// LLA:     sal_Bool res = sal_True;
// LLA:     sal_Int32 i;
// LLA: 
// LLA:     for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
// LLA:     {
// LLA:         ::rtl::OUString aStr1;
// LLA:         aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
// LLA:         sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
// LLA: 
// LLA:         c_rtl_tres_state
// LLA:             (
// LLA:                 hRtlTestResult,
// LLA:                 lastRes,
// LLA:                 arrTestCase[i].comments,
// LLA:                 createName( pMeth, "valueof_negative float", i)
// LLA:                 );
// LLA: 
// LLA:         res &= lastRes;
// LLA: 
// LLA:     }
// LLA: 
// LLA:     return ( res );
// LLA: }

//------------------------------------------------------------------------
// testing the method valueOf( double f )
//------------------------------------------------------------------------
// LLA: sal_Bool SAL_CALL test_rtl_OUString_valueOf_double(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA:     sal_Char methName[MAXBUFLENGTH];
// LLA:     sal_Char* pMeth =methName;
// LLA: 
// LLA:     typedef struct TestCase
// LLA:     {
// LLA:         sal_Char*       comments;
// LLA:         double          input1;
// LLA:         OUString*       expVal;
// LLA: 
// LLA:         ~TestCase() {delete expVal;}
// LLA:     } TestCase;
// LLA: 
// LLA: 	TestCase arrTestCase[] =
// LLA:     {
// LLA:         {"3.0", 3.0, new OUString("3.0",3,kEncodingRTLTextUSASCII,
// LLA:                                   kConvertFlagsOStringToOUString)},
// LLA:         {"3.5", 3.5, new OUString("3.5",3,kEncodingRTLTextUSASCII,
// LLA:                                   kConvertFlagsOStringToOUString)},
// LLA:         {"3.0625", 3.0625, new OUString("3.0625",6,kEncodingRTLTextUSASCII,
// LLA:                                         kConvertFlagsOStringToOUString)},
// LLA:         {"3.1415926535", 3.1415926535, new OUString("3.1415926535",12,
// LLA:                                                     kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString)},
// LLA:         {"3.1415926535897931", 3.141592653589793, 
// LLA:          new OUString("3.1415926535897931",18,kEncodingRTLTextUSASCII,
// LLA:                       kConvertFlagsOStringToOUString)},
// LLA:         {"3.1415926535897931", 3.1415926535897932, 
// LLA:          new OUString("3.1415926535897931",18,kEncodingRTLTextUSASCII,
// LLA:                       kConvertFlagsOStringToOUString)},
// LLA:         {"3.1415926535897931", 3.14159265358979323, 
// LLA:          new OUString("3.1415926535897931",18,kEncodingRTLTextUSASCII,
// LLA:                       kConvertFlagsOStringToOUString)},
// LLA:         {"3.1415926535897931", 3.141592653589793238462643,
// LLA:          new OUString("3.1415926535897931",18,kEncodingRTLTextUSASCII,
// LLA:                       kConvertFlagsOStringToOUString)}
// LLA:     };
// LLA: 
// LLA:     sal_Bool res = sal_True;
// LLA:     sal_Int32 i;
// LLA: 
// LLA:     for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
// LLA:     {
// LLA:         ::rtl::OUString aStr1;
// LLA:         aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
// LLA:         sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
// LLA: 
// LLA:         c_rtl_tres_state
// LLA:             (
// LLA:                 hRtlTestResult,
// LLA:                 lastRes,
// LLA:                 arrTestCase[i].comments,
// LLA:                 createName( pMeth, "valueof_double", i)
// LLA:                 );
// LLA: 
// LLA:         res &= lastRes;
// LLA: 
// LLA:     }
// LLA: 
// LLA:     return ( res );
// LLA: }


//------------------------------------------------------------------------
// testing the method valueOf( double f ) for negative value
//------------------------------------------------------------------------
// LLA: sal_Bool SAL_CALL test_rtl_OUString_valueOf_Double_Negative(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA:     sal_Char methName[MAXBUFLENGTH];
// LLA:     sal_Char* pMeth =methName;
// LLA: 
// LLA:     typedef struct TestCase
// LLA: 	{
// LLA:         sal_Char*        comments;
// LLA:         double           input1;
// LLA:         OUString*        expVal;
// LLA: 
// LLA:         ~TestCase() {delete expVal;}
// LLA: 	} TestCase;
// LLA: 
// LLA: 	TestCase arrTestCase[] =
// LLA:     {
// LLA:         {"-3.0", -3.0, new OUString("-3.0",4,kEncodingRTLTextUSASCII,
// LLA:                                     kConvertFlagsOStringToOUString)},
// LLA:         {"-3.5", -3.5, new OUString("-3.5",4,kEncodingRTLTextUSASCII,
// LLA:                                     kConvertFlagsOStringToOUString)},
// LLA:         {"-3.0625", -3.0625, new OUString("-3.0625",7,kEncodingRTLTextUSASCII,
// LLA:                                           kConvertFlagsOStringToOUString)},
// LLA:         {"-3.1415926535", -3.1415926535, 
// LLA:          new OUString("-3.1415926535",13,kEncodingRTLTextUSASCII,
// LLA:                       kConvertFlagsOStringToOUString)},
// LLA:         {"-3.1415926535897931", -3.141592653589793, 
// LLA:          new OUString("-3.1415926535897931",19,kEncodingRTLTextUSASCII,
// LLA:                       kConvertFlagsOStringToOUString)},
// LLA:         {"-3.1415926535897931", -3.1415926535897932, 
// LLA:          new OUString("-3.1415926535897931",19,kEncodingRTLTextUSASCII,
// LLA:                       kConvertFlagsOStringToOUString)},
// LLA:         {"-3.1415926535897931", -3.14159265358979323, 
// LLA:          new OUString("-3.1415926535897931",19,kEncodingRTLTextUSASCII,
// LLA:                       kConvertFlagsOStringToOUString)},
// LLA:         {"-3.1415926535897931", -3.141592653589793238462643, 
// LLA:          new OUString("-3.1415926535897931",19,kEncodingRTLTextUSASCII,
// LLA:                       kConvertFlagsOStringToOUString)}
// LLA:     };
// LLA: 
// LLA:     sal_Bool res = sal_True;
// LLA:     sal_Int32 i;
// LLA: 
// LLA:     for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
// LLA:     {
// LLA:         ::rtl::OUString aStr1;
// LLA:         aStr1 = aStr1.valueOf( arrTestCase[i].input1 );
// LLA:         sal_Bool lastRes = (arrTestCase[i].expVal->compareTo(aStr1) == 0);
// LLA: 
// LLA:         c_rtl_tres_state
// LLA:             (
// LLA:                 hRtlTestResult,
// LLA:                 lastRes,
// LLA:                 arrTestCase[i].comments,
// LLA:                 createName( pMeth, "valueof_nagative double", i)
// LLA:                 );
// LLA: 
// LLA:         res &= lastRes;
// LLA: 
// LLA:     }
// LLA: 
// LLA:     return ( res );
// LLA: }

//------------------------------------------------------------------------
// testing the method valueOf()
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_valueOf(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "valueOf");
    sal_Bool bTState = test_rtl_OUString_valueOf_Int32( hRtlTestResult );
    bTState &= test_rtl_OUString_valueOf_Int32_Bounderies( hRtlTestResult );
    bTState &= test_rtl_OUString_valueOf_Int32_Negative( hRtlTestResult );
    bTState &= test_rtl_OUString_valueOf_Int32_WrongRadix( hRtlTestResult );
    bTState &= test_rtl_OUString_valueOf_Int32_defaultParam(
        hRtlTestResult );
    bTState &= test_rtl_OUString_valueOf_Int64( hRtlTestResult );
    bTState &= test_rtl_OUString_valueOf_Int64_Bounderies( hRtlTestResult );
    bTState &= test_rtl_OUString_valueOf_Int64_Negative( hRtlTestResult );
    bTState &= test_rtl_OUString_valueOf_Int64_WrongRadix( hRtlTestResult );
    bTState &= test_rtl_OUString_valueOf_Int64_defaultParam(
        hRtlTestResult );
    // LLA: bTState &= test_rtl_OUString_valueOf_float( hRtlTestResult );
    // LLA: bTState &= test_rtl_OUString_valueOf_Float_Negative( hRtlTestResult );

    // LLA: bTState &= test_rtl_OUString_valueOf_double( hRtlTestResult );
    // LLA: bTState &= test_rtl_OUString_valueOf_Double_Negative( hRtlTestResult );
    c_rtl_tres_state_end( hRtlTestResult, "valueOf");
//    return ( bTState );
}
//------------------------------------------------------------------------
//    this is my testing code 
//    testing the method createFromAscii( const sal_Char * value )
//------------------------------------------------------------------------

extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_createFromAscii(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "createFromAscii");
    sal_Char     methName[MAXBUFLENGTH];
    sal_Char*    pMeth = methName;
    
    
    typedef struct TestCase
    {
        sal_Char*       comments;
        const sal_Char*  input1;
        OUString*       expVal;
        ~TestCase()     {delete expVal;}

    }TestCase;

    TestCase arrTestCase[]=
    {
                            
        {   "create OUString from sal_Char" ,kTestStr1,
            new OUString(kTestStr1,kTestStr1Len,kEncodingRTLTextUSASCII,
                         kConvertFlagsOStringToOUString)
        },
        {
            "create OUString from empty", "",
            new OUString()
        },
        {
            "create OUString from empty(string arg = '\\0')","",
            new OUString("",0,kEncodingRTLTextUSASCII,
                         kConvertFlagsOStringToOUString)
        }
       
    };
    
    sal_Bool    res;
    sal_uInt32   i;
 
    for(i=0;i<(sizeof(arrTestCase))/(sizeof(TestCase));i++)
    {
        sal_Bool lastRes=(*(arrTestCase[i].expVal)==
                          OUString::createFromAscii(arrTestCase[i].input1));
        
        
    {
        c_rtl_tres_state(hRtlTestResult,
                         lastRes,
                         arrTestCase[i].comments,
                         createName( pMeth, "createFromAscii", i )
                         );
    }
        
    res&=lastRes;

    }
    
    c_rtl_tres_state_end( hRtlTestResult, "createFromAscii");
//    return(res);
}
//------------------------------------------------------------------------
// testing the method index(  )
//------------------------------------------------------------------------
template <class T>
sal_Bool test_index( const T* input1, int num,const sal_Int32* input2,
                     const sal_Int32* expVal,int base,rtlTestResult hRtlTestResult)
{
	sal_Bool    res=sal_True;
	sal_Char    methName[MAXBUFLENGTH];
	sal_Char    *meth = '\0';
	sal_Char*   pMeth=methName;
	sal_Int32   i;
    sal_Bool    lastRes=sal_False;
	
	for(i=0;i<num;i++)
	{
		OUString str(aUStr2);
		
        if(base==0)
		{
            lastRes=(str.indexOf(input1[i])==expVal[i]);
            meth="indexOf_001";
        }
		if(base==1)
		{	
            lastRes=(str.indexOf(input1[i],input2[i])==expVal[i]);
            meth="indexOf_002";
        }
// LLA: 		if(base==2)
// LLA: 		{
// LLA:             lastRes=(str.lastIndexOf(input1[i])==expVal[i]);
// LLA:             meth="lastIndexOf_001(sal_Unicode)";
// LLA:         }
// LLA: 		if(base==3)
// LLA: 		{
// LLA: /*
// LLA:             OUString s4(&input1[i]);
// LLA:             rtl::OString sStr;
// LLA:             sStr <<= str;
// LLA:             t_print("str = %s\n", sStr.getStr());
// LLA:             rtl::OString sInput1;
// LLA:             sInput1 <<= s4; // rtl::OUString((sal_Unicode*)input1[i]);
// LLA:             t_print("%d = lastIndexOf(\"%s\", %d) =? %d\n", str.lastIndexOf(input1[i], input2[i]), sInput1.getStr(), input2[i], expVal[i]);
// LLA: */            
// LLA:             lastRes=(str.lastIndexOf(input1[i],input2[i])==expVal[i]);
// LLA:             meth="lastIndexOf_002(sal_Unicode , sal_Int32 )";
// LLA:         }	
        	
        c_rtl_tres_state
        	(
                hRtlTestResult,
                lastRes,
           		"index",
                createName( pMeth,meth, i )
                );

        res &= lastRes;
    }

    return( res );
}
template <class T>
sal_Bool test_indexStr( const T** input1, int num,const sal_Int32* input2,
                        const sal_Int32* expVal,int base,rtlTestResult hRtlTestResult)
{
	sal_Bool    res=sal_True;
	sal_Char    methName[MAXBUFLENGTH];
	sal_Char    *meth = '\0';
	sal_Char*   pMeth=methName;
	sal_Int32   i;
    sal_Bool    lastRes=sal_False;
	
	for(i=0;i<num;i++)
	{
		OUString str(aUStr2);
		

		if(base==0)
		{
            OUString s1(input1[i]);
            lastRes=(str.indexOf(s1)==expVal[i]);
            meth="indexOf_003";
        }
		if(base==1)
		{	
            OUString s2(input1[i]);
            lastRes=(str.indexOf(s2,input2[i])==expVal[i]);
            meth="indexOf_004";
        }
// LLA: 		if(base==2)
// LLA: 		{
// LLA:             OUString s3(input1[i]);
// LLA:             lastRes=(str.lastIndexOf(s3)==expVal[i]);
// LLA:             meth="lastIndexOf_003(const OUString)";
// LLA:         }
// LLA: 		if(base==3)
// LLA: 		{
// LLA:             OUString s4(input1[i]);
// LLA: 
// LLA:             rtl::OString sStr;
// LLA:             sStr <<= str;
// LLA:             t_print("str = \"%s\"\n", sStr.getStr());
// LLA:             rtl::OString sInput1;
// LLA:             sInput1 <<= s4; // rtl::OUString((sal_Unicode*)input1[i]);
// LLA:             t_print("%d = lastIndexOf(\"%s\", %d) =? %d\n", str.lastIndexOf(input1[i], input2[i]), sInput1.getStr(), input2[i], expVal[i]);
// LLA:             
// LLA:             lastRes=(str.lastIndexOf(s4,input2[i])==expVal[i]);
// LLA:             meth="lastIndexOf_004(const OUString,sal_Int32)";
// LLA:         }	
        	
        c_rtl_tres_state
        	(
                hRtlTestResult,
                lastRes,
           		"index",
                createName( pMeth,meth, i )
                );

        res &= lastRes;
    }

    return( res );
}
//------------------------------------------------------------------------
// testing the method indexOf(  )
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_indexOf_001(
    hTestResult hRtlTestResult )
{
	sal_Bool bRes=sal_False;
	
	bRes=c_rtl_tres_state
        (
	      	hRtlTestResult,
	      	test_index<sal_Unicode>((const sal_Unicode*)input1Default,
                                    nDefaultCount,input2Default,
                                    expValDefault,0,hRtlTestResult),
	      	"index",
	      	"indexDefault(sal_Unicode ch, sal_Int32 fromIndex = 0)"
	      	);
	      	
    return ( bRes );
}
//------------------------------------------------------------------------
// testing the method indexOf(  )
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_indexOf_002(
    hTestResult hRtlTestResult )
{
	sal_Bool bRes=sal_False;
	
	bRes=c_rtl_tres_state
        (
	      	hRtlTestResult,
	      	test_index<sal_Unicode>((const sal_Unicode*)input1Normal,
                                    nNormalCount,input2Normal,
                                    expValNormal,1,hRtlTestResult),
	      	"index",
	      	"indexNormal(sal_Unicode ch, sal_Int32 fromIndex)"
	      	);
	      	
    return ( bRes );
}		
//------------------------------------------------------------------------
// testing the method indexOf(  OUString ch, sal_Int32 fromIndex = 0 )
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_indexOf_003(
    hTestResult hRtlTestResult )
{
	sal_Bool bRes=sal_False;
	
	bRes=c_rtl_tres_state
        (
	      	hRtlTestResult,
	      	test_indexStr<sal_Unicode>((const sal_Unicode**)input1StrDefault,
                                       nStrDefaultCount,input2StrDefault,
                                       expValStrDefault,0,hRtlTestResult),
	      	"index",
	      	"indexDefault(OUString ch, sal_Int32 fromIndex = 0)"
	      	);
	      	
    return ( bRes );
}
//------------------------------------------------------------------------
// testing the method indexOf(  OUString ch, sal_Int32 fromIndex )
//------------------------------------------------------------------------
sal_Bool SAL_CALL test_rtl_OUString_indexOf_004(
    hTestResult hRtlTestResult )
{
	sal_Bool bRes=sal_False;
	
	bRes=c_rtl_tres_state
        (
	      	hRtlTestResult,
	      	test_indexStr<sal_Unicode>((const sal_Unicode**)input1StrNormal,
                                       nStrNormalCount,input2StrNormal,
                                       expValStrNormal,1,hRtlTestResult),
	      	"indexOf",
	      	"indexOf(OUString ch, sal_Int32 fromIndex)"
	      	);
	      	
    return ( bRes );
}		
// LLA: //------------------------------------------------------------------------
// LLA: // testing the method lastIndexOf( sal_Unicode ch )
// LLA: //------------------------------------------------------------------------
// LLA: sal_Bool SAL_CALL test_rtl_OUString_lastIndexOf_001(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA: 	sal_Bool bRes=sal_False;
// LLA: 	
// LLA: 	bRes=c_rtl_tres_state
// LLA:         (
// LLA: 	      	hRtlTestResult,
// LLA: 	      	test_index<sal_Unicode>((const sal_Unicode*)input1lastDefault,
// LLA:                                     nlastDefaultCount,input2lastDefault,
// LLA:                                     expVallastDefault,2,hRtlTestResult),
// LLA: 	      	"lastIndex",
// LLA: 	      	"lastIndexDefault(sal_Unicode ch)"
// LLA: 	      	);
// LLA: 	      	
// LLA:     return ( bRes );
// LLA: }
// LLA: //------------------------------------------------------------------------
// LLA: // testing the method lastIndexOf(  sal_Unicode ch, sal_Int32 fromIndex )
// LLA: //------------------------------------------------------------------------
// LLA: sal_Bool SAL_CALL test_rtl_OUString_lastIndexOf_002(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA: 	sal_Bool bRes=sal_False;
// LLA: 	
// LLA: 	bRes=c_rtl_tres_state
// LLA:         (
// LLA: 	      	hRtlTestResult,
// LLA: 	      	test_index<sal_Unicode>((const sal_Unicode*)input1lastNormal,
// LLA:                                     nlastNormalCount,input2lastNormal,
// LLA:                                     expVallastNormal,3,hRtlTestResult),
// LLA: 	      	"lastIndex",
// LLA: 	      	"lastIndexNormal(sal_Unicode ch, sal_Int32 fromIndex)"
// LLA: 	      	);
// LLA: 	      	
// LLA:     return ( bRes );
// LLA: }
// LLA: //------------------------------------------------------------------------
// LLA: // testing the method lastIndexOf(  OUString ch )
// LLA: //------------------------------------------------------------------------
// LLA: sal_Bool SAL_CALL test_rtl_OUString_lastIndexOf_003(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA: 	sal_Bool bRes=sal_False;
// LLA: 	
// LLA: 	bRes=c_rtl_tres_state
// LLA:         (
// LLA: 	      	hRtlTestResult,
// LLA: 	      	test_indexStr<sal_Unicode>((const sal_Unicode**)input1StrLastDefault,
// LLA:                                        nStrLastDefaultCount,input2StrLastDefault,
// LLA:                                        expValStrLastDefault,2,hRtlTestResult),
// LLA: 	      	"lastIndexOf",
// LLA: 	      	"lastIndexOf(OUString ch)"
// LLA: 	      	);
// LLA: 	      	
// LLA:     return ( bRes );
// LLA: }
// LLA: //------------------------------------------------------------------------
// LLA: // testing the method lastIndexOf(  OUString ch, sal_Int32 fromIndex )
// LLA: //------------------------------------------------------------------------
// LLA: sal_Bool SAL_CALL test_rtl_OUString_lastIndexOf_004(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA: 	sal_Bool bRes=sal_False;
// LLA: 	
// LLA:     for (int i=0;i<nStrLastNormalCount;i++)
// LLA:     {
// LLA:         rtl::OUString aStr = rtl::OUString(input1StrLastNormal[i]);
// LLA:         volatile int dummy = 0;
// LLA:     }
// LLA:     
// LLA: 	bRes=c_rtl_tres_state
// LLA:         (
// LLA: 	      	hRtlTestResult,
// LLA: 	      	test_indexStr<sal_Unicode>((const sal_Unicode**)input1StrLastNormal,
// LLA:                                        nStrLastNormalCount,input2StrLastNormal,
// LLA:                                        expValStrLastNormal,3,hRtlTestResult),
// LLA: 	      	"lastIndexOf",
// LLA: 	      	"lastIndexOf(OUString ch, sal_Int32 fromIndex)"
// LLA: 	      	);
// LLA: 	      	
// LLA:     return ( bRes );
// LLA: }
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_indexOf(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "indexOf");
    sal_Bool res = test_rtl_OUString_indexOf_001(hRtlTestResult);
    res &= test_rtl_OUString_indexOf_002(hRtlTestResult);    
    res &= test_rtl_OUString_indexOf_003(hRtlTestResult);
    res &= test_rtl_OUString_indexOf_004(hRtlTestResult);
    c_rtl_tres_state_end( hRtlTestResult, "indexOf");   
//    return ( res );
}
//------------------------------------------------------------------------
// LLA: extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_lastIndexOf(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA:     c_rtl_tres_state_start( hRtlTestResult, "lastIndexOf");
// LLA:     sal_Bool res = test_rtl_OUString_lastIndexOf_001(hRtlTestResult);
// LLA:     res &= test_rtl_OUString_lastIndexOf_002(hRtlTestResult);
// LLA:     res &= test_rtl_OUString_lastIndexOf_003(hRtlTestResult);
// LLA:     res &= test_rtl_OUString_lastIndexOf_004(hRtlTestResult);
// LLA:     c_rtl_tres_state_end( hRtlTestResult, "lastIndexOf");
// LLA: //    return ( res );
// LLA: }
//------------------------------------------------------------------------
// testing the method concat( const OString & aStr )
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_concat(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "concat");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth =methName;

    typedef struct TestCase
    {
        sal_Char*                    comments;
        OUString*                     expVal;
        OUString*                     input1;
        OUString*                     input2;
        ~TestCase() { delete input1;delete input2; delete expVal;}
    } TestCase;

    TestCase arrTestCase[] =
    {
        {"concatenates two ustrings",new OUString(aUStr1),
         new OUString(aUStr7), new OUString(aUStr8)},
        {"concatenates empty ustring",new OUString(aUStr1),
         new OUString(aUStr1), new OUString("",0,
                                            kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString)},
        {"concatenates to empty ustring",new OUString(aUStr1),new OUString("",
                                                                           0,kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),
         new OUString(aUStr1)},
        {"concatenates two empty ustrings",new OUString("",0,
                                                        kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),
         new OUString("",0,
                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString), 
         new OUString("",0,
                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString)},
        {"concatenates ustring constructed by default constructor",
         new OUString(aUStr1),new OUString(aUStr1), new OUString()},
        {"concatenates to ustring constructed by default constructor",
         new OUString(aUStr1),new OUString(), new OUString(aUStr1)},
        {"concatenates two ustrings constructed by default constructor",
         new OUString(),new OUString(), new OUString()}
    };

    sal_Bool res = sal_True;
    sal_uInt32 i;
    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        OUString str = arrTestCase[i].input1->concat(*arrTestCase[i].input2);
        sal_Bool lastRes = (str == *arrTestCase[i].expVal);

        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "concat", i)
                );

        res &= lastRes;

    }
    c_rtl_tres_state_end( hRtlTestResult, "concat");
//    return ( res );
}
//------------------------------------------------------------------------
// testing the method replaceAt( sal_Int32 index, sal_Int32 count,
// const OUString& newStr )
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_replaceAt(
    rtlTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "replaceAt");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

    typedef struct TestCase
    {
        sal_Char*                    comments;
        OUString*                    expVal;
        OUString*                    input;
        OUString*                    newStr;
        sal_Int32                    index;
        sal_Int32                    count;

        ~TestCase() { delete input; delete expVal; delete newStr;}
    } TestCase;

    TestCase arrTestCase[]=
    {

        { "string differs", new OUString(aUStr2), new OUString(aUStr22),
          new OUString(aUStr2), 0, kTestStr22Len },

        { "larger index", new OUString(aUStr1), new OUString(aUStr7),
          new OUString(aUStr8), 64, kTestStr8Len },

        { "larger count", new OUString(aUStr2), new OUString(aUStr22),
          new OUString(aUStr2),0, 64 },

        { "navigate index", new OUString(aUStr2), new OUString(aUStr22),
          new OUString(aUStr2), -64, 64 },

        { "null ustring", 
          new OUString("",0,
                       kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),
          new OUString(aUStr14),
          new OUString("",0,
                       kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString), 
          0, kTestStr14Len }
    };

	sal_Bool res = sal_True;
	sal_uInt32 i;

    for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        ::rtl::OUString aStr1;
        aStr1 = arrTestCase[i].input->replaceAt( arrTestCase[i].index,
                                                 arrTestCase[i].count, *arrTestCase[i].newStr );

        sal_Bool lastRes = ( arrTestCase[i].expVal->compareTo(aStr1) == 0 );

        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "replaceAt", i )

                );
        res &= lastRes;
    }

    c_rtl_tres_state_end( hRtlTestResult, "replaceAt");
//     return ( res );
}
//------------------------------------------------------------------------
// this is my testing code
// testing the method replace( sal_Unicode oldChar, sal_Unicode newChar )
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_replace(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "replace");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

    typedef struct TestCase
    {
        sal_Char*                    comments;
        OUString*                    expVal;
        OUString*                    input;
        sal_Unicode                  oldChar;
        sal_Unicode                  newChar;

        ~TestCase() { delete input; delete expVal;}
    } TestCase;

    TestCase arrTestCase[]=
    {
        {"ustring differs", new OUString(aUStr18), new OUString(aUStr4),83,115},
        {"ustring differs", new OUString(aUStr19), new OUString(aUStr17),32,45},
        {"ustring must be empty", new OUString("",0,
                                               kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),
         new OUString("",0,
                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),83,23},
        {"ustring must be empty", new OUString(),
         new OUString("",0,
                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),83,23},
        {"same ustring, no replace ", new OUString(aUStr22), 
         new OUString(aUStr22),42,56}
    };


    sal_Bool res = sal_True;
    sal_uInt32 i;

    for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        ::rtl::OUString aStr1;
        aStr1= arrTestCase[i].input->replace(arrTestCase[i].oldChar,arrTestCase[i].newChar);
        res &= c_rtl_tres_state
            (
                hRtlTestResult,
                (arrTestCase[i].expVal->compareTo(aStr1) == 0),
                arrTestCase[i].comments,
                createName( pMeth, "replace", i )

                );
    }
    c_rtl_tres_state_end( hRtlTestResult, "replace");
//     return ( res );
}
//------------------------------------------------------------------------
// testing the method toAsciiLowerCase()
//-----------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_toAsciiLowerCase(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "toAsciiLowerCase");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth =methName;

    typedef struct TestCase
    {
        sal_Char*                    comments;
        OUString*                     expVal;
        OUString*                     input1;
        ~TestCase() { delete input1; delete expVal;}
    } TestCase;

    TestCase arrTestCase[] =
    {

        {"only uppercase",new OUString(aUStr5),new OUString(aUStr4)},
        {"different cases",new OUString(aUStr5),new OUString(aUStr1)},
        {"different cases",new OUString(aUStr5),new OUString(aUStr3)},
        {"only lowercase",new OUString(aUStr5),new OUString(aUStr5)},
        {"empty ustring",new OUString("",0,
                                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),
         new OUString("",0,
                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString)},
        {"ustring constructed by default constructor",new OUString(),
         new OUString()},
        {"have special Unicode",new OUString("\23\12\34sun\13\45",6,
                                             kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),
         new OUString("\23\12\34sun\13\45",6,
                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString)}
    };

    sal_Bool res = sal_True;
    sal_uInt32 i;
    sal_Bool lastRes=sal_False;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        OUString str = arrTestCase[i].input1->toAsciiLowerCase();
        if(i<=5)
        {
            lastRes = (str ==* arrTestCase[i].expVal);

            c_rtl_tres_state
                (
                    hRtlTestResult,
                    lastRes,
                    arrTestCase[i].comments,
                    createName( pMeth, "toAsciiLowerCase", i)
                    );
        }
        else
        {
            c_rtl_tres_state
                (
                    hRtlTestResult,
                    sal_True,
                    arrTestCase[i].comments,
                    createName( pMeth, "toAsciiLowerCase", i)
                    );
        }
        res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "toAsciiLowerCase");
//    return ( res );
} 
//------------------------------------------------------------------------
// testing the method toAsciiUpperCase()
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_toAsciiUpperCase(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "toAsciiUpperCase");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth =methName;

    typedef struct TestCase
    {
        sal_Char*                    comments;
        OUString*                    expVal;
        OUString*                    input1;
        ~TestCase() { delete input1; delete expVal;}
    } TestCase;

	TestCase arrTestCase[] =
    {
        {"only lowercase",new OUString(aUStr4),new OUString(aUStr5)},
        {"mixed cases",new OUString(aUStr4),new OUString(aUStr3)},
        {"mixed cases",new OUString(aUStr4),new OUString(aUStr1)},
        {"only uppercase",new OUString(aUStr4),new OUString(aUStr4)},
        {"empty ustring",new OUString("",0,
                                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),
         new OUString("",0,
                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString)},
        {"ustring constructed by default constructor",new OUString(),
         new OUString()},
        {"have special Unicode",new OUString("\23\12\34SUN\13\45",6,
                                             kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString),
         new OUString("\23\12\34sun\13\45",6,
                      kEncodingRTLTextUSASCII,kConvertFlagsOStringToOUString)}
    };

    sal_Bool res = sal_True;
    sal_uInt32 i;
    sal_Bool lastRes=sal_False;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        OUString str = arrTestCase[i].input1->toAsciiUpperCase();
        if(i<=5)
        { 
            lastRes = (str == *arrTestCase[i].expVal);

            c_rtl_tres_state
                (
                    hRtlTestResult,
                    lastRes,
                    arrTestCase[i].comments,
                    createName( pMeth, "toAsciiUpperCase", i)
                    );
        }
        else
        {
            c_rtl_tres_state
                (
                    hRtlTestResult,
                    sal_True,
                    arrTestCase[i].comments,
                    createName( pMeth, "toAsciiUpperCase", i)
                    );
        }

        res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "toAsciiUpperCase");
//    return ( res );
}
 
//------------------------------------------------------------------------ 
// testing the method trim()
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_trim(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "trim");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth =methName;

    typedef struct TestCase
    {
        sal_Char*                    comments;
        OUString*                    expVal;
        OUString*                    input1;
        ~TestCase() { delete input1; delete expVal;}
    } TestCase;

    TestCase arrTestCase[] =
    {
        {"removes space from the front",new OUString(aUStr1),
         new OUString(aUStr10)},
        {"removes space from the end",new OUString(aUStr1),
         new OUString(aUStr11)},
        {"removes space from the front and end",new OUString(aUStr1),
         new OUString(aUStr12)},
        {"removes several spaces from the end",new OUString(aUStr1),
         new OUString(aUStr13)},
        {"removes several spaces from the front",new OUString(aUStr1),
         new OUString(aUStr14)},
        {"removes several spaces from the front and one from the end",
         new OUString(aUStr1),
         new OUString(aUStr15)},
        {"removes one space from the front and several from the end",
         new OUString(aUStr1),
         new OUString(aUStr16)},
        {"removes several spaces from the front and end",
         new OUString(aUStr1),
         new OUString(aUStr17)}, 
        {"removes characters that have codes <= 32",new OUString(aUStr30),
         new OUString("\1\3\5\7\11\13\15\17sun\21\23\25\27\31\33\50",
                      18,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)},
        {"removes characters that have codes <= 32",new OUString(aUStr28),
         new OUString("\50\3\5\7\11\13\15\17sun\21\23\25\27\31\33\1",
                      18,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)},
        {"removes characters that have codes <= 32",new OUString(aUStr29),
         new OUString("\50\3\5\7\11\13\15\17sun\21\23\25\27\31\33\50",
                      18,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)},
        {"removes characters that have codes <= 32",new OUString(aUStr20),
         new OUString("\1\3\5\7\11\13\15\17sun\21\23\25\27\31\23\20",
                      18,kEncodingRTLTextUSASCII,
                      kConvertFlagsOStringToOUString)},
        {"no spaces",new OUString(aUStr8),
         new OUString(aUStr8)}
    };

    sal_Bool res = sal_True;
    sal_uInt32 i;

    for(i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        OUString strRes = arrTestCase[i].input1->trim();
        sal_Bool lastRes = (strRes == *arrTestCase[i].expVal);

        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "trim", i)
                );

        res &= lastRes;

    }
    c_rtl_tres_state_end( hRtlTestResult, "trim");
//    return ( res );
}
//------------------------------------------------------------------------ 
//    testing the method toData()
//------------------------------------------------------------------------
                                              
template <class T>
sal_Bool test_toData( const char** input, int num, sal_Int16 radix,
                      const T* expVal,int base,
                      const T* _fPrecision,
                      rtlTestResult hRtlTestResult)
{
    (void)_fPrecision;
	sal_Bool    res=sal_True;
	sal_Char    methName[MAXBUFLENGTH];
	sal_Char    *meth = '\0';
	sal_Char*   pMeth=methName;
	sal_Int32   i;
// 	static      sal_Unicode aUchar[60]={0x00};
	T           intRes;
    sal_Bool    lastRes=sal_False;
	
	for(i=0;i<num;i++)
	{
        OSL_ENSURE( i < 60, "ERROR: leave aUchar bound");

// LLA: stored for the posterity
//      AStringToUStringCopy(aUchar,input[i]);
// 		OUString str(aUchar);
		
        OUString str;
        str = OUString::createFromAscii(input[i]);


        if(base==0)
		{
            intRes=static_cast<T>(str.toInt32());
            lastRes=(intRes==expVal[i]);
            meth="toInt32default";
        }
		if(base==1)
		{	
            intRes=static_cast<T>(str.toInt32(radix));
            lastRes=(intRes==expVal[i]);
            meth="toInt32normal";
        }
		if(base==2)
		{
            intRes=static_cast<T>(str.toInt64());
            lastRes=(intRes==expVal[i]);
            meth="toInt64default";
        }
		if(base==3)
		{
            intRes=static_cast<T>(str.toInt64(radix));
            lastRes=(intRes==expVal[i]);
            meth="toInt64normal";
        }
// LLA: does no longer exist, moved to rtl/oustring
// LLA: 		if(base==4)
// LLA: 		{
// LLA:             intRes=str.toDouble();
// LLA:             lastRes=(fabs(intRes-expVal[i])<=1e-35);
// LLA:             meth="toDouble";
// LLA:         }

// LLA: dt:20040802 create compile problems within wntmsci10
//		if(base==5) 
//		{	
//            intRes=str.toFloat();
//            T nPrec = _fPrecision[i];
//            lastRes=(fabs((T)(intRes-expVal[i])) <= nPrec /* 1e-35 */ );
//            meth="toFloat";
//        }
		if(base==6)
		{
            intRes=str.toChar();
            lastRes=(intRes==expVal[i]);
            meth="toChar";
        }		
			
		char buf[MAXBUFLENGTH];
        buf[0] = '\'';
        cpynstr( buf + 1, input[i], MAXBUFLENGTH );
        int length = AStringLen( input[i] );
        buf[length + 1] = '\'';
        buf[length + 2] = 0;
        	
        c_rtl_tres_state
        	(
                hRtlTestResult,
                lastRes,
                buf,
                createName( pMeth,meth, i )
                );

        res &= lastRes;
    }

    return( res );
}
//------------------------------------------------------------------------
//    testing the method toDouble()
//------------------------------------------------------------------------

// LLA: extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_toDouble(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA:     c_rtl_tres_state_start( hRtlTestResult, "toDouble");
// LLA: 	sal_Bool bRes=sal_False;
// LLA: 	
// LLA: 	bRes=c_rtl_tres_state
// LLA:         (
// LLA: 	      	hRtlTestResult,
// LLA: 	      	test_toData<double>((const char**)inputDouble,nDoubleCount,10,
// LLA:                                 expValDouble,4,hRtlTestResult),
// LLA: 	      	"toDouble",
// LLA: 	      	"toDouble()"
// LLA: 	      	);
// LLA: 	c_rtl_tres_state_end( hRtlTestResult, "toDouble");      	
// LLA: //	 return ( bRes );
// LLA: }		

//------------------------------------------------------------------------
//    testing the method toFloat()
//------------------------------------------------------------------------
// LLA: dt:20040802 the test_toData() has compile problems.
// LLA: extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_toFloat(
// LLA:     hTestResult hRtlTestResult )
// LLA: {
// LLA:     c_rtl_tres_state_start( hRtlTestResult, "toFloat");
// LLA: 	sal_Bool bRes=sal_False;
// LLA: 	
// LLA: 	bRes=c_rtl_tres_state
// LLA:         (
// LLA: 	      	hRtlTestResult,
// LLA: 	      	test_toData<float>((const char**)inputFloat,
// LLA:                                nFloatCount,
// LLA:                                10, /* radix */
// LLA:                                expValFloat,
// LLA:                                5,  /* float */
// LLA:                                fPrecision,
// LLA:                                hRtlTestResult),
// LLA: 	      	"toFloat",
// LLA: 	      	"toFloat()"
// LLA: 	      	);
// LLA: 	      	
// LLA:     c_rtl_tres_state_end( hRtlTestResult, "toFloat");
// LLA: //	 return ( bRes ); 
// LLA: 		
// LLA: } 
//------------------------------------------------------------------------
//    testing the method toChar()
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_toChar(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "toChar");
	sal_Bool bRes=sal_False;
	
	bRes=c_rtl_tres_state
        (
	      	hRtlTestResult,
	      	test_toData<sal_Unicode>((const char**)inputChar,nCharCount,
                                     10,expValChar,6,NULL,hRtlTestResult),
	      	"toChar",
	      	"toChar()"
	      	);
	      	
    c_rtl_tres_state_end( hRtlTestResult, "toChar");
//	 return ( bRes ); 
		
} 
//------------------------------------------------------------------------
//    testing the method toBoolean()
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_toBoolean(
    hTestResult hRtlTestResult)
{
    c_rtl_tres_state_start( hRtlTestResult, "toBoolean");
    sal_Char methName[MAXBUFLENGTH];
    sal_Char* pMeth = methName;

    typedef struct TestCase
    {
        sal_Char*          comments;
        sal_Bool           expVal;
        OUString*          input;

        ~TestCase()      {delete input;}
    }TestCase;

    TestCase arrTestCase[]={

        {"expected true", sal_True, new OUString("True",4,kEncodingRTLTextUSASCII,
                                                 kConvertFlagsOStringToOUString)},
        {"expected false", sal_False, new OUString("False",5,
                                                   kEncodingRTLTextUSASCII,
                                                   kConvertFlagsOStringToOUString)},
        {"expected true", sal_True, new OUString("1",1,kEncodingRTLTextUSASCII,
                                                 kConvertFlagsOStringToOUString)}
    };

    sal_Bool res = sal_True;
    sal_uInt32 i;

    for (i = 0; i < (sizeof (arrTestCase))/(sizeof (TestCase)); i++)
    {
        sal_Bool bRes = arrTestCase[i].input->toBoolean();
        sal_Bool lastRes = (bRes == arrTestCase[i].expVal);
        c_rtl_tres_state
            (
                hRtlTestResult,
                lastRes,
                arrTestCase[i].comments,
                createName( pMeth, "toBoolean", i )

                );
        res &= lastRes;
    }
    c_rtl_tres_state_end( hRtlTestResult, "toBoolean");
//     return ( res );
}
//------------------------------------------------------------------------
//    testing the method toInt32()
//------------------------------------------------------------------------

sal_Bool SAL_CALL test_rtl_OUString_toInt32_normal(
    hTestResult hRtlTestResult )
{
    sal_Int32 expValues[kBase36NumsCount];
    sal_Int32 i;

    for ( i = 0; i < kBase36NumsCount; i++ )
        expValues[i] = i;

    sal_Bool res = c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kBinaryNumsStr,kBinaryNumsCount, 
                                    kRadixBinary,expValues,1,NULL,hRtlTestResult ),
            "kBinaryNumsStr",
            "toInt32( radix 2 )"
            );
    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kBinaryMaxNumsStr,kInt32MaxNumsCount, 
                                    kRadixBinary,kInt32MaxNums,1,NULL,hRtlTestResult ),
            "kBinaryMaxNumsStr",
            "toInt32_Boundaries( radix 2 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kOctolNumsStr,kOctolNumsCount, 
                                    kRadixOctol,expValues,1,NULL,hRtlTestResult ),
            "kOctolNumsStr",
            "toInt32( radix 8 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kOctolMaxNumsStr,kInt32MaxNumsCount, 
                                    kRadixOctol,(sal_Int32*)kInt32MaxNums,1,NULL,hRtlTestResult ),
            "kOctolMaxNumsStr",
            "toInt32_Boundaries( radix 8 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kDecimalNumsStr,kDecimalNumsCount,
                                    kRadixDecimal,expValues,1,NULL,hRtlTestResult ),
            "kDecimalNumsStr",
            "toInt32( radix 10 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kDecimalMaxNumsStr,kInt32MaxNumsCount, 
                                    kRadixDecimal,(sal_Int32*)kInt32MaxNums,1,NULL,hRtlTestResult ),
            "kDecimalMaxNumsStr",
            "toInt32_Boundaries( radix 10 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kHexDecimalNumsStr,kHexDecimalNumsCount,
                                    kRadixHexdecimal,expValues,1,NULL,hRtlTestResult ),
            "kHexDecimalNumsStr",
            "toInt32( radix 16 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>(  kHexDecimalMaxNumsStr,kInt32MaxNumsCount,
                                     kRadixHexdecimal,(sal_Int32*)kInt32MaxNums,1,NULL,hRtlTestResult ),
            "kHexDecimalMaxNumsStr",
            "toInt32_Boundaries( radix 16 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>(  kBase36NumsStr,kBase36NumsCount,
                                     kRadixBase36, expValues,1,NULL,hRtlTestResult ),
            "kBase36NumsStr",
            "toInt32( radix 36 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kBase36MaxNumsStr,kInt32MaxNumsCount,
                                    kRadixBase36,(sal_Int32*)kInt32MaxNums,1,NULL,hRtlTestResult ),
            "kBase36MaxNumsStr",
            "toInt32_Boundaries( radix 36 )"
            );

    const sal_Int16 nSpecCases = 5;
    static const sal_Char *spString[nSpecCases] =
    {
        "-1",
        "+1",
        " 1",
        " -1",
        "001"
    };

    sal_Int32 expSpecVal[nSpecCases] =
    {
        -1,
        1,
        1,
        -1,
        1
    };

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( spString,nSpecCases,
                                    kRadixDecimal,expSpecVal,1,NULL,hRtlTestResult ),
            "special cases",
            "toInt32( specialcases )"
            );

    return ( res );
}
sal_Bool SAL_CALL test_rtl_OUString_toInt32_wrongRadix(
    hTestResult hRtlTestResult )
{
    ::rtl::OUString str("0",1,kEncodingRTLTextUSASCII,
                        kConvertFlagsOStringToOUString);

    sal_Int32 iRes =str.toInt32(-1);

    return
        (
            c_rtl_tres_state
            (
                hRtlTestResult,
                iRes == 0,
                "wrong radix -1",
                "toInt32( 0, wrong radix -1 )"
                )
            );
}
sal_Bool SAL_CALL test_rtl_OUString_toInt32_defaultParam(
    hTestResult hRtlTestResult )
{
    sal_Int32 expValues[kBase36NumsCount];
    sal_Int32 i;

    for ( i = 0; i < kBase36NumsCount; i++ )
        expValues[i] = i;

    sal_Bool res = c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kDecimalNumsStr,kDecimalNumsCount,
                                    kRadixDecimal,expValues,0,NULL,hRtlTestResult ),
            "kBinaryNumsStr",
            "toInt32( radix 2 )"
            );
    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( kDecimalMaxNumsStr,kInt32MaxNumsCount, 
                                    kRadixDecimal,(sal_Int32*)kInt32MaxNums,0,NULL,hRtlTestResult ),
            "kDecimalMaxNumsStr",
            "toInt32_Boundaries( radix 10 )"
            );
    const sal_Int16 nSpecCases = 5;
    static const sal_Char *spString[nSpecCases] =
    {
        "-1",
        "+1",
        " 1",
        " -1",
        "001"
    };

    sal_Int32 expSpecVal[nSpecCases] =
    {
        -1,
        1,
        1,
        -1,
        1
    };

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int32>( spString,nSpecCases,
                                    kRadixDecimal,expSpecVal,0,NULL,hRtlTestResult ),
            "special cases",
            "toInt32( specialcases )"
            );

    return ( res );
}

//------------------------------------------------------------------------
// testing the method toInt32()
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_toInt32(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "toInt32");
    sal_Bool bTState = test_rtl_OUString_toInt32_normal( hRtlTestResult );
    bTState &= test_rtl_OUString_toInt32_defaultParam( hRtlTestResult );
    bTState &= test_rtl_OUString_toInt32_wrongRadix( hRtlTestResult );
    c_rtl_tres_state_end( hRtlTestResult, "toInt32");
//    return ( bTState );
}
//------------------------------------------------------------------------
// testing the method toInt64( sal_Int16 radix = 2,8,10,16,36 )
//------------------------------------------------------------------------

sal_Bool SAL_CALL test_rtl_OUString_toInt64_normal(
    hTestResult hRtlTestResult )
{
    sal_Int64 expValues[kBase36NumsCount];
    sal_Int32 i;

    for (i = 0; i < kBase36NumsCount; expValues[i] = i, i++);

    sal_Bool res = c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( kBinaryNumsStr,kBinaryNumsCount, 
                                    kRadixBinary,expValues,3,NULL,hRtlTestResult ),
            "kBinaryNumsStr",
            "toInt64( radix 2 )"
            );
    
/* LLA: does not work within wntmsci8.pro
   res &= c_rtl_tres_state
   (
   hRtlTestResult,
   test_toData<sal_Int64>( kBinaryMaxNumsStr,kInt64MaxNumsCount, 
   kRadixBinary,kInt64MaxNums,3,hRtlTestResult ),
   "kBinaryMaxNumsStr",
   "toInt64_Boundaries( radix 2 )"
   );
*/

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( kOctolNumsStr,kOctolNumsCount, 
                                    kRadixOctol,expValues,3,NULL,hRtlTestResult ),
            "kOctolNumsStr",
            "toInt64( radix 8 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( kOctolMaxNumsStr,kInt64MaxNumsCount, 
                                    kRadixOctol,(sal_Int64*)kInt64MaxNums,3,NULL,hRtlTestResult ),
            "kOctolMaxNumsStr",
            "toInt64_Boundaries( radix 8 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( kDecimalNumsStr,kDecimalNumsCount,
                                    kRadixDecimal,expValues,3,NULL,hRtlTestResult ),
            "kDecimalNumsStr",
            "toInt64( radix 10 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( kDecimalMaxNumsStr,kInt64MaxNumsCount, 
                                    kRadixDecimal,(sal_Int64*)kInt64MaxNums,3,NULL,hRtlTestResult ),
            "kDecimalMaxNumsStr",
            "toInt64_Boundaries( radix 10 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( kHexDecimalNumsStr,kHexDecimalNumsCount,
                                    kRadixHexdecimal,expValues,3,NULL,hRtlTestResult ),
            "kHexDecimalNumsStr",
            "toInt64( radix 16 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>(  kHexDecimalMaxNumsStr,kInt64MaxNumsCount,
                                     kRadixHexdecimal,(sal_Int64*)kInt64MaxNums,3,NULL,hRtlTestResult ),
            "kHexDecimalMaxNumsStr",
            "toInt64_Boundaries( radix 16 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>(  kBase36NumsStr,kBase36NumsCount,
                                     kRadixBase36, expValues,3,NULL,hRtlTestResult ),
            "kBase36NumsStr",
            "toInt64( radix 36 )"
            );

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( kBase36MaxNumsStr,kInt64MaxNumsCount,
                                    kRadixBase36,(sal_Int64*)kInt64MaxNums,3,NULL,hRtlTestResult ),
            "kBase36MaxNumsStr",
            "toInt64_Boundaries( radix 36 )"
            );


    const sal_Int16 nSpecCases = 5;
    static const sal_Char *spString[nSpecCases] =
    {
        "-1",
        "+1",
        " 1",
        " -1",
        "001"
    };

    sal_Int64 expSpecVal[nSpecCases] =
    {
        -1,
        1,
        1,
        -1,
        1
    };

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( spString,nSpecCases,
                                    kRadixDecimal,expSpecVal,3,NULL,hRtlTestResult ),
            "special cases",
            "toInt64( specialcases )"
            );

    return (res);
}

sal_Bool SAL_CALL test_rtl_OUString_toInt64_wrongRadix(
    hTestResult hRtlTestResult )
{
    ::rtl::OUString str("0",1,kEncodingRTLTextUSASCII,
                        kConvertFlagsOStringToOUString);

    sal_Int64 iRes = str.toInt64(-1);

    return (
        c_rtl_tres_state
		( 
            hRtlTestResult,
            iRes == 0,
            "wrong radix -1",
            "toInt64( wrong radix -1)"
            )
        );
}
sal_Bool SAL_CALL test_rtl_OUString_toInt64_defaultParam(
    hTestResult hRtlTestResult )
{
    sal_Int64 expValues[kBase36NumsCount];
    sal_Int32 i;

    for ( i = 0; i < kBase36NumsCount; i++ )
        expValues[i] = i;

    sal_Bool res = c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( kDecimalNumsStr,kDecimalNumsCount,
                                    kRadixDecimal,expValues,2,NULL,hRtlTestResult ),
            "kBinaryNumsStr",
            "toInt64( radix 10 )"
            );
    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( kDecimalMaxNumsStr,kInt64MaxNumsCount, 
                                    kRadixDecimal,(sal_Int64*)kInt64MaxNums,2,NULL,hRtlTestResult ),
            "kDecimalMaxNumsStr",
            "toInt64_Boundaries( radix 10 )"
            );
    const sal_Int16 nSpecCases = 5;
    static const sal_Char *spString[nSpecCases] =
    {
        "-1",
        "+1",
        " 1",
        " -1",
        "001"
    };

    sal_Int64 expSpecVal[nSpecCases] =
    {
        -1,
        1,
        1,
        -1,
        1
    };

    res &= c_rtl_tres_state
        (
            hRtlTestResult,
            test_toData<sal_Int64>( spString,nSpecCases,
                                    kRadixDecimal,expSpecVal,2,NULL,hRtlTestResult ),
            "special cases",
            "toInt64( specialcases )"
            );

    return ( res );
}

//------------------------------------------------------------------------
// testing the method toInt64()
//------------------------------------------------------------------------
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString_toInt64(
    hTestResult hRtlTestResult )
{
    c_rtl_tres_state_start( hRtlTestResult, "toInt64");
    sal_Bool bTState = test_rtl_OUString_toInt64_normal( hRtlTestResult );
    bTState &= test_rtl_OUString_toInt64_defaultParam (hRtlTestResult );
    bTState &= test_rtl_OUString_toInt64_wrongRadix( hRtlTestResult );
    c_rtl_tres_state_end( hRtlTestResult, "toInt64");
//    return ( bTState );
}
extern "C" void /* sal_Bool */ SAL_CALL test_rtl_OUString( hTestResult hRtlTestResult )
{

    c_rtl_tres_state_start(hRtlTestResult, "rtl_OUString" );

    test_rtl_OUString_ctors( hRtlTestResult );
    test_rtl_OUString_getLength( hRtlTestResult );
    test_rtl_OUString_equals( hRtlTestResult );
    test_rtl_OUString_equalsIgnoreAsciiCase( hRtlTestResult );
    test_rtl_OUString_compareTo( hRtlTestResult );
    test_rtl_OUString_match( hRtlTestResult );
    test_rtl_OUString_op_eq( hRtlTestResult );
    test_rtl_OUString_op_peq( hRtlTestResult );
    test_rtl_OUString_csuc( hRtlTestResult );
    test_rtl_OUString_getStr( hRtlTestResult );
    test_rtl_OUString_reverseCompareTo( hRtlTestResult );
    test_rtl_OUString_equalsAscii( hRtlTestResult );
    test_rtl_OUString_equalsAsciiL( hRtlTestResult );
    test_rtl_OUString_compareToAscii( hRtlTestResult );
    test_rtl_OUString_valueOf_sal_Bool( hRtlTestResult );
    test_rtl_OUString_valueOf_sal_Unicode( hRtlTestResult );
    test_rtl_OUString_valueOf( hRtlTestResult );
    test_rtl_OUString_createFromAscii( hRtlTestResult );
    test_rtl_OUString_indexOf( hRtlTestResult );
// LLA: removed, it is in a new test in rtl/oustring. test_rtl_OUString_lastIndexOf( hRtlTestResult );
    test_rtl_OUString_concat( hRtlTestResult );
    test_rtl_OUString_replaceAt( hRtlTestResult );
    test_rtl_OUString_replace( hRtlTestResult );
    test_rtl_OUString_toAsciiLowerCase( hRtlTestResult );
    test_rtl_OUString_toAsciiUpperCase( hRtlTestResult );
    test_rtl_OUString_trim( hRtlTestResult );
// LLA: removed, it is in a new test in rtl/oustring. test_rtl_OUString_toDouble( hRtlTestResult );
// LLA: removed, has compile problems.    test_rtl_OUString_toFloat( hRtlTestResult );
    test_rtl_OUString_toChar( hRtlTestResult );
    test_rtl_OUString_toBoolean( hRtlTestResult );
    test_rtl_OUString_toInt32( hRtlTestResult );
    test_rtl_OUString_toInt64( hRtlTestResult );

    c_rtl_tres_state_end(hRtlTestResult, "rtl_OUString");
}
// -----------------------------------------------------------------------------
void RegisterAdditionalFunctions(FktRegFuncPtr _pFunc)
{
    if (_pFunc)
    {
        (_pFunc)(&test_rtl_OUString, "");
    }
}