From 7ef439acc92d7c59d114601a014fba643522b027 Mon Sep 17 00:00:00 2001 From: Vladimir Glazounov Date: Tue, 1 Apr 2003 12:23:23 +0000 Subject: INTEGRATION: CWS qadev3 (1.2.2); FILE ADDED 2003/03/28 12:50:30 lla 1.2.2.1: #108453# get back all tests. --- sal/qa/OStringBuffer/rtl_String_Utils.cxx | 643 ++++++++++++++++++++++++++++++ 1 file changed, 643 insertions(+) create mode 100644 sal/qa/OStringBuffer/rtl_String_Utils.cxx (limited to 'sal') 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 +#include + +//------------------------------------------------------------------------ +//------------------------------------------------------------------------ + +#ifndef _SAL_TYPES_H_ + #include +#endif + +#ifndef _RTL_USTRING_H_ + #include +#endif + +#ifndef _RTL_STRING_HXX_ + #include +#endif + +//------------------------------------------------------------------------ +//------------------------------------------------------------------------ + +#ifndef _RTL_STRING_UTILS_CONST_H_ + #include +#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 + +//------------------------------------------------------------------------ +//------------------------------------------------------------------------ + -- cgit