/* * $Id$ */ /* * Harbour Project source code: * Regression tests for the runtime library (strings) * * Copyright 1999-2001 Viktor Szakats (harbour syenar.net) * www - http://harbour-project.org * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this software; see the file COPYING.txt. If not, write to * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, * Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/). * * As a special exception, the Harbour Project gives permission for * additional uses of the text contained in its release of Harbour. * * The exception is that, if you link the Harbour libraries with other * files to produce an executable, this does not by itself cause the * resulting executable to be covered by the GNU General Public License. * Your use of that executable is in no way restricted on account of * linking the Harbour library code into it. * * This exception does not however invalidate any other reasons why * the executable file might be covered by the GNU General Public License. * * This exception applies only to the code released by the Harbour * Project under the name Harbour. If you copy code from other * Harbour Project or Free Software Foundation releases into a copy of * Harbour, as the General Public License permits, the exception does * not apply to the code that you add in this way. To avoid misleading * anyone as to the status of such modified files, you must delete * this exception notice from them. * * If you write modifications of your own for Harbour, it is your choice * whether to permit this exception to apply to your modifications. * If you do not wish that, delete this exception notice. * */ #include "rt_main.ch" /* Don't change the position of this #include. */ #include "rt_vars.ch" #ifdef __HARBOUR__ #include "hbver.ch" #endif PROCEDURE Main_STR() LOCAL l64 #ifdef __HARBOUR__ l64 := hb_Version( HB_VERSION_BITWIDTH ) >= 64 #else l64 := .F. #endif /* Val() */ HBTEST Val( NIL ) IS "E 1 BASE 1098 Argument error (VAL) OS:0 #:0 A:1:U:NIL F:S" HBTEST Val( 10 ) IS "E 1 BASE 1098 Argument error (VAL) OS:0 #:0 A:1:N:10 F:S" #ifndef RT_NO_C #ifdef __PLATFORM__WINDOWS IF .F. /* [U]LONG is 32 bit integer in Win64 */ #else IF l64 #endif HBTEST Str(R_PASSENL( 1860637360 )) IS "1860637360" HBTEST Str(R_PASSENL( 100 )) IS " 100" HBTEST Str(R_PASSENL( 999999999 )) IS " 999999999" HBTEST Str(R_PASSENL( 1000000000 )) IS "1000000000" HBTEST Str(R_PASSENL( 2147483647 )) IS "2147483647" HBTEST Str(R_PASSENL( 2147483648 )) IS "2147483648" HBTEST Str(R_PASSENL( -1 )) IS " -1" HBTEST Str(R_PASSENL( -999999999 )) IS "-999999999" HBTEST Str(R_PASSENL( -1000000000 )) IS " -1000000000" HBTEST Str(R_PASSENL( -99999999 )) IS " -99999999" HBTEST Str(R_PASSENL( -100000000 )) IS "-100000000" HBTEST Str(R_PASSENLC()) IS "1000000000" ELSE HBTEST Str(R_PASSENL( 1860637360 )) IS " 1860637360" HBTEST Str(R_PASSENL( 100 )) IS " 100" HBTEST Str(R_PASSENL( 999999999 )) IS " 999999999" HBTEST Str(R_PASSENL( 1000000000 )) IS " 1000000000" HBTEST Str(R_PASSENL( 2147483647 )) IS " 2147483647" HBTEST Str(R_PASSENL( 2147483648 )) IS " -2147483648" HBTEST Str(R_PASSENL( -1 )) IS " -1" HBTEST Str(R_PASSENL( -999999999 )) IS "-999999999" HBTEST Str(R_PASSENL( -1000000000 )) IS " -1000000000" HBTEST Str(R_PASSENL( -99999999 )) IS " -99999999" HBTEST Str(R_PASSENL( -100000000 )) IS "-100000000" HBTEST Str(R_PASSENLC()) IS " 1000000000" ENDIF #endif HBTEST Str(Val("")) IS " 0" HBTEST Str(Val("")) IS " 0" HBTEST Str(Val(" ")) IS "0" HBTEST Str(Val("-")) IS "0" HBTEST Str(Val("+")) IS "0" HBTEST Str(Val("-+")) IS " 0" HBTEST Str(Val("+-")) IS " 0" HBTEST Str(Val(".")) IS "0" HBTEST Str(Val("..")) IS "0.0" HBTEST Str(Val("-.")) IS " 0" /* Bug in CA-Cl*pper 5.3b, it will return: " 0" */ HBTEST Str(Val("-..")) IS "0.0" /* Bug in CA-Cl*pper 5.3b, it will return: " 0.0" */ HBTEST Str(Val("1.")) IS " 1" HBTEST Str(Val("1..")) IS "1.0" HBTEST Str(Val("1...")) IS "1.00" HBTEST Str(Val("-1.")) IS " -1" HBTEST Str(Val(" -1.")) IS " -1" HBTEST Str(Val(" --1.")) IS " 0" HBTEST Str(Val("-1..")) IS "-1.0" HBTEST Str(Val("-1...")) IS "-1.00" HBTEST Str(Val(".1")) IS "0.1" HBTEST Str(Val("-.1")) IS "-0.1" HBTEST Str(Val("-.0")) IS "0.0" /* Bug in CA-Cl*pper 5.3b, it will return: " 0.0" */ HBTEST Str(Val(" -.1")) IS "-0.1" HBTEST Str(Val(" --.1")) IS " 0.0" HBTEST Str(Val("+.1")) IS "0.1" HBTEST Str(Val(" .1")) IS "0.1" HBTEST Str(Val("- .1")) IS " 0.0" HBTEST Str(Val("+.1")) IS "0.1" HBTEST Str(Val("- 12")) IS " 0" HBTEST Str(Val(" - 12")) IS " 0" HBTEST Str(Val(" -12")) IS " -12" HBTEST Str(Val(" --12")) IS " 0" HBTEST Str(Val(" 12-")) IS " 12" HBTEST Str(Val(" 12 -")) IS " 12" HBTEST Str(Val(" 13.1.9")) IS " 13.100" HBTEST Str(Val(" 12")) IS " 12" HBTEST Str(Val(" 12"+Chr(0)+"0")) IS " 12" HBTEST Str(Val(" 12.1"+Chr(0)+"2")) IS " 12.100" HBTEST Str(Val(" 12"+Chr(0)+".2")) IS " 12.0" HBTEST Str(Val(" 12.0")) IS " 12.0" HBTEST Str(Val(" 12. 0")) IS " 12.00" HBTEST Str(Val(" 12 .0")) IS " 12.0" HBTEST Str(Val(" 12. 00")) IS " 12.000" HBTEST Str(Val(" 12 .00")) IS " 12.00" HBTEST Str(Val(" 12. 1")) IS " 12.00" HBTEST Str(Val(" 12 .1")) IS " 12.0" HBTEST Str(Val(" 12. 10")) IS " 12.000" HBTEST Str(Val(" 12 .10")) IS " 12.00" HBTEST Str(Val("+ 12")) IS " 0" HBTEST Str(Val(" + 12")) IS " 0" HBTEST Str(Val(" +12")) IS " 12" HBTEST Str(Val("+++12")) IS " 0" HBTEST Str(Val(Chr(9)+"12")) IS " 12" HBTEST Str(Val(Chr(10)+"12")) IS " 12" HBTEST Str(Val(Chr(13)+"12")) IS " 12" HBTEST Str(Val("1E2")) IS " 1" HBTEST Str(Val("+INF")) IS " 0" HBTEST Str(Val("-INF")) IS " 0" HBTEST Str(Val("+NAN")) IS " 0" HBTEST Str(Val("-NAN")) IS " 0" HBTEST Str(Val("2.0000000000000001")) IS "2.0000000000000000" HBTEST Str(Val("2.0000000000000009")) IS "2.0000000000000010" HBTEST Str(Val("2.000000000000001")) IS "2.000000000000001" HBTEST Str(Val("2.000000000000009")) IS "2.000000000000009" HBTEST Str(Val("2.00000000000001")) IS "2.00000000000001" HBTEST Str(Val("2.00000000000009")) IS "2.00000000000009" HBTEST Str(Val("2.000000000001")) IS "2.000000000001" HBTEST Str(Val("2.00000000001")) IS "2.00000000001" HBTEST Str(Val("1HELLO.")) IS " 1" /* Chr() */ HBTEST Chr( NIL ) IS "E 1 BASE 1104 Argument error (CHR) OS:0 #:0 A:1:U:NIL F:S" HBTEST Chr( "A" ) IS "E 1 BASE 1104 Argument error (CHR) OS:0 #:0 A:1:C:A F:S" HBTEST Chr( "ADDDDDD" ) IS "E 1 BASE 1104 Argument error (CHR) OS:0 #:0 A:1:C:ADDDDDD F:S" HBTEST Chr( -10000000.0 ) IS "€" HBTEST Chr( -100000 ) IS "`" HBTEST Chr( -65 ) IS "ż" HBTEST Chr( snIntP1 ) IS "A" #ifdef __HARBOUR__ HBTEST Chr( @snIntP1 ) IS "A" /* Bug in CA-Cl*pper, it returns: "E 1 BASE 1104 Argument error (CHR) OS:0 #:0 A:1:U:65 F:S" */ #endif /* disable Harbour extensions in compiler to replicate Clipper bugs */ #ifdef __HARBOUR__ #pragma -kh- #endif HBTEST Chr( 0 ) IS ""+Chr(0)+"" HBTEST Chr( 0.0 ) IS ""+Chr(0)+"" HBTEST Chr( 0.1 ) IS ""+Chr(0)+"" HBTEST Chr( -0.1 ) IS ""+Chr(0)+"" HBTEST Chr( 66.4 ) IS "B" HBTEST Chr( 66.5 ) IS "B" HBTEST Chr( 66.6 ) IS "B" HBTEST Chr( 255 ) IS "˙" HBTEST Chr( 256 ) IS "" /* Due to a bug in CA-Cl*pper compiler optimizer. It should return Chr(0) */ HBTEST Chr( 256.0 ) IS ""+Chr(0)+"" HBTEST Chr( 256.1 ) IS ""+Chr(0)+"" HBTEST Chr( ( 256 ) ) IS ""+Chr(0)+"" /* Double paranthesis should be used here to avoid the optimizer of the CA-Cl*pper compiler */ HBTEST Chr( 257 ) IS "" HBTEST Chr( ( 512 ) ) IS ""+Chr(0)+"" /* Double paranthesis should be used here to avoid the optimizer of the CA-Cl*pper compiler */ HBTEST Chr( 1023 ) IS "˙" HBTEST Chr( ( 1024 ) ) IS ""+Chr(0)+"" /* Double paranthesis should be used here to avoid the optimizer of the CA-Cl*pper compiler */ HBTEST Chr( 1025 ) IS "" HBTEST Chr( 1000 ) IS "č" HBTEST Chr( 100000 ) IS " " HBTEST Chr( 100000.0 ) IS " " #ifdef __HARBOUR__ /* enable Harbour extensions and test correct results results */ #pragma -kh+ HBTEST Chr( 0 ) IS ""+Chr(0)+"" HBTEST Chr( 0.0 ) IS ""+Chr(0)+"" HBTEST Chr( 0.1 ) IS ""+Chr(0)+"" HBTEST Chr( -0.1 ) IS ""+Chr(0)+"" HBTEST Chr( 66.4 ) IS "B" HBTEST Chr( 66.5 ) IS "B" HBTEST Chr( 66.6 ) IS "B" HBTEST Chr( 255 ) IS "˙" HBTEST Chr( 256 ) IS ""+Chr(0)+"" HBTEST Chr( 256.0 ) IS ""+Chr(0)+"" HBTEST Chr( 256.1 ) IS ""+Chr(0)+"" HBTEST Chr( ( 256 ) ) IS ""+Chr(0)+"" HBTEST Chr( 257 ) IS "" HBTEST Chr( ( 512 ) ) IS ""+Chr(0)+"" HBTEST Chr( 1023 ) IS "˙" HBTEST Chr( ( 1024 ) ) IS ""+Chr(0)+"" HBTEST Chr( 1025 ) IS "" HBTEST Chr( 1000 ) IS "č" HBTEST Chr( 100000 ) IS " " HBTEST Chr( 100000.0 ) IS " " #endif /* Asc() */ HBTEST Asc( NIL ) IS "E 1 BASE 1107 Argument error (ASC) OS:0 #:0 A:1:U:NIL F:S" HBTEST Asc( 100 ) IS "E 1 BASE 1107 Argument error (ASC) OS:0 #:0 A:1:N:100 F:S" HBTEST Asc( 20000 ) IS "E 1 BASE 1107 Argument error (ASC) OS:0 #:0 A:1:N:20000 F:S" HBTEST Asc( "HELLO" ) IS 72 HBTEST Asc( Chr(0) ) IS 0 HBTEST Asc( "a" ) IS 97 HBTEST Asc( "A" ) IS 65 HBTEST Asc( scString ) IS 72 #ifdef __HARBOUR__ HBTEST Asc( @scString ) IS 72 /* Bug in CA-Cl*pper, it returns: "E 1 BASE 1107 Argument error (ASC) OS:0 #:0 A:1:U:HELLO F:S" */ #endif /* IsDigit() */ #ifndef __XPP__ HBTEST IsDigit() IS .F. #endif HBTEST IsDigit( 100 ) IS .F. #ifdef __HARBOUR__ HBTEST IsDigit( @scString ) IS .F. /* Bug in CA-Cl*pper, it will always return .F. */ #endif HBTEST IsDigit( "" ) IS .F. HBTEST IsDigit( "A" ) IS .F. HBTEST IsDigit( "AA" ) IS .F. HBTEST IsDigit( "-" ) IS .F. HBTEST IsDigit( "." ) IS .F. HBTEST IsDigit( "0" ) IS .T. HBTEST IsDigit( "9" ) IS .T. HBTEST IsDigit( "123" ) IS .T. HBTEST IsDigit( "1" ) IS .T. HBTEST IsDigit( "A1" ) IS .F. HBTEST IsDigit( "1A" ) IS .T. /* IsAlpha() */ #ifndef __XPP__ HBTEST IsAlpha() IS .F. #endif HBTEST IsAlpha( 100 ) IS .F. #ifdef __HARBOUR__ HBTEST IsAlpha( @scString ) IS .T. /* Bug in CA-Cl*pper, it will always return .F. */ #endif HBTEST IsAlpha( "" ) IS .F. HBTEST IsAlpha( "A" ) IS .T. HBTEST IsAlpha( "AA" ) IS .T. HBTEST IsAlpha( "-" ) IS .F. HBTEST IsAlpha( "." ) IS .F. HBTEST IsAlpha( "0" ) IS .F. HBTEST IsAlpha( "9" ) IS .F. HBTEST IsAlpha( "123" ) IS .F. HBTEST IsAlpha( "1" ) IS .F. HBTEST IsAlpha( "A" ) IS .T. HBTEST IsAlpha( "A1" ) IS .T. HBTEST IsAlpha( "aa" ) IS .T. HBTEST IsAlpha( "za" ) IS .T. HBTEST IsAlpha( "Aa" ) IS .T. HBTEST IsAlpha( "Za" ) IS .T. HBTEST IsAlpha( "@" ) IS .F. HBTEST IsAlpha( "[" ) IS .F. HBTEST IsAlpha( "`" ) IS .F. HBTEST IsAlpha( "{" ) IS .F. /* IsUpper() */ #ifndef __XPP__ HBTEST IsUpper() IS .F. #endif HBTEST IsUpper( 100 ) IS .F. #ifdef __HARBOUR__ HBTEST IsUpper( @scString ) IS .T. /* Bug in CA-Cl*pper, it will always return .F. */ #endif HBTEST IsUpper( "" ) IS .F. HBTEST IsUpper( "6" ) IS .F. HBTEST IsUpper( "A" ) IS .T. HBTEST IsUpper( "AA" ) IS .T. HBTEST IsUpper( "a" ) IS .F. HBTEST IsUpper( "K" ) IS .T. HBTEST IsUpper( "Z" ) IS .T. HBTEST IsUpper( "z" ) IS .F. HBTEST IsUpper( "™" ) IS .F. HBTEST IsUpper( "”" ) IS .F. /* IsLower() */ #ifndef __XPP__ HBTEST IsLower() IS .F. #endif HBTEST IsLower( 100 ) IS .F. #ifdef __HARBOUR__ HBTEST IsLower( @scString ) IS .F. /* Bug in CA-Cl*pper, it will always return .F. */ #endif HBTEST IsLower( "" ) IS .F. HBTEST IsLower( "6" ) IS .F. HBTEST IsLower( "A" ) IS .F. HBTEST IsLower( "AA" ) IS .F. HBTEST IsLower( "a" ) IS .T. HBTEST IsLower( "K" ) IS .F. HBTEST IsLower( "Z" ) IS .F. HBTEST IsLower( "z" ) IS .T. HBTEST IsLower( "™" ) IS .F. HBTEST IsLower( "”" ) IS .F. /* AllTrim() */ #ifdef HB_COMPAT_C53 /* These lines will cause CA-Cl*pper 5.2e to trash memory and later crash, it was fixed in 5.3 */ HBTEST AllTrim( NIL ) IS "E 1 BASE 2022 Argument error (ALLTRIM) OS:0 #:0 A:1:U:NIL F:S" HBTEST AllTrim( 100 ) IS "E 1 BASE 2022 Argument error (ALLTRIM) OS:0 #:0 A:1:N:100 F:S" #endif #ifdef __HARBOUR__ HBTEST AllTrim(@scString) IS "HELLO" /* CA-Cl*pper bug, it will terminate the program on this line. */ #endif HBTEST AllTrim(scString) IS "HELLO" HBTEST AllTrim("HELLO") IS "HELLO" HBTEST AllTrim( "" ) IS "" HBTEST AllTrim( "UA " ) IS "UA" HBTEST AllTrim( " UA" ) IS "UA" HBTEST AllTrim( " UA " ) IS "UA" HBTEST AllTrim( " "+Chr(0)+" UA " ) IS ""+Chr(0)+" UA" HBTEST AllTrim( " "+Chr(9)+" UA " ) IS "UA" HBTEST AllTrim( " "+Chr(9)+"U"+Chr(9)) IS "U"+Chr(9)+"" HBTEST AllTrim( " "+Chr(9)+Chr(9)) IS "" HBTEST AllTrim( Chr(10)+"U"+Chr(10)) IS "U"+Chr(10)+"" HBTEST AllTrim( Chr(13)+"U"+Chr(13)) IS "U"+Chr(13)+"" HBTEST AllTrim( "A"+Chr(10)) IS "A"+Chr(10)+"" HBTEST AllTrim( "A"+Chr(13)) IS "A"+Chr(13)+"" HBTEST AllTrim( " "+Chr(0)+"ABC"+Chr(0)+" ") IS ""+Chr(0)+"ABC"+Chr(0)+"" /* Trim() */ HBTEST Trim( 100 ) IS "E 1 BASE 1100 Argument error (TRIM) OS:0 #:0 A:1:N:100 F:S" HBTEST Trim( NIL ) IS "E 1 BASE 1100 Argument error (TRIM) OS:0 #:0 A:1:U:NIL F:S" #ifdef __HARBOUR__ HBTEST Trim(@scString) IS "HELLO" /* CA-Cl*pper bug, it will throw an error here. */ #endif HBTEST Trim(scString) IS "HELLO" HBTEST Trim("HELLO") IS "HELLO" HBTEST Trim( "" ) IS "" HBTEST Trim( "UA " ) IS "UA" HBTEST Trim( " UA" ) IS " UA" HBTEST Trim( " UA " ) IS " UA" HBTEST Trim( " "+Chr(0)+" UA " ) IS " "+Chr(0)+" UA" HBTEST Trim( " "+Chr(9)+" UA " ) IS " "+Chr(9)+" UA" HBTEST Trim( " "+Chr(9)+"U"+Chr(9)) IS " "+Chr(9)+"U"+Chr(9)+"" HBTEST Trim( " "+Chr(9)+Chr(9)) IS " "+Chr(9)+""+Chr(9)+"" HBTEST Trim( Chr(10)+"U"+Chr(10)) IS ""+Chr(10)+"U"+Chr(10)+"" HBTEST Trim( Chr(13)+"U"+Chr(13)) IS ""+Chr(13)+"U"+Chr(13)+"" HBTEST Trim( "A"+Chr(10)) IS "A"+Chr(10)+"" HBTEST Trim( "A"+Chr(13)) IS "A"+Chr(13)+"" HBTEST Trim( " "+Chr(0)+"ABC"+Chr(0)+" ") IS " "+Chr(0)+"ABC"+Chr(0)+"" /* RTrim() */ HBTEST RTrim( 100 ) IS "E 1 BASE 1100 Argument error (TRIM) OS:0 #:0 A:1:N:100 F:S" HBTEST RTrim( NIL ) IS "E 1 BASE 1100 Argument error (TRIM) OS:0 #:0 A:1:U:NIL F:S" #ifdef __HARBOUR__ HBTEST RTrim(@scString) IS "HELLO" /* CA-Cl*pper bug, it will throw an error here. */ #endif HBTEST RTrim(scString) IS "HELLO" HBTEST RTrim("HELLO") IS "HELLO" HBTEST RTrim( "" ) IS "" HBTEST RTrim( "UA " ) IS "UA" HBTEST RTrim( " UA" ) IS " UA" HBTEST RTrim( " UA " ) IS " UA" HBTEST RTrim( " "+Chr(0)+" UA " ) IS " "+Chr(0)+" UA" HBTEST RTrim( " "+Chr(9)+" UA " ) IS " "+Chr(9)+" UA" HBTEST RTrim( " "+Chr(9)+"U"+Chr(9)) IS " "+Chr(9)+"U"+Chr(9)+"" HBTEST RTrim( " "+Chr(9)+Chr(9)) IS " "+Chr(9)+""+Chr(9)+"" HBTEST RTrim( Chr(10)+"U"+Chr(10)) IS ""+Chr(10)+"U"+Chr(10)+"" HBTEST RTrim( Chr(13)+"U"+Chr(13)) IS ""+Chr(13)+"U"+Chr(13)+"" HBTEST RTrim( "A"+Chr(10)) IS "A"+Chr(10)+"" HBTEST RTrim( "A"+Chr(13)) IS "A"+Chr(13)+"" HBTEST RTrim( " "+Chr(0)+"ABC"+Chr(0)+" ") IS " "+Chr(0)+"ABC"+Chr(0)+"" /* LTrim() */ HBTEST LTrim( 100 ) IS "E 1 BASE 1101 Argument error (LTRIM) OS:0 #:0 A:1:N:100 F:S" HBTEST LTrim( NIL ) IS "E 1 BASE 1101 Argument error (LTRIM) OS:0 #:0 A:1:U:NIL F:S" #ifdef __HARBOUR__ HBTEST LTrim(@scString) IS "HELLO" /* CA-Cl*pper bug, it will throw an error here. */ #endif HBTEST LTrim(scString) IS "HELLO" HBTEST LTrim("HELLO") IS "HELLO" HBTEST LTrim( "" ) IS "" HBTEST LTrim( "UA " ) IS "UA " HBTEST LTrim( " UA" ) IS "UA" HBTEST LTrim( " UA " ) IS "UA " HBTEST LTrim( " "+Chr(0)+" UA " ) IS ""+Chr(0)+" UA " HBTEST LTrim( " "+Chr(9)+" UA " ) IS "UA " HBTEST LTrim( " "+Chr(9)+"U"+Chr(9)) IS "U"+Chr(9)+"" HBTEST LTrim( " "+Chr(9)+Chr(9)) IS "" HBTEST LTrim( Chr(10)+"U"+Chr(10)) IS "U"+Chr(10)+"" HBTEST LTrim( Chr(13)+"U"+Chr(13)) IS "U"+Chr(13)+"" HBTEST LTrim( "A"+Chr(10)) IS "A"+Chr(10)+"" HBTEST LTrim( "A"+Chr(13)) IS "A"+Chr(13)+"" HBTEST LTrim( " "+Chr(0)+"ABC"+Chr(0)+" ") IS ""+Chr(0)+"ABC"+Chr(0)+" " /* StrTran() */ /* TODO: StrTran() */ /* NOTE: It seems like CA-Cl*pper 5.x is not aware of the BREAK return value of the error handler, so the error is thrown, but we can't catch it. This bug is fixed in CA-Cl*pper 5.3 [vszakats] */ #ifndef __CLIPPER__ #ifndef __XPP__ HBTEST StrTran() IS "E 1 BASE 1126 Argument error (STRTRAN) OS:0 #:0 F:S" /* CA-Cl*pper bug, it will exit on this */ HBTEST StrTran( NIL ) IS "E 1 BASE 1126 Argument error (STRTRAN) OS:0 #:0 A:1:U:NIL F:S" /* CA-Cl*pper bug, it will exit on this */ HBTEST StrTran( 100 ) IS "E 1 BASE 1126 Argument error (STRTRAN) OS:0 #:0 A:1:N:100 F:S" /* CA-Cl*pper bug, it will exit on this */ #endif HBTEST StrTran( "AA", 1 ) IS "E 1 BASE 1126 Argument error (STRTRAN) OS:0 #:0 A:2:C:AA;N:1 F:S" /* CA-Cl*pper bug, it will exit on this */ #endif HBTEST StrTran( "AA", "A" ) IS "" HBTEST StrTran( "AA", "A", "1" ) IS "11" HBTEST StrTran( "AA", "A", "1", "2" ) IS "11" /* Upper() */ HBTEST Upper( scString ) IS "HELLO" #ifdef __HARBOUR__ HBTEST Upper( @scString ) IS "HELLO" /* Bug in CA-Cl*pper, it will return argument error */ #endif HBTEST Upper( 100 ) IS "E 1 BASE 1102 Argument error (UPPER) OS:0 #:0 A:1:N:100 F:S" HBTEST Upper( "" ) IS "" HBTEST Upper( " " ) IS " " HBTEST Upper( "2" ) IS "2" HBTEST Upper( "{" ) IS "{" HBTEST Upper( Chr(0) ) IS ""+Chr(0)+"" HBTEST Upper( "aAZAZa" ) IS "AAZAZA" HBTEST Upper( "AazazA" ) IS "AAZAZA" HBTEST Upper( "Aaz"+Chr(0)+"zA" ) IS "AAZ"+Chr(0)+"ZA" HBTEST Upper( "z" ) IS "Z" HBTEST Upper( " µ" ) IS " µ" HBTEST Upper( "H rbor 8-) µ" ) IS "H RBOR 8-) µ" /* Lower() */ HBTEST Lower( scString ) IS "hello" #ifdef __HARBOUR__ HBTEST Lower( @scString ) IS "hello" /* Bug in CA-Cl*pper, it will return argument error */ #endif HBTEST Lower( 100 ) IS "E 1 BASE 1103 Argument error (LOWER) OS:0 #:0 A:1:N:100 F:S" HBTEST Lower( "" ) IS "" HBTEST Lower( " " ) IS " " HBTEST Lower( "2" ) IS "2" HBTEST Lower( "{" ) IS "{" HBTEST Lower( Chr(0) ) IS ""+Chr(0)+"" HBTEST Lower( "aAZAZa" ) IS "aazaza" HBTEST Lower( "AazazA" ) IS "aazaza" HBTEST Lower( "Aaz"+Chr(0)+"zA" ) IS "aaz"+Chr(0)+"za" HBTEST Lower( "z" ) IS "z" HBTEST Lower( " µ" ) IS " µ" HBTEST Lower( "H rbor 8-) µ" ) IS "h rbor 8-) µ" /* At() */ HBTEST At(90, 100) IS "E 1 BASE 1108 Argument error (AT) OS:0 #:0 A:2:N:90;N:100 F:S" HBTEST At("", 100) IS "E 1 BASE 1108 Argument error (AT) OS:0 #:0 A:2:C:;N:100 F:S" HBTEST At(100, "") IS "E 1 BASE 1108 Argument error (AT) OS:0 #:0 A:2:N:100;C: F:S" /* disable Harbour extensions in compiler to replicate Clipper bugs */ #ifdef __HARBOUR__ #pragma -kh- #endif HBTEST At("", "") IS 1 /* Bug in CA-Cl*ppers compiler optimizer, it should return 0 */ HBTEST At("", "ABCDEF") IS 1 /* Bug in CA-Cl*ppers compiler optimizer, it should return 0 */ #ifdef __HARBOUR__ /* enable Harbour extensions and test correct results results */ #pragma -kh+ HBTEST At("", "") IS 0 /* Bug in CA-Cl*ppers compiler optimizer, it should return 0 */ HBTEST At("", "ABCDEF") IS 0 /* Bug in CA-Cl*ppers compiler optimizer, it should return 0 */ #endif HBTEST At(scStringE, scStringE) IS 0 HBTEST At(scStringE, "ABCDEF") IS 0 HBTEST At("ABCDEF", "") IS 0 HBTEST At("AB", "AB") IS 1 HBTEST At("AB", "AAB") IS 2 HBTEST At("A", "ABCDEF") IS 1 HBTEST At("F", "ABCDEF") IS 6 HBTEST At("D", "ABCDEF") IS 4 HBTEST At("X", "ABCDEF") IS 0 HBTEST At("AB", "ABCDEF") IS 1 HBTEST At("AA", "ABCDEF") IS 0 HBTEST At("ABCDEF", "ABCDEF") IS 1 HBTEST At("BCDEF", "ABCDEF") IS 2 HBTEST At("BCDEFG", "ABCDEF") IS 0 HBTEST At("ABCDEFG", "ABCDEF") IS 0 HBTEST At("FI", "ABCDEF") IS 0 /* RAt() */ HBTEST RAt(90, 100) IS 0 HBTEST RAt("", 100) IS 0 HBTEST RAt(100, "") IS 0 HBTEST RAt("", "") IS 0 HBTEST RAt("", "ABCDEF") IS 0 HBTEST RAt("ABCDEF", "") IS 0 HBTEST RAt("AB", "AB") IS 1 HBTEST RAt("AB", "AAB") IS 2 HBTEST RAt("AB", "ABAB") IS 3 HBTEST RAt("A", "ABCADEF") IS 4 HBTEST RAt("A", "ABCADEFA") IS 8 HBTEST RAt("A", "ABCDEFA") IS 7 HBTEST RAt("A", "ABCDEF") IS 1 HBTEST RAt("F", "ABCDEF") IS 6 HBTEST RAt("D", "ABCDEF") IS 4 HBTEST RAt("X", "ABCDEF") IS 0 HBTEST RAt("AB", "ABCDEF") IS 1 HBTEST RAt("AA", "ABCDEF") IS 0 HBTEST RAt("ABCDEF", "ABCDEF") IS 1 HBTEST RAt("BCDEF", "ABCDEF") IS 2 HBTEST RAt("BCDEFG", "ABCDEF") IS 0 HBTEST RAt("ABCDEFG", "ABCDEF") IS 0 HBTEST RAt("FI", "ABCDEF") IS 0 /* Replicate() */ #ifdef __HARBOUR__ IF l64 HBTEST Replicate("XXX", 9000000000000000000) IS "E 3 BASE 1234 String overflow (REPLICATE) OS:0 #:0 A:2:C:XXX;N:9000000000000000000 F:S" ELSE HBTEST Replicate("XXX", 2000000000) IS "E 3 BASE 1234 String overflow (REPLICATE) OS:0 #:0 A:2:C:XXX;N:2000000000 F:S" ENDIF #else HBTEST Replicate("XXX", 30000) IS "E 3 BASE 1234 String overflow (REPLICATE) OS:0 #:0 A:2:C:XXX;N:30000 F:S" #endif HBTEST Replicate(200 , 0 ) IS "E 1 BASE 1106 Argument error (REPLICATE) OS:0 #:0 A:2:N:200;N:0 F:S" HBTEST Replicate("" , 10 ) IS "" HBTEST Replicate("" , 0 ) IS "" HBTEST Replicate("A" , "B" ) IS "E 1 BASE 1106 Argument error (REPLICATE) OS:0 #:0 A:2:C:A;C:B F:S" HBTEST Replicate("A" , 1 ) IS "A" HBTEST Replicate("A" , 2 ) IS "AA" HBTEST Replicate("HE", 3 ) IS "HEHEHE" HBTEST Replicate("HE", 3.1 ) IS "HEHEHE" HBTEST Replicate("HE", 3.5 ) IS "HEHEHE" HBTEST Replicate("HE", 3.7 ) IS "HEHEHE" HBTEST Replicate("HE", -3 ) IS "" HBTEST Replicate("H"+Chr(0), 2 ) IS "H"+Chr(0)+"H"+Chr(0)+"" /* Space() */ HBTEST Space( "A" ) IS "E 1 BASE 1105 Argument error (SPACE) OS:0 #:0 A:1:C:A F:S" HBTEST Space( 0 ) IS "" HBTEST Space( -10 ) IS "" HBTEST Space( 10 ) IS " " HBTEST Space( 10.2 ) IS " " HBTEST Space( 10.5 ) IS " " HBTEST Space( 10.7 ) IS " " /* SubStr() */ HBTEST SubStr(100 , 0, -1) IS "E 1 BASE 1110 Argument error (SUBSTR) OS:0 #:0 A:3:N:100;N:0;N:-1 F:S" HBTEST SubStr("abcdef", 1, "a") IS "E 1 BASE 1110 Argument error (SUBSTR) OS:0 #:0 A:3:C:abcdef;N:1;C:a F:S" HBTEST SubStr("abcdef", "a") IS "E 1 BASE 1110 Argument error (SUBSTR) OS:0 #:0 A:2:C:abcdef;C:a F:S" HBTEST SubStr("abcdef", "a", 1) IS "E 1 BASE 1110 Argument error (SUBSTR) OS:0 #:0 A:3:C:abcdef;C:a;N:1 F:S" HBTEST SubStr("abcdef", 0, -1) IS "" HBTEST SubStr("abcdef", 0, 0) IS "" HBTEST SubStr("abcdef", 0, 1) IS "a" HBTEST SubStr("abcdef", 0, 7) IS "abcdef" HBTEST SubStr("abcdef", 0) IS "abcdef" HBTEST SubStr("abcdef", 2, -1) IS "" HBTEST SubStr("abcdef", 2, 0) IS "" HBTEST SubStr("abcdef", 2, 1) IS "b" HBTEST SubStr("abcdef", 2, 7) IS "bcdef" HBTEST SubStr("abcdef", 2) IS "bcdef" #ifndef __XPP__ HBTEST SubStr("abcdef", -2, -1) IS "" HBTEST SubStr("abcdef", -2, 0) IS "" HBTEST SubStr("abcdef", -2, 1) IS "e" HBTEST SubStr("abcdef", -2, 7) IS "ef" HBTEST SubStr("abcdef", -2) IS "ef" #endif HBTEST SubStr("abcdef", 10, -1) IS "" HBTEST SubStr("abcdef", 10, 0) IS "" HBTEST SubStr("abcdef", 10, 1) IS "" HBTEST SubStr("abcdef", 10, 7) IS "" HBTEST SubStr("abcdef", 10) IS "" #ifndef __XPP__ HBTEST SubStr("abcdef", -10, -1) IS "" HBTEST SubStr("abcdef", -10, 0) IS "" HBTEST SubStr("abcdef", -10, 1) IS "a" HBTEST SubStr("abcdef", -10, 7) IS "abcdef" HBTEST SubStr("abcdef", -10, 15) IS "abcdef" HBTEST SubStr("abcdef", -10) IS "abcdef" #endif HBTEST SubStr("ab" + Chr(0) + "def", 2, 3) IS "b" + Chr(0) + "d" HBTEST SubStr("abc" + Chr(0) + "def", 3, 1) IS "c" HBTEST SubStr("abc" + Chr(0) + "def", 4, 1) IS "" + Chr(0) + "" HBTEST SubStr("abc" + Chr(0) + "def", 5, 1) IS "d" /* Left() */ HBTEST Left(100 , -10) IS "E 1 BASE 1124 Argument error (LEFT) OS:0 #:0 A:2:N:100;N:-10 F:S" HBTEST Left("abcdef", "A") IS "E 1 BASE 1124 Argument error (LEFT) OS:0 #:0 A:2:C:abcdef;C:A F:S" HBTEST Left("abcdef", -10) IS "" HBTEST Left("abcdef", -2) IS "" HBTEST Left("abcdef", 0) IS "" HBTEST Left("abcdef", 2) IS "ab" HBTEST Left("abcdef", 10) IS "abcdef" HBTEST Left("ab" + Chr(0) + "def", 5) IS "ab" + Chr(0) + "de" /* Right() */ HBTEST Right(100 , -10) IS "" HBTEST Right("abcdef", "A") IS "" HBTEST Right("abcdef", -10) IS "" HBTEST Right("abcdef", -2) IS "" HBTEST Right("abcdef", 0) IS "" HBTEST Right("abcdef", 2) IS "ef" HBTEST Right("abcdef", 10) IS "abcdef" HBTEST Right("ab" + Chr(0) + "def", 5) IS "b" + Chr(0) + "def" /* PadR() */ HBTEST Pad(NIL, 5) IS "" HBTEST Pad(.T., 5) IS "" HBTEST Pad(10, 5) IS "10 " HBTEST Pad(10.2, 5) IS "10.2 " HBTEST Pad(100000, 8) IS "100000 " HBTEST Pad(100000, 8, "-") IS "100000--" HBTEST Pad(-100000, 8, "-") IS "-100000-" HBTEST Pad(5000000000, 15) IS "5000000000 " HBTEST Pad(hb_SToD("19840325"), 12) IS "1984.03.25 " HBTEST Pad(Year(hb_SToD("19840325")), 5) IS "1984 " HBTEST Pad(Day(hb_SToD("19840325")), 5) IS "25 " #ifdef __HARBOUR__ HBTEST Pad(@scString, 10) IS "HELLO " /* Bug in CA-Cl*pper, it will return "" */ HBTEST Pad(scString, @snIntP) IS "HELLO " /* Bug in CA-Cl*pper, it will return "" */ #endif #ifndef __XPP__ HBTEST Pad("abcdef", "A") IS "" HBTEST Pad("abcdef", -5) IS "" #endif HBTEST Pad("abcdef", 0) IS "" HBTEST Pad("abcdef", 5) IS "abcde" HBTEST Pad("abcdef", 10) IS "abcdef " HBTEST Pad("abcdef", 10, "") IS "abcdef"+Chr(0)+""+Chr(0)+""+Chr(0)+""+Chr(0)+"" HBTEST Pad("abcdef", 10, "1") IS "abcdef1111" HBTEST Pad("abcdef", 10, "12") IS "abcdef1111" /* PadR() */ HBTEST PadR(NIL, 5) IS "" HBTEST PadR(.T., 5) IS "" HBTEST PadR(10, 5) IS "10 " HBTEST PadR(10.2, 5) IS "10.2 " HBTEST PadR(100000, 8) IS "100000 " HBTEST PadR(100000, 8, "-") IS "100000--" HBTEST PadR(-100000, 8, "-") IS "-100000-" HBTEST PadR(hb_SToD("19840325"), 12) IS "1984.03.25 " HBTEST PadR(Year(hb_SToD("19840325")), 5) IS "1984 " HBTEST PadR(Day(hb_SToD("19840325")), 5) IS "25 " #ifdef __HARBOUR__ HBTEST PadR(@scString, 10) IS "HELLO " /* Bug in CA-Cl*pper, it will return "" */ HBTEST PadR(scString, @snIntP) IS "HELLO " /* Bug in CA-Cl*pper, it will return "" */ #endif #ifndef __XPP__ HBTEST PadR("abcdef", "A") IS "" HBTEST PadR("abcdef", -5) IS "" #endif HBTEST PadR("abcdef", 0) IS "" HBTEST PadR("abcdef", 5) IS "abcde" HBTEST PadR("abcdef", 10) IS "abcdef " HBTEST PadR("abcdef", 10, "") IS "abcdef"+Chr(0)+""+Chr(0)+""+Chr(0)+""+Chr(0)+"" HBTEST PadR("abcdef", 10, "1") IS "abcdef1111" HBTEST PadR("abcdef", 10, "12") IS "abcdef1111" /* PadL() */ HBTEST PadL(NIL, 5) IS "" HBTEST PadL(.T., 5) IS "" HBTEST PadL(10, 5) IS " 10" HBTEST PadL(10.2, 5) IS " 10.2" HBTEST PadL(100000, 8) IS " 100000" HBTEST PadL(100000, 8, "-") IS "--100000" HBTEST PadL(-100000, 8, "-") IS "--100000" HBTEST PadL(hb_SToD("19840325"), 12) IS " 1984.03.25" HBTEST PadL(Year(hb_SToD("19840325")), 5) IS " 1984" HBTEST PadL(Day(hb_SToD("19840325")), 5) IS " 25" #ifdef __HARBOUR__ HBTEST PadL(@scString, 10) IS " HELLO" /* Bug in CA-Cl*pper, it will return "" */ HBTEST PadL(scString, @snIntP) IS " HELLO" /* Bug in CA-Cl*pper, it will return "" */ #endif #ifndef __XPP__ HBTEST PadL("abcdef", "A") IS "" HBTEST PadL("abcdef", -5) IS "" #endif HBTEST PadL("abcdef", 0) IS "" HBTEST PadL("abcdef", 5) IS "abcde" /* QUESTION: CA-Cl*pper "bug", should return: "bcdef" ? */ HBTEST PadL("abcdef", 10) IS " abcdef" HBTEST PadL("abcdef", 10, "") IS ""+Chr(0)+""+Chr(0)+""+Chr(0)+""+Chr(0)+"abcdef" HBTEST PadL("abcdef", 10, "1") IS "1111abcdef" HBTEST PadL("abcdef", 10, "12") IS "1111abcdef" /* PadC() */ HBTEST PadC(NIL, 5) IS "" HBTEST PadC(.T., 5) IS "" HBTEST PadC(10, 5) IS " 10 " HBTEST PadC(10.2, 5) IS "10.2 " HBTEST PadC(100000, 8) IS " 100000 " HBTEST PadC(100000, 8, "-") IS "-100000-" HBTEST PadC(-100000, 8, "-") IS "-100000-" HBTEST PadC(hb_SToD("19840325"), 12) IS " 1984.03.25 " HBTEST PadC(Year(hb_SToD("19840325")), 5) IS "1984 " HBTEST PadC(Day(hb_SToD("19840325")), 5) IS " 25 " #ifdef __HARBOUR__ HBTEST PadC(@scString, 10) IS " HELLO " /* Bug in CA-Cl*pper, it will return "" */ HBTEST PadC(scString, @snIntP) IS " HELLO " /* Bug in CA-Cl*pper, it will return "" */ #endif #ifndef __XPP__ HBTEST PadC("abcdef", "A") IS "" HBTEST PadC("abcdef", -5) IS "" #endif HBTEST PadC("abcdef", 0) IS "" HBTEST PadC("abcdef", 2) IS "ab" /* QUESTION: CA-Cl*pper "bug", should return: "cd" ? */ HBTEST PadC("abcdef", 5) IS "abcde" HBTEST PadC("abcdef", 10) IS " abcdef " HBTEST PadC("abcdef", 10, "") IS ""+Chr(0)+""+Chr(0)+"abcdef"+Chr(0)+""+Chr(0)+"" HBTEST PadC("abcdef", 10, "1") IS "11abcdef11" HBTEST PadC("abcdef", 10, "12") IS "11abcdef11" /* Stuff() */ #ifndef __XPP__ HBTEST Stuff() IS "" HBTEST Stuff( 100 ) IS "" #endif HBTEST Stuff("ABCDEF", -6, -5, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", -6, -2, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", -6, 0, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", -6, 10, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", -6, 30, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", -2, -5, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", -2, -2, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", -2, 0, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", -2, 10, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", -2, 30, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", 0, -5, NIL) IS "" HBTEST Stuff("ABCDEF", 0, -2, "xyz") IS "xyz" HBTEST Stuff("ABCDEF", 0, 0, "xyz") IS "xyzABCDEF" HBTEST Stuff("ABCDEF", 0, 10, "xyz") IS "xyz" HBTEST Stuff("ABCDEF", 0, 30, "xyz") IS "xyz" HBTEST Stuff("ABCDEF", 1, -5, "xyz") IS "xyz" HBTEST Stuff("ABCDEF", 1, -2, "xyz") IS "xyz" HBTEST Stuff("ABCDEF", 1, 0, "xyz") IS "xyzABCDEF" HBTEST Stuff("ABCDEF", 1, 10, "xyz") IS "xyz" HBTEST Stuff("ABCDEF", 1, 30, "xyz") IS "xyz" HBTEST Stuff("ABCDEF", 2, 0, "xyz") IS "AxyzBCDEF" HBTEST Stuff("ABCDEF", 2, 3, "" ) IS "AEF" HBTEST Stuff("ABCDEF", 2, 3, "xyz") IS "AxyzEF" HBTEST Stuff("ABCDEF", 2, 2, "") IS "ADEF" HBTEST Stuff("ABCDEF", 2, -5, "xyz") IS "Axyz" HBTEST Stuff("ABCDEF", 2, -2, "xyz") IS "Axyz" HBTEST Stuff("ABCDEF", 2, 1, "xyz") IS "AxyzCDEF" HBTEST Stuff("ABCDEF", 2, 4, "xyz") IS "AxyzF" HBTEST Stuff("ABCDEF", 2, 10, "xyz") IS "Axyz" HBTEST Stuff("ABCDEF", 2, 30, "xyz") IS "Axyz" HBTEST Stuff("ABCDEF", 30, -5, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", 30, -2, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", 30, 0, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", 30, 10, "xyz") IS "ABCDEFxyz" HBTEST Stuff("ABCDEF", 30, 30, "xyz") IS "ABCDEFxyz" HBTEST Stuff(@scString , 2, 3, "xyz") IS "HxyzO" HBTEST Stuff("ABC"+Chr(0)+"EF", 2, 3, "xyz") IS "AxyzEF" HBTEST Stuff("ABCE"+Chr(0)+"F", 2, 3, "xyz") IS "Axyz"+Chr(0)+"F" HBTEST Stuff("ABC"+Chr(0)+"EF", 2, 3, "x"+Chr(0)+"z") IS "Ax"+Chr(0)+"zEF" RETURN /* Don't change the position of this #include. */ #include "rt_init.ch"