INTEGRATION: CWS qadev3 (1.2.2); FILE ADDED

2003/03/28 12:50:30 lla 1.2.2.1: #108453# get back all tests.

1 files changed, 643 insertions, 0 deletions

diff --git a/sal/qa/OStringBuffer/rtl_String_Utils.cxx b/sal/qa/OStringBuffer/rtl_String_Utils.cxx
new file mode 100644
index 000000000000..cad5d3a4eadf
--- /dev/null
+++ b/sal/qa/OStringBuffer/rtl_String_Utils.cxx
@@ -0,0 +1,643 @@
+/*************************************************************************
+#
+#   $RCSfile: rtl_String_Utils.cxx,v $
+#
+#   $Revision: 1.3 $
+#
+#   last change: $Author: vg $ $Date: 2003-04-01 13:23:23 $
+#
+#   The Contents of this file are made available subject to the terms of
+#   either of the following licenses
+#
+#          - GNU Lesser General Public License Version 2.1
+#          - Sun Industry Standards Source License Version 1.1
+#
+#   Sun Microsystems Inc., October, 2000
+#
+#   GNU Lesser General Public License Version 2.1
+#   =============================================
+#   Copyright 2000 by Sun Microsystems, Inc.
+#   901 San Antonio Road, Palo Alto, CA 94303, USA
+#
+#   This library is free software; you can redistribute it and/or
+#   modify it under the terms of the GNU Lesser General Public
+#   License version 2.1, as published by the Free Software Foundation.
+#
+#   This library is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#   Lesser General Public License for more details.
+#
+#   You should have received a copy of the GNU Lesser General Public
+#   License along with this library; if not, write to the Free Software
+#   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+#   MA  02111-1307  USA
+#
+#
+#   Sun Industry Standards Source License Version 1.1
+#   =================================================
+#   The contents of this file are subject to the Sun Industry Standards
+#   Source License Version 1.1 (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.openoffice.org/license.html.
+#
+#   Software provided under this License is provided on an "AS IS" basis,
+#   WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+#   WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+#   MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+#   See the License for the specific provisions governing your rights and
+#   obligations concerning the Software.
+#
+#   The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+#
+#   Copyright: 2000 by Sun Microsystems, Inc.
+#
+#   All Rights Reserved.
+#
+#   Contributor(s): _______________________________________
+#
+#
+#
+#*************************************************************************/
+
+//------------------------------------------------------------------------
+//------------------------------------------------------------------------
+
+#include <math.h>
+#include <stdlib.h>
+
+//------------------------------------------------------------------------
+//------------------------------------------------------------------------
+
+#ifndef _SAL_TYPES_H_
+    #include <sal/types.h>
+#endif
+
+#ifndef _RTL_USTRING_H_
+    #include <rtl/ustring.h>
+#endif
+
+#ifndef _RTL_STRING_HXX_
+    #include <rtl/string.hxx>
+#endif
+
+//------------------------------------------------------------------------
+//------------------------------------------------------------------------
+
+#ifndef _RTL_STRING_UTILS_CONST_H_
+    #include <rtl_String_Utils_Const.h>
+#endif
+
+//------------------------------------------------------------------------
+//------------------------------------------------------------------------
+
+using namespace rtl;
+
+sal_uInt32 AStringLen( const sal_Char *pAStr )
+{
+    sal_uInt32  nStrLen = 0;
+
+    if ( pAStr != NULL )
+    {
+        const sal_Char *pTempStr = pAStr;
+
+        while( *pTempStr )
+        {
+            pTempStr++;
+        } // while
+
+        nStrLen = (sal_uInt32)( pTempStr - pAStr );
+    } // if
+
+    return nStrLen;
+} // AStringLen
+sal_Char* cpystr( sal_Char* dst, const sal_Char* src )
+{
+    const sal_Char* psrc = src;
+    sal_Char* pdst = dst;
+
+    while( *pdst++ = *psrc++ );
+    return ( dst );
+}
+
+sal_Char* cpynstr( sal_Char* dst, const sal_Char* src, sal_uInt32 cnt )
+{
+
+    const sal_Char* psrc = src;
+    sal_Char* pdst = dst;
+    sal_uInt32 len = cnt;
+    sal_uInt32 i;
+
+    if ( len >= AStringLen(src) )
+    {
+        return( cpystr( dst, src ) );
+    }
+
+    // copy string by char
+    for( i = 0; i < len; i++ )
+        *pdst++ = *psrc++;
+    *pdst = '\0';
+
+    return ( dst );
+}
+
+//------------------------------------------------------------------------
+sal_Bool cmpstr( const sal_Char* str1, const sal_Char* str2, sal_uInt32 len )
+{
+    const sal_Char* pBuf1 = str1;
+    const sal_Char* pBuf2 = str2;
+    sal_uInt32 i = 0;
+
+    while ( (*pBuf1 == *pBuf2) && i < len )
+    {
+        (pBuf1)++;
+        (pBuf2)++;
+        i++;
+    }
+    return( i == len );
+}
+//-----------------------------------------------------------------------
+sal_Bool cmpstr( const sal_Char* str1, const sal_Char* str2 )
+{
+    const sal_Char* pBuf1 = str1;
+    const sal_Char* pBuf2 = str2;
+    sal_Bool res = sal_True;
+
+    while ( (*pBuf1 == *pBuf2) && *pBuf1 !='\0' && *pBuf2 != '\0')
+    {
+        (pBuf1)++;
+        (pBuf2)++;
+    }
+    if (*pBuf1 == '\0' && *pBuf2 == '\0')
+        res = sal_True;
+    else
+        res = sal_False;
+    return (res);
+}
+//------------------------------------------------------------------------
+sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2, sal_uInt32 len )
+{
+    const sal_Unicode* pBuf1 = str1;
+    const sal_Unicode* pBuf2 = str2;
+    sal_uInt32 i = 0;
+
+    while ( (*pBuf1 == *pBuf2) && i < len )
+    {
+        (pBuf1)++;
+        (pBuf2)++;
+        i++;
+    }
+    return( i == len );
+}
+
+//-----------------------------------------------------------------------
+sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2 )
+{
+    const sal_Unicode* pBuf1 = str1;
+    const sal_Unicode* pBuf2 = str2;
+    sal_Bool res = sal_True;
+
+    while ( (*pBuf1 == *pBuf2) && *pBuf1 !='\0' && *pBuf2 != '\0')
+    {
+        (pBuf1)++;
+        (pBuf2)++;
+    }
+    if (*pBuf1 == '\0' && *pBuf2 == '\0')
+        res = sal_True;
+    else
+        res = sal_False;
+    return (res);
+}
+
+sal_Char* createName( sal_Char* dst, const sal_Char* meth, sal_uInt32 cnt )
+{
+    sal_Char* pdst = dst;
+    sal_Char nstr[16];
+    sal_Char* pstr = nstr;
+    rtl_str_valueOfInt32( pstr, cnt, 10 );
+
+    cpystr( pdst, meth );
+    cpystr( pdst+ AStringLen(meth), "_" );
+
+    if ( cnt < 100 )
+    {
+        cpystr(pdst + AStringLen(pdst), "0" );
+    }
+    if ( cnt < 10 )
+    {
+        cpystr(pdst + AStringLen(pdst), "0" );
+    }
+
+    cpystr( pdst + AStringLen(pdst), nstr );
+    return( pdst );
+}
+
+//------------------------------------------------------------------------
+//  testing the method compareTo( const OString & aStr )
+//------------------------------------------------------------------------
+void makeComment( char *com, const char *str1, const char *str2,
+                                                            sal_Int32 sgn )
+{
+    cpystr(com, str1);
+    int str1Length = AStringLen( str1 );
+    const char *sign = (sgn == 0) ? " == " : (sgn > 0) ? " > " : " < " ;
+    cpystr(com + str1Length, sign);
+    int signLength = AStringLen(sign);
+    cpystr(com + str1Length + signLength, str2);
+    com[str1Length + signLength + AStringLen(str2)] = 0;
+}
+
+
+//------------------------------------------------------------------------
+
+sal_Bool AStringToFloatCompare ( const sal_Char  *pStr,
+                                 const float      nX,
+                                 const float      nEPS
+                                )
+{
+    sal_Bool cmp = sal_False;
+
+    if ( pStr != NULL )
+    {
+        ::rtl::OString aStr(pStr);
+
+        float actNum = 0;
+        float expNum = nX;
+        float eps    = nEPS;
+
+        actNum = aStr.toFloat();
+
+        if ( abs( (int)(actNum - expNum) ) <= eps )
+        {
+            cmp = sal_True;
+        } // if
+    } // if
+
+    return cmp;
+} // AStringToFloatCompare
+
+//------------------------------------------------------------------------
+
+sal_Bool AStringToDoubleCompare ( const sal_Char  *pStr,
+                                  const double     nX,
+                                  const double     nEPS
+                                )
+{
+    sal_Bool cmp = sal_False;
+
+    if ( pStr != NULL )
+    {
+        ::rtl::OString aStr(pStr);
+
+        double actNum = 0;
+        double expNum = nX;
+        double eps    = nEPS;
+
+        actNum = aStr.toDouble();
+
+        if ( abs( (int)(actNum - expNum) ) <= eps )
+        {
+            cmp = sal_True;
+        } // if
+    } // if
+
+    return cmp;
+} // AStringToDoubleCompare
+
+//------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------
+
+sal_uInt32 UStringLen( const sal_Unicode *pUStr )
+{
+    sal_uInt32 nUStrLen = 0;
+
+    if ( pUStr != NULL )
+    {
+        const sal_Unicode *pTempUStr = pUStr;
+
+        while( *pTempUStr )
+        {
+            pTempUStr++;
+        } // while
+
+        nUStrLen = (sal_uInt32)( pTempUStr - pUStr );
+    } // if
+
+    return nUStrLen;
+} // UStringLen
+
+//------------------------------------------------------------------------
+
+sal_Bool AStringIsValid( const sal_Char  *pAStr )
+{
+    if ( pAStr != NULL )
+    {
+        sal_uInt32 nLen  = AStringLen( pAStr );
+        sal_uChar  uChar = 0;
+
+        while ( ( nLen >= 0 ) && ( *pAStr ) )
+        {
+            uChar = (unsigned char)*pAStr;
+
+            if ( uChar > 127 )
+            {
+                return sal_False;
+            } // if
+
+            pAStr++;
+
+            // Since we are dealing with unsigned integers
+            // we want to make sure that the last number is
+            // indeed zero.
+
+            if ( nLen > 0 )
+            {
+                nLen--;
+            } // if
+            else
+            {
+                break;
+            } // else
+        } // while
+    } // if
+
+    return sal_True;
+} // AStringIsValid
+
+//------------------------------------------------------------------------
+
+sal_Bool AStringNIsValid( const sal_Char   *pAStr,
+                          const sal_uInt32  nStrLen
+                        )
+{
+    sal_uInt32 nLen  = nStrLen;
+    sal_uChar  uChar = 0;
+
+    while ( ( nLen >= 0 ) && ( *pAStr ) )
+    {
+        uChar = (unsigned char)*pAStr;
+
+        if ( uChar > 127 )
+        {
+            return sal_False;
+        } // if
+
+        pAStr++;
+
+        // Since we are dealing with unsigned integers
+        // we want to make sure that the last number is
+        // indeed zero.
+
+        if ( nLen > 0 )
+        {
+            nLen--;
+        } // if
+        else
+        {
+            break;
+        } // else
+    } // while
+
+    return sal_True;
+} // AStringNIsValid
+
+//------------------------------------------------------------------------
+
+static inline sal_Int32 ACharToUCharCompare( const sal_Unicode *pUStr,
+                                             const sal_Char    *pAStr
+                                           )
+{
+    sal_Int32  nCmp   = 0;
+    sal_Int32  nUChar = (sal_Int32)*pUStr;
+    sal_Int32  nChar  = (sal_Int32)((unsigned char)*pAStr);
+
+    nCmp = nUChar - nChar;
+
+    return  nCmp;
+} // ACharToUCharCompare
+
+//------------------------------------------------------------------------
+
+sal_Int32 AStringToUStringCompare( const sal_Unicode *pUStr,
+                                   const sal_Char    *pAStr
+                                 )
+{
+     sal_Int32 nCmp = kErrCompareAStringToUString;
+
+    if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
+    {
+        nCmp = ACharToUCharCompare( pUStr, pAStr );
+
+        while ( ( nCmp == 0 ) && ( *pAStr ) )
+        {
+            pUStr++;
+            pAStr++;
+
+            nCmp = ACharToUCharCompare( pUStr, pAStr );
+        } // while
+    } // if
+
+    return nCmp;
+} // AStringToUStringCompare
+
+//------------------------------------------------------------------------
+
+sal_Int32 AStringToUStringNCompare( const sal_Unicode  *pUStr,
+                                    const sal_Char     *pAStr,
+                                    const sal_uInt32    nAStrCount
+                                   )
+{
+    sal_Int32 nCmp = kErrCompareNAStringToUString;
+
+    if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
+    {
+        sal_uInt32 nCount = nAStrCount;
+
+        nCmp = ACharToUCharCompare( pUStr, pAStr );
+
+        while ( ( nCmp == 0 ) && ( *pAStr ) && ( nCount ) )
+        {
+            pUStr++;
+            pAStr++;
+
+            nCmp = ACharToUCharCompare( pUStr, pAStr );
+
+            // Since we are dealing with unsigned integers
+            // we want to make sure that the last number is
+            // indeed zero.
+
+            if ( nCount > 0 )
+            {
+                nCount--;
+            } // if
+            else
+            {
+                break;
+            } // else
+        } // while
+    } // if
+
+    return nCmp;
+} // AStringToUStringNCompare
+
+//------------------------------------------------------------------------
+
+sal_Int32 AStringToRTLUStringCompare( const rtl_uString  *pRTLUStr,
+                                      const sal_Char     *pAStr
+                                    )
+{
+    sal_Int32 nCmp = kErrCompareAStringToRTLUString;
+
+    if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
+    {
+        rtl_uString *pRTLUStrCopy = NULL;
+
+        rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );
+
+        if ( pRTLUStrCopy != NULL )
+        {
+            const sal_Unicode *pUStr = rtl_uString_getStr( pRTLUStrCopy );
+
+            if ( pUStr != NULL )
+            {
+                nCmp = AStringToUStringCompare( pUStr, pAStr );
+            } // if
+
+            rtl_uString_release( pRTLUStrCopy );
+
+            pRTLUStrCopy = NULL;
+        } // if
+    } // if
+
+    return nCmp;
+} // AStringToRTLUStringCompare
+
+//------------------------------------------------------------------------
+
+sal_Int32 AStringToRTLUStringNCompare( const rtl_uString  *pRTLUStr,
+                                       const sal_Char     *pAStr,
+                                       const sal_uInt32    nAStrCount
+                                     )
+{
+    sal_Int32 nCmp = kErrCompareNAStringToRTLUString;
+
+    if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
+    {
+        rtl_uString *pRTLUStrCopy = NULL;
+
+        rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );
+
+        if ( pRTLUStrCopy != NULL )
+        {
+            const sal_Unicode  *pUStr = rtl_uString_getStr( pRTLUStrCopy );
+
+            if ( pUStr != NULL )
+            {
+                nCmp = AStringToUStringNCompare( pUStr, pAStr, nAStrCount );
+            } // if
+
+            rtl_uString_release( pRTLUStrCopy );
+
+            pRTLUStrCopy = NULL;
+        } // if
+    } // if
+
+    return nCmp;
+} // AStringToRTLUStringNCompare
+
+//------------------------------------------------------------------------
+
+sal_Bool AStringToUStringCopy( sal_Unicode     *pDest,
+                               const sal_Char  *pSrc
+                             )
+{
+    sal_Bool    bCopied = sal_False;
+    sal_uInt32  nCount  = AStringLen( pSrc );
+    sal_uInt32  nLen    = nCount;
+
+    if (    ( pDest != NULL )
+         && ( pSrc  != NULL )
+         && ( AStringNIsValid( pSrc, nLen ) )
+       )
+    {
+        while ( nCount >= 0 )
+        {
+            *pDest = (unsigned char)*pSrc;
+
+            pDest++;
+            pSrc++;
+
+            // Since we are dealing with unsigned integers
+            // we want to make sure that the last number is
+            // indeed zero.
+
+            if ( nCount > 0 )
+            {
+                nCount--;
+            } // if
+            else
+            {
+                break;
+            } // else
+        } // while
+
+        if ( nCount == 0 )
+        {
+            bCopied = sal_True;
+        } // if
+    } // if
+
+    return  bCopied;
+} // AStringToUStringCopy
+
+//------------------------------------------------------------------------
+
+sal_Bool AStringToUStringNCopy( sal_Unicode       *pDest,
+                                const sal_Char    *pSrc,
+                                const sal_uInt32   nSrcLen
+                              )
+{
+    sal_Bool    bCopied = sal_False;
+    sal_uInt32  nCount  = nSrcLen;
+    sal_uInt32  nLen    = nSrcLen;
+
+    if (    ( pDest != NULL )
+         && ( pSrc  != NULL )
+         && ( AStringNIsValid( pSrc, nLen ) )
+       )
+    {
+        while ( nCount >= 0 )
+        {
+            *pDest = (unsigned char)*pSrc;
+
+            pDest++;
+            pSrc++;
+
+            // Since we are dealing with unsigned integers
+            // we want to make sure that the last number is
+            // indeed zero.
+
+            if ( nCount > 0 )
+            {
+                nCount--;
+            } // if
+            else
+            {
+                break;
+            } // else
+        } // while
+
+        if ( nCount == 0 )
+        {
+            bCopied = sal_True;
+        } // if
+    } // if
+
+    return  bCopied;
+} // AStringToUStringNCopy
+
+//------------------------------------------------------------------------
+//------------------------------------------------------------------------
+