/* * $Id$ */ /* Harbour Project source code Runtime library regression tests, currently for some of the string manipulating functions. Copyright (C) 1999 Victor Szel www - http://www.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 of the License, or (at your option) any later version, with one exception: The exception is that if you link the Harbour Runtime Library (HRL) and/or the Harbour Virtual Machine (HVM) 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 HRL and/or HVM code into it. 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 program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA (or visit their web site at http://www.gnu.org/). */ /* TRANSFORM() tests written by Eddie Runia */ /* EMPTY() tests written by Eddie Runia */ /* :class* tests written by Dave Pearson */ /* NOTE: Always compile with /n switch */ /* NOTE: It's worth to make tests with and without the /z switch */ /* NOTE: Guard all Harbour extensions with __HARBOUR__ #ifdefs */ /* TODO: Add checks for string parameters with embedded NUL character */ /* TODO: Add test cases for other string functions */ /* TODO: Incorporate tests from test/working/string*.prg */ /* TODO: String overflow on + and - tests */ /* TODO: Tests with MEMO type ? */ /* TODO: Tests with Log(0) type of invalid values */ #include "error.ch" #translate TEST_LINE( , ) => TEST_CALL( <(x)>, {|| }, ) STATIC s_nPass STATIC s_nFail STATIC s_cFileName STATIC s_nFhnd STATIC s_cNewLine STATIC s_nCount STATIC s_lShowAll STATIC s_lShortcut STATIC s_aSkipList STATIC s_nStartTime STATIC s_nEndTime STATIC scString STATIC scStringE STATIC scStringZ STATIC snIntZ STATIC snDoubleZ STATIC snIntP STATIC snLongP STATIC snDoubleP STATIC snIntN STATIC snLongN STATIC snDoubleN STATIC snDoubleI STATIC sdDate STATIC sdDateE STATIC slFalse STATIC slTrue STATIC soObject STATIC suNIL STATIC sbBlock STATIC sbBlockC STATIC saArray STATIC saAllTypes MEMVAR mxNotHere MEMVAR mcString MEMVAR mcStringE MEMVAR mcStringZ MEMVAR mnIntZ MEMVAR mnDoubleZ MEMVAR mnIntP MEMVAR mnLongP MEMVAR mnDoubleP MEMVAR mnDoubleI MEMVAR mnIntN MEMVAR mnLongN MEMVAR mnDoubleN MEMVAR mdDate MEMVAR mdDateE MEMVAR mlFalse MEMVAR mlTrue MEMVAR moObject MEMVAR muNIL MEMVAR mbBlock MEMVAR mbBlockC MEMVAR maArray FUNCTION Main( cPar1, cPar2 ) /* Initialize test */ IF cPar1 == NIL cPar1 := "" ENDIF IF cPar2 == NIL cPar2 := "" ENDIF TEST_BEGIN( cPar1 + " " + cPar2 ) Main_HVM() Main_MATH() Main_STRINGS() Main_MISC() /* Show results, return ERRORLEVEL and exit */ TEST_END() RETURN NIL STATIC FUNCTION Main_HVM() /* NOTE: CA-Cl*pper PP fails on these TEST_LINE( "1" .AND. "2" , "E BASE 1066 Argument error conditional " ) TEST_LINE( "1" .AND. .F. , .F. ) TEST_LINE( "A" > 1 , "E BASE 1075 Argument error > F:S" ) */ /* VALTYPE() */ TEST_LINE( ValType( scString ) , "C" ) TEST_LINE( ValType( scStringE ) , "C" ) TEST_LINE( ValType( scStringZ ) , "C" ) TEST_LINE( ValType( snIntZ ) , "N" ) TEST_LINE( ValType( snDoubleZ ) , "N" ) TEST_LINE( ValType( snIntP ) , "N" ) TEST_LINE( ValType( snLongP ) , "N" ) TEST_LINE( ValType( snDoubleP ) , "N" ) TEST_LINE( ValType( snIntN ) , "N" ) TEST_LINE( ValType( snLongN ) , "N" ) TEST_LINE( ValType( snDoubleN ) , "N" ) TEST_LINE( ValType( snDoubleI ) , "N" ) TEST_LINE( ValType( sdDateE ) , "D" ) TEST_LINE( ValType( slFalse ) , "L" ) TEST_LINE( ValType( slTrue ) , "L" ) TEST_LINE( ValType( soObject ) , "O" ) TEST_LINE( ValType( suNIL ) , "U" ) TEST_LINE( ValType( sbBlock ) , "B" ) TEST_LINE( ValType( saArray ) , "A" ) #ifdef __HARBOUR__ TEST_LINE( ValType( @scString ) , "C" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @scStringE ) , "C" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @scStringZ ) , "C" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @snIntZ ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @snDoubleZ ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @snIntP ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @snLongP ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @snDoubleP ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @snIntN ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @snLongN ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @snDoubleN ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @snDoubleI ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @sdDateE ) , "D" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @slFalse ) , "L" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @slTrue ) , "L" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @soObject ) , "O" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @suNIL ) , "U" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @sbBlock ) , "B" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @saArray ) , "A" ) /* Bug in CA-Cl*pper, it will return "U" */ #endif TEST_LINE( ValType( mcString ) , "C" ) TEST_LINE( ValType( mcStringE ) , "C" ) TEST_LINE( ValType( mcStringZ ) , "C" ) TEST_LINE( ValType( mnIntZ ) , "N" ) TEST_LINE( ValType( mnDoubleZ ) , "N" ) TEST_LINE( ValType( mnIntP ) , "N" ) TEST_LINE( ValType( mnLongP ) , "N" ) TEST_LINE( ValType( mnDoubleP ) , "N" ) TEST_LINE( ValType( mnIntN ) , "N" ) TEST_LINE( ValType( mnLongN ) , "N" ) TEST_LINE( ValType( mnDoubleN ) , "N" ) TEST_LINE( ValType( mnDoubleI ) , "N" ) TEST_LINE( ValType( mdDateE ) , "D" ) TEST_LINE( ValType( mlFalse ) , "L" ) TEST_LINE( ValType( mlTrue ) , "L" ) TEST_LINE( ValType( moObject ) , "O" ) TEST_LINE( ValType( muNIL ) , "U" ) TEST_LINE( ValType( mbBlock ) , "B" ) TEST_LINE( ValType( maArray ) , "A" ) #ifdef __HARBOUR__ TEST_LINE( ValType( @mcString ) , "C" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mcStringE ) , "C" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mcStringZ ) , "C" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mnIntZ ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mnDoubleZ ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mnIntP ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mnLongP ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mnDoubleP ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mnIntN ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mnLongN ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mnDoubleN ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mnDoubleI ) , "N" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mdDateE ) , "D" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mlFalse ) , "L" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mlTrue ) , "L" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @moObject ) , "O" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @muNIL ) , "U" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @mbBlock ) , "B" ) /* Bug in CA-Cl*pper, it will return "U" */ TEST_LINE( ValType( @maArray ) , "A" ) /* Bug in CA-Cl*pper, it will return "U" */ #endif /* Special internal messages */ /* Harbour compiler not yet handles these */ #ifndef __HARBOUR__ TEST_LINE( NIL:className , "NIL" ) TEST_LINE( "":className , "CHARACTER" ) TEST_LINE( 0:className , "NUMERIC" ) TEST_LINE( ctod( "" ):className , "DATE" ) TEST_LINE( .F.:className , "LOGICAL" ) TEST_LINE( {|| nil }:className , "BLOCK" ) TEST_LINE( {}:className , "ARRAY" ) TEST_LINE( ErrorNew():className , "ERROR" ) TEST_LINE( NIL:classH , 0 ) TEST_LINE( "":classH , 0 ) TEST_LINE( 0:classH , 0 ) TEST_LINE( ctod( "" ):classH , 0 ) TEST_LINE( .F.:classH , 0 ) TEST_LINE( {|| nil }:classH , 0 ) TEST_LINE( {}:classH , 0 ) TEST_LINE( ErrorNew():classH > 0 , .T. ) #endif ) /* Harbour compiler not yet handles these */ #ifndef __HARBOUR__ TEST_LINE( suNIL:className , "NIL" ) #endif TEST_LINE( scString:className , "CHARACTER" ) TEST_LINE( snIntP:className , "NUMERIC" ) TEST_LINE( sdDateE:className , "DATE" ) TEST_LINE( slFalse:className , "LOGICAL" ) TEST_LINE( sbBlock:className , "BLOCK" ) TEST_LINE( saArray:className , "ARRAY" ) TEST_LINE( soObject:className , "ERROR" ) /* Harbour compiler not yet handles these */ #ifndef __HARBOUR__ TEST_LINE( suNIL:classH , 0 ) #endif TEST_LINE( scString:classH , 0 ) TEST_LINE( snIntP:classH , 0 ) TEST_LINE( sdDateE:classH , 0 ) TEST_LINE( slFalse:classH , 0 ) TEST_LINE( sbBlock:classH , 0 ) TEST_LINE( saArray:classH , 0 ) TEST_LINE( soObject:classH > 0 , .T. ) /* (operators) */ TEST_LINE( 2 <= 1 , .F. ) TEST_LINE( 1 <= 2 , .T. ) TEST_LINE( 2.0 <= 2 , .T. ) TEST_LINE( 2 <= 2.0 , .T. ) TEST_LINE( 2.5 <= 3.7 , .T. ) TEST_LINE( 3.7 <= 2.5 , .F. ) TEST_LINE( .F. <= .F. , .T. ) TEST_LINE( .T. <= .F. , .F. ) TEST_LINE( .F. <= .T. , .T. ) TEST_LINE( SToD("") <= SToD("") , .T. ) TEST_LINE( SToD("") <= SToD("19800101") , .T. ) TEST_LINE( SToD("19800101") <= SToD("") , .F. ) TEST_LINE( 2 < 1 , .F. ) TEST_LINE( 1 < 2 , .T. ) TEST_LINE( 2.0 < 2 , .F. ) TEST_LINE( 2 < 2.0 , .F. ) TEST_LINE( 2.5 < 3.7 , .T. ) TEST_LINE( 3.7 < 2.5 , .F. ) TEST_LINE( .F. < .F. , .F. ) TEST_LINE( .T. < .F. , .F. ) TEST_LINE( .F. < .T. , .T. ) TEST_LINE( SToD("") < SToD("") , .F. ) TEST_LINE( SToD("") < SToD("19800101") , .T. ) TEST_LINE( SToD("19800101") < SToD("") , .F. ) TEST_LINE( 2 >= 1 , .T. ) TEST_LINE( 1 >= 2 , .F. ) TEST_LINE( 2.0 >= 2 , .T. ) TEST_LINE( 2 >= 2.0 , .T. ) TEST_LINE( 2.5 >= 3.7 , .F. ) TEST_LINE( 3.7 >= 2.5 , .T. ) TEST_LINE( .F. >= .F. , .T. ) TEST_LINE( .T. >= .F. , .T. ) TEST_LINE( .F. >= .T. , .F. ) TEST_LINE( SToD("") >= SToD("") , .T. ) TEST_LINE( SToD("") >= SToD("19800101") , .F. ) TEST_LINE( SToD("19800101") >= SToD("") , .T. ) TEST_LINE( 2 > 1 , .T. ) TEST_LINE( 1 > 2 , .F. ) TEST_LINE( 2.0 > 2 , .F. ) TEST_LINE( 2 > 2.0 , .F. ) TEST_LINE( 2.5 > 3.7 , .F. ) TEST_LINE( 3.7 > 2.5 , .T. ) TEST_LINE( .F. > .F. , .F. ) TEST_LINE( .T. > .F. , .T. ) TEST_LINE( .F. > .T. , .F. ) TEST_LINE( SToD("") > SToD("") , .F. ) TEST_LINE( SToD("") > SToD("19800101") , .F. ) TEST_LINE( SToD("19800101") > SToD("") , .T. ) TEST_LINE( 1 + NIL , "E BASE 1081 Argument error + F:S" ) TEST_LINE( 1 - NIL , "E BASE 1082 Argument error - F:S" ) TEST_LINE( "A" - "B" , "AB" ) TEST_LINE( "A " - "B" , "AB " ) TEST_LINE( "A " - "B " , "AB " ) TEST_LINE( "A " - " B" , "A B " ) TEST_LINE( " " - "B " , "B " ) TEST_LINE( 1 / NIL , "E BASE 1084 Argument error / F:S" ) TEST_LINE( 1 * NIL , "E BASE 1083 Argument error * F:S" ) TEST_LINE( 1 ** NIL , "E BASE 1088 Argument error ^ F:S" ) /* NOTE: Harbour PP fails to process this line, so it's temporarly commented out */ #ifndef __HARBOUR__ TEST_LINE( 1 ^ NIL , "E BASE 1088 Argument error ^ F:S" ) #endif TEST_LINE( 1 % NIL , "E BASE 1085 Argument error % F:S" ) TEST_LINE( -Month(sdDate) , -1 ) TEST_LINE( Str(-(Month(sdDate))) , " -1" ) TEST_LINE( Str(-(Val("10"))) , " -10" ) TEST_LINE( Str(-(Val("100000"))) , " -100000" ) TEST_LINE( Str(-(Val("20.876"))) , " -20.876" ) TEST_LINE( -(0) , 0 ) TEST_LINE( -(10) , -10 ) TEST_LINE( -(10.505) , -10.505 ) TEST_LINE( -(100000) , -100000 ) TEST_LINE( -(-10) , 10 ) TEST_LINE( -("1") , "E BASE 1080 Argument error - F:S" ) /* NOTE: Harbour PP fails to process this line, so it's temporarly commented out */ #ifndef __HARBOUR__ TEST_LINE( "AA" $ 1 , "E BASE 1109 Argument error $ F:S" ) #endif TEST_LINE( scString $ 1 , "E BASE 1109 Argument error $ F:S" ) TEST_LINE( 1 $ "AA" , "E BASE 1109 Argument error $ F:S" ) IF TEST_OPT_Z() /* With the shortcut optimalization *ON* */ TEST_LINE( 1 .AND. 2 , "E BASE 1066 Argument error conditional " ) TEST_LINE( NIL .AND. NIL , "E BASE 1066 Argument error conditional " ) TEST_LINE( scString .AND. scString , "E BASE 1066 Argument error conditional " ) TEST_LINE( .T. .AND. 1 , 1 ) TEST_LINE( .T. .AND. 1.567 , 1.567 ) TEST_LINE( .T. .AND. scString , "HELLO" ) TEST_LINE( .T. .AND. SToD("") , SToD(" ") ) TEST_LINE( .T. .AND. NIL , NIL ) TEST_LINE( .T. .AND. {} , "{.[0].}" ) TEST_LINE( .T. .AND. {|| NIL } , "{||...}" ) TEST_LINE( .F. .AND. 1 , .F. ) TEST_LINE( .F. .AND. 1.567 , .F. ) TEST_LINE( .F. .AND. scString , .F. ) TEST_LINE( .F. .AND. SToD("") , .F. ) TEST_LINE( .F. .AND. NIL , .F. ) TEST_LINE( .F. .AND. {} , .F. ) TEST_LINE( .F. .AND. {|| NIL } , .F. ) TEST_LINE( 1 .AND. .F. , .F. ) TEST_LINE( 1.567 .AND. .F. , .F. ) TEST_LINE( scString .AND. .F. , .F. ) /* With the shortcut optimalization *OFF* (/z switch) */ TEST_LINE( 1 .OR. 2 , "E BASE 1066 Argument error conditional " ) TEST_LINE( .F. .OR. 2 , 2 ) TEST_LINE( .F. .OR. 1.678 , 1.678 ) TEST_LINE( .F. .OR. scString , "HELLO" ) TEST_LINE( .T. .OR. 2 , .T. ) TEST_LINE( .T. .OR. 1.678 , .T. ) TEST_LINE( .T. .OR. scString , .T. ) TEST_LINE( 1 .OR. .F. , 1 ) TEST_LINE( 1.0 .OR. .F. , 1.0 ) TEST_LINE( scString .OR. .F. , "HELLO" ) ELSE TEST_LINE( 1 .AND. 2 , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( NIL .AND. NIL , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( scString .AND. scString , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .T. .AND. 1 , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .T. .AND. 1.567 , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .T. .AND. scString , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .T. .AND. SToD("") , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .T. .AND. NIL , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .T. .AND. {} , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .T. .AND. {|| NIL } , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .F. .AND. 1 , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .F. .AND. 1.567 , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .F. .AND. scString , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .F. .AND. SToD("") , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .F. .AND. NIL , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .F. .AND. {} , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( .F. .AND. {|| NIL } , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( 1 .AND. .F. , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( 1.567 .AND. .F. , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( scString .AND. .F. , "E BASE 1078 Argument error .AND. F:S" ) TEST_LINE( 1 .OR. 2 , "E BASE 1079 Argument error .OR. F:S" ) TEST_LINE( .F. .OR. 2 , "E BASE 1079 Argument error .OR. F:S" ) TEST_LINE( .F. .OR. 1.678 , "E BASE 1079 Argument error .OR. F:S" ) TEST_LINE( .F. .OR. scString , "E BASE 1079 Argument error .OR. F:S" ) TEST_LINE( .T. .OR. 2 , "E BASE 1079 Argument error .OR. F:S" ) TEST_LINE( .T. .OR. 1.678 , "E BASE 1079 Argument error .OR. F:S" ) TEST_LINE( .T. .OR. scString , "E BASE 1079 Argument error .OR. F:S" ) TEST_LINE( 1 .OR. .F. , "E BASE 1079 Argument error .OR. F:S" ) TEST_LINE( 1.0 .OR. .F. , "E BASE 1079 Argument error .OR. F:S" ) TEST_LINE( scString .OR. .F. , "E BASE 1079 Argument error .OR. F:S" ) ENDIF TEST_LINE( .NOT. .T. , .F. ) TEST_LINE( .NOT. .F. , .T. ) TEST_LINE( .NOT. 1 , "E BASE 1077 Argument error .NOT. F:S" ) TEST_LINE( iif( "A", ":T:", ":F:" ) , "E BASE 1066 Argument error conditional " ) TEST_LINE( iif( .T., ":T:", ":F:" ) , ":T:" ) TEST_LINE( iif( .F., ":T:", ":F:" ) , ":F:" ) TEST_LINE( scString++ , "E BASE 1086 Argument error ++ F:S" ) TEST_LINE( scString-- , "E BASE 1087 Argument error -- F:S" ) TEST_LINE( mxNotHere , "E BASE 1003 Variable does not exist MXNOTHERE F:R" ) TEST_LINE( saArray[ 0 ] , "E BASE 1132 Bound error array access " ) TEST_LINE( saArray[ 0 ] := 1 , "E BASE 1133 Bound error array assign " ) TEST_LINE( saArray[ 1000 ] , "E BASE 1132 Bound error array access " ) TEST_LINE( saArray[ 1000 ] := 1 , "E BASE 1133 Bound error array assign " ) TEST_LINE( saArray[ -1 ] , "E BASE 1132 Bound error array access " ) TEST_LINE( saArray[ -1 ] := 1 , "E BASE 1133 Bound error array assign " ) TEST_LINE( saArray[ "1" ] , "E BASE 1068 Argument error array access F:S" ) TEST_LINE( saArray[ "1" ] := 1 , "E BASE 1069 Argument error array assign " ) TEST_LINE( scString > 1 , "E BASE 1075 Argument error > F:S" ) TEST_LINE( scString >= 1 , "E BASE 1076 Argument error >= F:S" ) TEST_LINE( scString <> 1 , "E BASE 1072 Argument error <> F:S" ) SET EXACT ON TEST_LINE( "123" = "123 " , .T. ) TEST_LINE( " 123" = "123" , .F. ) TEST_LINE( "123" = "12345" , .F. ) TEST_LINE( "12345" = "123" , .F. ) TEST_LINE( "123" = "" , .F. ) TEST_LINE( "" = "123" , .F. ) TEST_LINE( "A" == "A" , .T. ) TEST_LINE( "Z" == "A" , .F. ) TEST_LINE( "A" == "A " , .F. ) TEST_LINE( "AA" == "A" , .F. ) SET EXACT OFF TEST_LINE( "123" = "123 " , .F. ) TEST_LINE( " 123" = "123" , .F. ) TEST_LINE( "123" = "12345" , .F. ) TEST_LINE( "12345" = "123" , .T. ) TEST_LINE( "123" = "" , .T. ) TEST_LINE( "" = "123" , .F. ) TEST_LINE( "A" == "A" , .T. ) TEST_LINE( "Z" == "A" , .F. ) TEST_LINE( "A" == "A " , .F. ) TEST_LINE( "AA" == "A" , .F. ) TEST_LINE( scString = scString , .T. ) TEST_LINE( scString = scStringE , .T. ) TEST_LINE( scString = scStringZ , .F. ) TEST_LINE( scStringE = scString , .F. ) TEST_LINE( scStringE = scStringE , .T. ) TEST_LINE( scStringE = scStringZ , .F. ) TEST_LINE( scStringZ = scString , .F. ) TEST_LINE( scStringZ = scStringE , .T. ) TEST_LINE( scStringZ = scStringZ , .T. ) TEST_LINE( scString == 1 , "E BASE 1070 Argument error == F:S" ) TEST_LINE( soObject == soObject , .T. ) TEST_LINE( soObject = soObject , "E BASE 1071 Argument error = F:S" ) TEST_LINE( soObject == ErrorNew() , .F. ) TEST_LINE( soObject = ErrorNew() , "E BASE 1071 Argument error = F:S" ) TEST_LINE( ErrorNew() == ErrorNew() , .F. ) TEST_LINE( ErrorNew() = ErrorNew() , "E BASE 1071 Argument error = F:S" ) TEST_LINE( soObject == TBColumnNew() , .F. ) TEST_LINE( soObject = TBColumnNew() , "E BASE 1071 Argument error = F:S" ) TEST_LINE( saArray == saArray , .T. ) TEST_LINE( saArray = saArray , "E BASE 1071 Argument error = F:S" ) TEST_LINE( {} == {} , .F. ) TEST_LINE( {} = {} , "E BASE 1071 Argument error = F:S" ) TEST_LINE( {|| NIL } == {|| NIL } , "E BASE 1070 Argument error == F:S" ) TEST_LINE( {|| NIL } = {|| NIL } , "E BASE 1071 Argument error = F:S" ) TEST_LINE( scString = 1 , "E BASE 1071 Argument error = F:S" ) TEST_LINE( scString < 1 , "E BASE 1073 Argument error < F:S" ) TEST_LINE( scString <= 1 , "E BASE 1074 Argument error <= F:S" ) /* NOTE: TEST_CALL() should be used here, since CA-Cl*pper can't preprocess the TEST_LINE() variation properly. */ // TEST_LINE( ("NOTHERE")->NOFIELD , "E BASE 1002 Alias does not exist NOTHERE F:R" ) // TEST_LINE( (mcString)->NOFIELD , "E BASE 1002 Alias does not exist NOTHERE F:R" ) // TEST_LINE( ({})->NOFIELD , "E BASE 1002 Alias does not exist NOTHERE F:R" ) // TEST_LINE( ({|| NIL })->NOFIELD , "E BASE 1002 Alias does not exist NOTHERE F:R" ) // TEST_LINE( (.T.)->NOFIELD , "E BASE 1002 Alias does not exist NOTHERE F:R" ) TEST_CALL( '("NOTHERE")->NOFIELD', {|| ("NOTHERE")->NOFIELD }, "E BASE 1002 Alias does not exist NOTHERE F:R" ) TEST_CALL( '(mcString)->NOFIELD' , {|| (mcString)->NOFIELD } , "E BASE 1002 Alias does not exist HELLO F:R" ) TEST_CALL( '({})->NOFIELD' , {|| ({})->NOFIELD } , "E BASE 1065 Argument error & F:S" ) TEST_CALL( '({|| NIL })->NOFIELD', {|| ({|| NIL })->NOFIELD }, "E BASE 1065 Argument error & F:S" ) TEST_CALL( '(.T.)->NOFIELD' , {|| (.T.)->NOFIELD } , "E BASE 1065 Argument error & F:S" ) TEST_CALL( '(NIL)->NOFIELD' , {|| (NIL)->NOFIELD } , "E BASE 1065 Argument error & F:S" ) TEST_CALL( '("NOTHERE")->(Eof())', {|| ("NOTHERE")->(Eof()) }, .T. ) TEST_CALL( '(mcString)->(Eof())' , {|| (mcString)->(Eof()) } , .T. ) TEST_CALL( '({})->(Eof())' , {|| ({})->(Eof()) } , .T. ) TEST_CALL( '({|| NIL })->(Eof())', {|| ({|| NIL })->(Eof()) }, .T. ) TEST_CALL( '(.T.)->(Eof())' , {|| (.T.)->(Eof()) } , .T. ) TEST_CALL( '(.F.)->(Eof())' , {|| (.F.)->(Eof()) } , .T. ) TEST_CALL( '(NIL)->(Eof())' , {|| (NIL)->(Eof()) } , .T. ) #ifndef __HARBOUR__ TEST_LINE( NOTHERE->NOFIELD , "E BASE 1002 Alias does not exist NOTHERE F:R" ) #endif TEST_LINE( 200->NOFIELD , "E BASE 1003 Variable does not exist NOFIELD F:R" ) TEST_LINE( 200->("NOFIELD") , "NOFIELD" ) TEST_LINE( 200->(NIL) , NIL ) TEST_LINE( 200->(1) , 1 ) TEST_LINE( 200->(1.5) , 1.5 ) TEST_LINE( 200->({}) , "{.[0].}" ) TEST_LINE( 200->({|| NIL }) , "{||...}" ) TEST_LINE( 200->(.T.) , .T. ) TEST_LINE( soObject:hello , "E BASE 1004 No exported method HELLO F:S" ) TEST_LINE( soObject:hello := 1 , "E BASE 1005 No exported variable HELLO F:S" ) /* LEN() */ TEST_LINE( Len( NIL ) , "E BASE 1111 Argument error LEN F:S" ) TEST_LINE( Len( 123 ) , "E BASE 1111 Argument error LEN F:S" ) TEST_LINE( Len( "" ) , 0 ) TEST_LINE( Len( "123" ) , 3 ) TEST_LINE( Len( saArray ) , 1 ) #ifdef __HARBOUR__ TEST_LINE( Len( Space( 3000000000 ) ) , 3000000000 ) #else TEST_LINE( Len( Space( 40000 ) ) , 40000 ) #endif /* EMPTY() */ #ifdef __HARBOUR__ TEST_LINE( Empty( @scString ) , .F. ) /* Bug in CA-Cl*pper, it will return .T. */ TEST_LINE( Empty( @scStringE ) , .T. ) TEST_LINE( Empty( @snIntP ) , .F. ) /* Bug in CA-Cl*pper, it will return .T. */ TEST_LINE( Empty( @snIntZ ) , .T. ) #endif TEST_LINE( Empty( "Hallo" ) , .F. ) TEST_LINE( Empty( "" ) , .T. ) TEST_LINE( Empty( " " ) , .T. ) TEST_LINE( Empty( " "+Chr(0) ) , .F. ) TEST_LINE( Empty( " "+Chr(13)+Chr(9) ) , .T. ) TEST_LINE( Empty( " A" ) , .F. ) TEST_LINE( Empty( " x " ) , .F. ) TEST_LINE( Empty( " x"+Chr(0) ) , .F. ) TEST_LINE( Empty( " "+Chr(13)+"x"+Chr(9) ) , .F. ) TEST_LINE( Empty( 0 ) , .T. ) TEST_LINE( Empty( -0 ) , .T. ) TEST_LINE( Empty( 0.0 ) , .T. ) TEST_LINE( Empty( 70000-70000 ) , .T. ) TEST_LINE( Empty( 1.5*1.5-2.25 ) , .T. ) TEST_LINE( Empty( 10 ) , .F. ) TEST_LINE( Empty( 10.0 ) , .F. ) TEST_LINE( Empty( 70000+70000 ) , .F. ) TEST_LINE( Empty( 1.5*1.5*2.25 ) , .F. ) TEST_LINE( Empty( SToD("18241010") ) , .F. ) TEST_LINE( Empty( SToD("18250231") ) , .T. ) TEST_LINE( Empty( SToD("99999999") ) , .T. ) TEST_LINE( Empty( SToD(" ") ) , .T. ) TEST_LINE( Empty( SToD("") ) , .T. ) TEST_LINE( Empty( .T. ) , .F. ) TEST_LINE( Empty( .F. ) , .T. ) TEST_LINE( Empty( NIL ) , .T. ) TEST_LINE( Empty( {1} ) , .F. ) TEST_LINE( Empty( {} ) , .T. ) TEST_LINE( Empty( {0} ) , .F. ) TEST_LINE( Empty( {|x|x+x} ) , .F. ) RETURN NIL STATIC FUNCTION Main_MATH() /* LOG() */ TEST_LINE( Log("A") , "E BASE 1095 Argument error LOG F:S" ) TEST_LINE( Str(Log(snIntP)) , " 2.30" ) #ifdef __HARBOUR__ TEST_LINE( Str(Log(@snIntP)) , " 2.30" ) /* Bug in CA-Cl*pper, it returns: "E BASE 1095 Argument error LOG F:S" */ #endif /* SQRT() */ TEST_LINE( Sqrt("A") , "E BASE 1097 Argument error SQRT F:S" ) TEST_LINE( Sqrt(-1) , 0 ) TEST_LINE( Sqrt(0) , 0 ) TEST_LINE( Sqrt(4) , 2 ) TEST_LINE( Str(Sqrt(snIntP)) , " 3.16" ) #ifdef __HARBOUR__ TEST_LINE( Str(Sqrt(@snIntP)) , " 3.16" ) /* Bug in CA-Cl*pper, it returns: "E BASE 1097 Argument error SQRT F:S" */ #endif TEST_LINE( Str(Sqrt(4),21,18) , " 2.000000000000000000" ) TEST_LINE( Str(Sqrt(3),21,18) , " 1.732050807568877000" ) /* ABS() */ TEST_LINE( Abs("A") , "E BASE 1089 Argument error ABS F:S" ) TEST_LINE( Abs(0) , 0 ) TEST_LINE( Abs(10) , 10 ) TEST_LINE( Abs(-10) , 10 ) TEST_LINE( Str(Abs(snIntN)) , " 10" ) #ifdef __HARBOUR__ TEST_LINE( Str(Abs(@snIntN)) , " 10" ) /* Bug in CA-Cl*pper, it returns: "E BASE 1089 Argument error ABS F:S" */ #endif TEST_LINE( Abs(Month(sdDate)) , 1 ) TEST_LINE( Abs(-Month(sdDate)) , 1 ) TEST_LINE( Str(Abs(Month(sdDate))) , " 1" ) TEST_LINE( Str(Abs(-Month(sdDate))) , " 1" ) TEST_LINE( Str(Abs(Val("0"))) , "0" ) TEST_LINE( Str(Abs(Val("-0"))) , " 0" ) TEST_LINE( Str(Abs(Val("150"))) , "150" ) TEST_LINE( Str(Abs(Val("-150"))) , " 150" ) TEST_LINE( Str(Abs(Val("150.245"))) , " 150.245" ) TEST_LINE( Str(Abs(Val("-150.245"))) , " 150.245" ) TEST_LINE( Abs(0.1) , 0.1 ) TEST_LINE( Abs(10.5) , 10.5 ) TEST_LINE( Abs(-10.7) , 10.7 ) TEST_LINE( Abs(10.578) , 10.578 ) TEST_LINE( Abs(-10.578) , 10.578 ) TEST_LINE( Abs(100000) , 100000 ) TEST_LINE( Abs(-100000) , 100000 ) /* EXP() */ TEST_LINE( Exp("A") , "E BASE 1096 Argument error EXP F:S" ) TEST_LINE( Exp(0) , 1.00 ) TEST_LINE( Str(Exp(snIntZ)) , " 1.00" ) #ifdef __HARBOUR__ TEST_LINE( Str(Exp(@snIntZ)) , " 1.00" ) /* Bug in CA-Cl*pper, it returns: "E BASE 1096 Argument error EXP F:S" */ #endif TEST_LINE( Round(Exp(1),2) , 2.72 ) TEST_LINE( Str(Exp(1),20,10) , " 2.7182818285" ) TEST_LINE( Round(Exp(10),2) , 22026.47 ) TEST_LINE( Str(Exp(10),20,10) , " 22026.4657948067" ) /* ROUND() */ TEST_LINE( Round(snDoubleP, snIntZ) , 11 ) #ifdef __HARBOUR__ TEST_LINE( Round(@snDoubleP, @snIntZ) , 11 ) /* Bug in CA-Cl*pper, it returns: "E BASE 1094 Argument error ROUND F:S" */ #endif TEST_LINE( Round(NIL, 0) , "E BASE 1094 Argument error ROUND F:S" ) TEST_LINE( Round(0, NIL) , "E BASE 1094 Argument error ROUND F:S" ) TEST_LINE( Round(0, 0) , 0 ) TEST_LINE( Round(0, 2) , 0.00 ) TEST_LINE( Round(0, -2) , 0 ) TEST_LINE( Round(0.5, 0) , 1 ) TEST_LINE( Round(0.5, 1) , 0.5 ) TEST_LINE( Round(0.5, 2) , 0.50 ) TEST_LINE( Round(0.5, -1) , 0 ) TEST_LINE( Round(0.5, -2) , 0 ) TEST_LINE( Round(0.50, 0) , 1 ) TEST_LINE( Round(0.50, 1) , 0.5 ) TEST_LINE( Round(0.50, 2) , 0.50 ) TEST_LINE( Round(0.50, -1) , 0 ) TEST_LINE( Round(0.50, -2) , 0 ) TEST_LINE( Round(0.55, 0) , 1 ) TEST_LINE( Round(0.55, 1) , 0.6 ) TEST_LINE( Round(0.55, 2) , 0.55 ) TEST_LINE( Round(0.55, -1) , 0 ) TEST_LINE( Round(0.55, -2) , 0 ) TEST_LINE( Round(0.557, 0) , 1 ) TEST_LINE( Round(0.557, 1) , 0.6 ) TEST_LINE( Round(0.557, 2) , 0.56 ) TEST_LINE( Round(0.557, -1) , 0 ) TEST_LINE( Round(0.557, -2) , 0 ) TEST_LINE( Round(50, 0) , 50 ) TEST_LINE( Round(50, 1) , 50.0 ) TEST_LINE( Round(50, 2) , 50.00 ) TEST_LINE( Round(50, -1) , 50 ) TEST_LINE( Round(50, -2) , 100 ) TEST_LINE( Round(10.50, 0) , 11 ) TEST_LINE( Round(10.50, -1) , 10 ) TEST_LINE( Round(500000, 0) , 500000 ) TEST_LINE( Round(500000, 1) , 500000.0 ) TEST_LINE( Round(500000, 2) , 500000.00 ) TEST_LINE( Round(500000, -1) , 500000 ) TEST_LINE( Round(500000, -2) , 500000 ) TEST_LINE( Round(500000, -2) , 500000 ) TEST_LINE( Round(5000000000, 0) , 5000000000 ) TEST_LINE( Round(5000000000, 1) , 5000000000.0 ) TEST_LINE( Round(5000000000, 2) , 5000000000.00 ) TEST_LINE( Round(5000000000, -1) , 5000000000 ) TEST_LINE( Round(5000000000, -2) , 5000000000 ) TEST_LINE( Round(5000000000, -2) , 5000000000 ) TEST_LINE( Round(5000000000.129, 0) , 5000000000 ) TEST_LINE( Round(5000000000.129, 1) , 5000000000.1 ) TEST_LINE( Round(5000000000.129, 2) , 5000000000.13 ) TEST_LINE( Round(5000000000.129, -1) , 5000000000 ) TEST_LINE( Round(5000000000.129, -2) , 5000000000 ) TEST_LINE( Round(5000000000.129, -2) , 5000000000 ) TEST_LINE( Round(-0.5, 0) , -1 ) TEST_LINE( Round(-0.5, 1) , -0.5 ) TEST_LINE( Round(-0.5, 2) , -0.50 ) TEST_LINE( Round(-0.5, -1) , 0 ) TEST_LINE( Round(-0.5, -2) , 0 ) TEST_LINE( Round(-0.50, 0) , -1 ) TEST_LINE( Round(-0.50, 1) , -0.5 ) TEST_LINE( Round(-0.50, 2) , -0.50 ) TEST_LINE( Round(-0.50, -1) , 0 ) TEST_LINE( Round(-0.50, -2) , 0 ) TEST_LINE( Round(-0.55, 0) , -1 ) TEST_LINE( Round(-0.55, 1) , -0.6 ) TEST_LINE( Round(-0.55, 2) , -0.55 ) TEST_LINE( Round(-0.55, -1) , 0 ) TEST_LINE( Round(-0.55, -2) , 0 ) TEST_LINE( Round(-0.557, 0) , -1 ) TEST_LINE( Round(-0.557, 1) , -0.6 ) TEST_LINE( Round(-0.557, 2) , -0.56 ) TEST_LINE( Round(-0.557, -1) , 0 ) TEST_LINE( Round(-0.557, -2) , 0 ) TEST_LINE( Round(-50, 0) , -50 ) TEST_LINE( Round(-50, 1) , -50.0 ) TEST_LINE( Round(-50, 2) , -50.00 ) TEST_LINE( Round(-50, -1) , -50 ) TEST_LINE( Round(-50, -2) , -100 ) TEST_LINE( Round(-10.50, 0) , -11 ) TEST_LINE( Round(-10.50, -1) , -10 ) TEST_LINE( Round(-500000, 0) , -500000 ) TEST_LINE( Round(-500000, 1) , -500000.0 ) TEST_LINE( Round(-500000, 2) , -500000.00 ) TEST_LINE( Round(-500000, -1) , -500000 ) TEST_LINE( Round(-500000, -2) , -500000 ) TEST_LINE( Round(-500000, -2) , -500000 ) TEST_LINE( Round(-5000000000, 0) , -5000000000 ) TEST_LINE( Round(-5000000000, 1) , -5000000000.0 ) TEST_LINE( Round(-5000000000, 2) , -5000000000.00 ) TEST_LINE( Round(-5000000000, -1) , -5000000000 ) TEST_LINE( Round(-5000000000, -2) , -5000000000 ) TEST_LINE( Round(-5000000000, -2) , -5000000000 ) TEST_LINE( Round(-5000000000.129, 0) , -5000000000 ) TEST_LINE( Round(-5000000000.129, 1) , -5000000000.1 ) TEST_LINE( Round(-5000000000.129, 2) , -5000000000.13 ) TEST_LINE( Round(-5000000000.129, -1) , -5000000000 ) TEST_LINE( Round(-5000000000.129, -2) , -5000000000 ) TEST_LINE( Round(-5000000000.129, -2) , -5000000000 ) /* INT() */ TEST_LINE( Int( NIL ) , "E BASE 1090 Argument error INT F:S" ) TEST_LINE( Int( "A" ) , "E BASE 1090 Argument error INT F:S" ) TEST_LINE( Int( {} ) , "E BASE 1090 Argument error INT F:S" ) TEST_LINE( Int( 0 ) , 0 ) TEST_LINE( Int( 0.0 ) , 0 ) TEST_LINE( Int( 10 ) , 10 ) TEST_LINE( Int( snIntP ) , 10 ) #ifdef __HARBOUR__ TEST_LINE( Int( @snIntP ) , 10 ) /* Bug in CA-Cl*pper, it returns: "E BASE 1090 Argument error INT F:S" */ #endif TEST_LINE( Int( -10 ) , -10 ) TEST_LINE( Int( 100000 ) , 100000 ) TEST_LINE( Int( -100000 ) , -100000 ) TEST_LINE( Int( 10.5 ) , 10 ) TEST_LINE( Int( -10.5 ) , -10 ) TEST_LINE( Str(Int(Val("100.290"))) , "100" ) TEST_LINE( Str(Int(Val(" 100.290"))) , " 100" ) TEST_LINE( Str(Int(Val(" 100"))) , " 100" ) TEST_LINE( Int(5000000000.90) , 5000000000 ) TEST_LINE( Int(-5000000000.90) , -5000000000 ) TEST_LINE( Int(5000000000) , 5000000000 ) TEST_LINE( Int(-5000000000) , -5000000000 ) TEST_LINE( Int(5000000000) / 100000 , 50000 ) TEST_LINE( Int(-5000000000) / 100000 , -50000 ) /* MIN()/MAX() */ TEST_LINE( Max(NIL, NIL) , "E BASE 1093 Argument error MAX F:S" ) TEST_LINE( Max(10, NIL) , "E BASE 1093 Argument error MAX F:S" ) TEST_LINE( Max(SToD("19800101"), 10) , "E BASE 1093 Argument error MAX F:S" ) TEST_LINE( Max(SToD("19800101"), SToD("19800101")) , SToD("19800101") ) TEST_LINE( Max(SToD("19800102"), SToD("19800101")) , SToD("19800102") ) TEST_LINE( Max(SToD("19800101"), SToD("19800102")) , SToD("19800102") ) TEST_LINE( Max(snIntP, snLongP) , 100000 ) #ifdef __HARBOUR__ TEST_LINE( Max(@snIntP, @snLongP) , 100000 ) /* Bug in CA-Cl*pper, it will return: "E BASE 1093 Argument error MAX F:S" */ #endif TEST_LINE( Min(NIL, NIL) , "E BASE 1092 Argument error MIN F:S" ) TEST_LINE( Min(10, NIL) , "E BASE 1092 Argument error MIN F:S" ) TEST_LINE( Min(SToD("19800101"), 10) , "E BASE 1092 Argument error MIN F:S" ) TEST_LINE( Min(SToD("19800101"), SToD("19800101")) , SToD("19800101") ) TEST_LINE( Min(SToD("19800102"), SToD("19800101")) , SToD("19800101") ) TEST_LINE( Min(SToD("19800101"), SToD("19800102")) , SToD("19800101") ) TEST_LINE( Min(snIntP, snLongP) , 10 ) #ifdef __HARBOUR__ TEST_LINE( Min(@snIntP, @snLongP) , 10 ) /* Bug in CA-Cl*pper, it will return: "E BASE 1092 Argument error MIN F:S" */ #endif /* Decimals handling */ TEST_LINE( Str(Max(10, 12) ) , " 12" ) TEST_LINE( Str(Max(10.50, 10) ) , " 10.50" ) TEST_LINE( Str(Max(10, 9.50) ) , " 10" ) TEST_LINE( Str(Max(100000, 10) ) , " 100000" ) TEST_LINE( Str(Max(20.50, 20.670) ) , " 20.670" ) TEST_LINE( Str(Max(20.5125, 20.670) ) , " 20.670" ) TEST_LINE( Str(Min(10, 12) ) , " 10" ) TEST_LINE( Str(Min(10.50, 10) ) , " 10" ) TEST_LINE( Str(Min(10, 9.50) ) , " 9.50" ) TEST_LINE( Str(Min(100000, 10) ) , " 10" ) TEST_LINE( Str(Min(20.50, 20.670) ) , " 20.50" ) TEST_LINE( Str(Min(20.5125, 20.670) ) , " 20.5125" ) TEST_LINE( Str(Val("0") ) , "0" ) TEST_LINE( Str(Val(" 0") ) , " 0" ) TEST_LINE( Str(Val("-0") ) , " 0" ) TEST_LINE( Str(Val("00") ) , " 0" ) TEST_LINE( Str(Val("1") ) , "1" ) TEST_LINE( Str(Val("15") ) , "15" ) TEST_LINE( Str(Val("200") ) , "200" ) TEST_LINE( Str(Val(" 200") ) , " 200" ) TEST_LINE( Str(Val("200 ") ) , " 200" ) TEST_LINE( Str(Val(" 200 ") ) , " 200" ) TEST_LINE( Str(Val("-200") ) , "-200" ) TEST_LINE( Str(Val(" -200") ) , " -200" ) TEST_LINE( Str(Val("-200 ") ) , " -200" ) TEST_LINE( Str(Val(" -200 ") ) , " -200" ) TEST_LINE( Str(Val("15.0") ) , "15.0" ) TEST_LINE( Str(Val("15.00") ) , "15.00" ) TEST_LINE( Str(Val("15.000") ) , "15.000" ) TEST_LINE( Str(Val("15.001 ") ) , "15.0010" ) TEST_LINE( Str(Year(SToD("19990905")) ) , " 1999" ) TEST_LINE( Str(Month(SToD("19990905")) ) , " 9" ) TEST_LINE( Str(Day(SToD("19990905")) ) , " 5" ) TEST_LINE( Str(10 ) , " 10" ) TEST_LINE( Str(15.0 ) , " 15.0" ) TEST_LINE( Str(10.1 ) , " 10.1" ) TEST_LINE( Str(15.00 ) , " 15.00" ) TEST_LINE( Str(Log(0) ) , "***********************" ) TEST_LINE( Str(100.2 * 200.12 ) , " 20052.024" ) TEST_LINE( Str(100.20 * 200.12 ) , " 20052.0240" ) TEST_LINE( Str(1000.2 * 200.12 ) , " 200160.024" ) TEST_LINE( Str(100/1000 ) , " 0.10" ) TEST_LINE( Str(100/100000 ) , " 0.00" ) TEST_LINE( Str(10 * 10 ) , " 100" ) TEST_LINE( Str(100 / 10 ) , " 10" ) TEST_LINE( Str(100 / 13 ) , " 7.69" ) TEST_LINE( Str(100.0 / 10 ) , " 10.00" ) TEST_LINE( Str(100.0 / 10.00 ) , " 10.00" ) TEST_LINE( Str(100.0 / 10.000 ) , " 10.00" ) TEST_LINE( Str(100 / 10.00 ) , " 10.00" ) TEST_LINE( Str(100 / 10.000 ) , " 10.00" ) TEST_LINE( Str(100.00 / 10.0 ) , " 10.00" ) TEST_LINE( Str(sdDate - sdDateE ) , " 2444240" ) TEST_LINE( Str(sdDate - sdDate ) , " 0" ) TEST_LINE( Str(1234567890 * 1234567890 ) , " 1524157875019052000" ) RETURN NIL STATIC FUNCTION Main_STRINGS() /* ALLTRIM() */ TEST_LINE( AllTrim("HELLO") , "HELLO" ) #ifdef __HARBOUR__ TEST_LINE( AllTrim(@scString) , "HELLO" ) /* CA-Cl*pper bug, it will terminate the program on this line. */ #endif /* AT() */ TEST_LINE( At("", "") , 1 ) TEST_LINE( At("", "ABCDEF") , 1 ) TEST_LINE( At("ABCDEF", "") , 0 ) TEST_LINE( At("AB", "AB") , 1 ) TEST_LINE( At("AB", "AAB") , 2 ) TEST_LINE( At("A", "ABCDEF") , 1 ) TEST_LINE( At("F", "ABCDEF") , 6 ) TEST_LINE( At("D", "ABCDEF") , 4 ) TEST_LINE( At("X", "ABCDEF") , 0 ) TEST_LINE( At("AB", "ABCDEF") , 1 ) TEST_LINE( At("AA", "ABCDEF") , 0 ) TEST_LINE( At("ABCDEF", "ABCDEF") , 1 ) TEST_LINE( At("BCDEF", "ABCDEF") , 2 ) TEST_LINE( At("BCDEFG", "ABCDEF") , 0 ) TEST_LINE( At("ABCDEFG", "ABCDEF") , 0 ) TEST_LINE( At("FI", "ABCDEF") , 0 ) /* RAT() */ TEST_LINE( RAt("", "") , 0 ) TEST_LINE( RAt("", "ABCDEF") , 0 ) TEST_LINE( RAt("ABCDEF", "") , 0 ) TEST_LINE( RAt("AB", "AB") , 1 ) TEST_LINE( RAt("AB", "AAB") , 2 ) TEST_LINE( RAt("AB", "ABAB") , 3 ) TEST_LINE( RAt("A", "ABCADEF") , 4 ) TEST_LINE( RAt("A", "ABCADEFA") , 8 ) TEST_LINE( RAt("A", "ABCDEFA") , 7 ) TEST_LINE( RAt("A", "ABCDEF") , 1 ) TEST_LINE( RAt("F", "ABCDEF") , 6 ) TEST_LINE( RAt("D", "ABCDEF") , 4 ) TEST_LINE( RAt("X", "ABCDEF") , 0 ) TEST_LINE( RAt("AB", "ABCDEF") , 1 ) TEST_LINE( RAt("AA", "ABCDEF") , 0 ) TEST_LINE( RAt("ABCDEF", "ABCDEF") , 1 ) TEST_LINE( RAt("BCDEF", "ABCDEF") , 2 ) TEST_LINE( RAt("BCDEFG", "ABCDEF") , 0 ) TEST_LINE( RAt("ABCDEFG", "ABCDEF") , 0 ) TEST_LINE( RAt("FI", "ABCDEF") , 0 ) /* REPLICATE() */ #ifdef __HARBOUR__ TEST_LINE( Replicate("XXX", 2000000000) , "E BASE 1234 String overflow REPLICATE F:S" ) #else TEST_LINE( Replicate("XXX", 30000) , "E BASE 1234 String overflow REPLICATE F:S" ) #endif /* SUBSTR() */ TEST_LINE( SubStr("abcdef", 0, -1) , "" ) TEST_LINE( SubStr("abcdef", 0, 0) , "" ) TEST_LINE( SubStr("abcdef", 0, 1) , "a" ) TEST_LINE( SubStr("abcdef", 0, 7) , "abcdef" ) TEST_LINE( SubStr("abcdef", 0) , "abcdef" ) TEST_LINE( SubStr("abcdef", 2, -1) , "" ) TEST_LINE( SubStr("abcdef", 2, 0) , "" ) TEST_LINE( SubStr("abcdef", 2, 1) , "b" ) TEST_LINE( SubStr("abcdef", 2, 7) , "bcdef" ) TEST_LINE( SubStr("abcdef", 2) , "bcdef" ) TEST_LINE( SubStr("abcdef", -2, -1) , "" ) TEST_LINE( SubStr("abcdef", -2, 0) , "" ) TEST_LINE( SubStr("abcdef", -2, 1) , "e" ) TEST_LINE( SubStr("abcdef", -2, 7) , "ef" ) TEST_LINE( SubStr("abcdef", -2) , "ef" ) TEST_LINE( SubStr("abcdef", 10, -1) , "" ) TEST_LINE( SubStr("abcdef", 10, 0) , "" ) TEST_LINE( SubStr("abcdef", 10, 1) , "" ) TEST_LINE( SubStr("abcdef", 10, 7) , "" ) TEST_LINE( SubStr("abcdef", 10) , "" ) TEST_LINE( SubStr("abcdef", -10, -1) , "" ) TEST_LINE( SubStr("abcdef", -10, 0) , "" ) TEST_LINE( SubStr("abcdef", -10, 1) , "a" ) TEST_LINE( SubStr("abcdef", -10, 7) , "abcdef" ) TEST_LINE( SubStr("abcdef", -10, 15) , "abcdef" ) TEST_LINE( SubStr("abcdef", -10) , "abcdef" ) TEST_LINE( SubStr("ab" + Chr(0) + "def", 2, 3) , "b" + Chr(0) + "d" ) /* LEFT() */ TEST_LINE( Left("abcdef", -10) , "" ) TEST_LINE( Left("abcdef", -2) , "" ) TEST_LINE( Left("abcdef", 0) , "" ) TEST_LINE( Left("abcdef", 2) , "ab" ) TEST_LINE( Left("abcdef", 10) , "abcdef" ) TEST_LINE( Left("ab" + Chr(0) + "def", 5) , "ab" + Chr(0) + "de" ) /* RIGHT() */ TEST_LINE( Right("abcdef", -10) , "" ) TEST_LINE( Right("abcdef", -2) , "" ) TEST_LINE( Right("abcdef", 0) , "" ) TEST_LINE( Right("abcdef", 2) , "ef" ) TEST_LINE( Right("abcdef", 10) , "abcdef" ) TEST_LINE( Right("ab" + Chr(0) + "def", 5) , "b" + Chr(0) + "def" ) /* PADR() */ TEST_LINE( Pad(NIL, 5) , "" ) TEST_LINE( Pad(.T., 5) , "" ) TEST_LINE( Pad(10, 5) , "10 " ) TEST_LINE( Pad(10.2, 5) , "10.2 " ) TEST_LINE( Pad(100000, 8) , "100000 " ) TEST_LINE( Pad(100000, 8, "-") , "100000--" ) TEST_LINE( Pad(-100000, 8, "-") , "-100000-" ) TEST_LINE( Pad(5000000000, 15) , "5000000000 ") TEST_LINE( Pad(SToD("19800101"), 12) , "1980.01.01 " ) TEST_LINE( Pad(Year(SToD("19800101")), 5) , "1980 " ) TEST_LINE( Pad(Day(SToD("19800101")), 5) , "1 " ) #ifdef __HARBOUR__ TEST_LINE( Pad(@scString, 10) , "HELLO " ) /* Bug in CA-Cl*pper, it will return "" */ TEST_LINE( Pad(scString, @snIntP) , "HELLO " ) /* Bug in CA-Cl*pper, it will return "" */ #endif TEST_LINE( Pad("abcdef", -5) , "" ) TEST_LINE( Pad("abcdef", 0) , "" ) TEST_LINE( Pad("abcdef", 5) , "abcde" ) TEST_LINE( Pad("abcdef", 10) , "abcdef " ) TEST_LINE( Pad("abcdef", 10, "1") , "abcdef1111" ) TEST_LINE( Pad("abcdef", 10, "12") , "abcdef1111" ) /* PADR() */ TEST_LINE( PadR(NIL, 5) , "" ) TEST_LINE( PadR(.T., 5) , "" ) TEST_LINE( PadR(10, 5) , "10 " ) TEST_LINE( PadR(10.2, 5) , "10.2 " ) TEST_LINE( PadR(100000, 8) , "100000 " ) TEST_LINE( PadR(100000, 8, "-") , "100000--" ) TEST_LINE( PadR(-100000, 8, "-") , "-100000-" ) TEST_LINE( PadR(SToD("19800101"), 12) , "1980.01.01 " ) TEST_LINE( PadR(Year(SToD("19800101")), 5) , "1980 " ) TEST_LINE( PadR(Day(SToD("19800101")), 5) , "1 " ) #ifdef __HARBOUR__ TEST_LINE( PadR(@scString, 10) , "HELLO " ) /* Bug in CA-Cl*pper, it will return "" */ TEST_LINE( PadR(scString, @snIntP) , "HELLO " ) /* Bug in CA-Cl*pper, it will return "" */ #endif TEST_LINE( PadR("abcdef", -5) , "" ) TEST_LINE( PadR("abcdef", 0) , "" ) TEST_LINE( PadR("abcdef", 5) , "abcde" ) TEST_LINE( PadR("abcdef", 10) , "abcdef " ) TEST_LINE( PadR("abcdef", 10, "1") , "abcdef1111" ) TEST_LINE( PadR("abcdef", 10, "12") , "abcdef1111" ) /* PADL() */ TEST_LINE( PadL(NIL, 5) , "" ) TEST_LINE( PadL(.T., 5) , "" ) TEST_LINE( PadL(10, 5) , " 10" ) TEST_LINE( PadL(10.2, 5) , " 10.2" ) TEST_LINE( PadL(100000, 8) , " 100000" ) TEST_LINE( PadL(100000, 8, "-") , "--100000" ) TEST_LINE( PadL(-100000, 8, "-") , "--100000" ) TEST_LINE( PadL(SToD("19800101"), 12) , " 1980.01.01" ) TEST_LINE( PadL(Year(SToD("19800101")), 5) , " 1980" ) TEST_LINE( PadL(Day(SToD("19800101")), 5) , " 1" ) #ifdef __HARBOUR__ TEST_LINE( PadL(@scString, 10) , " HELLO" ) /* Bug in CA-Cl*pper, it will return "" */ TEST_LINE( PadL(scString, @snIntP) , " HELLO" ) /* Bug in CA-Cl*pper, it will return "" */ #endif TEST_LINE( PadL("abcdef", -5) , "" ) TEST_LINE( PadL("abcdef", 0) , "" ) TEST_LINE( PadL("abcdef", 5) , "abcde" ) /* QUESTION: CA-Cl*pper "bug", should return: "bcdef" ? */ TEST_LINE( PadL("abcdef", 10) , " abcdef" ) TEST_LINE( PadL("abcdef", 10, "1") , "1111abcdef" ) TEST_LINE( PadL("abcdef", 10, "12") , "1111abcdef" ) /* PADC() */ TEST_LINE( PadC(NIL, 5) , "" ) TEST_LINE( PadC(.T., 5) , "" ) TEST_LINE( PadC(10, 5) , " 10 " ) TEST_LINE( PadC(10.2, 5) , "10.2 " ) TEST_LINE( PadC(100000, 8) , " 100000 " ) TEST_LINE( PadC(100000, 8, "-") , "-100000-" ) TEST_LINE( PadC(-100000, 8, "-") , "-100000-" ) TEST_LINE( PadC(SToD("19800101"), 12) , " 1980.01.01 " ) TEST_LINE( PadC(Year(SToD("19800101")), 5) , "1980 " ) TEST_LINE( PadC(Day(SToD("19800101")), 5) , " 1 " ) #ifdef __HARBOUR__ TEST_LINE( PadC(@scString, 10) , " HELLO " ) /* Bug in CA-Cl*pper, it will return "" */ TEST_LINE( PadC(scString, @snIntP) , " HELLO " ) /* Bug in CA-Cl*pper, it will return "" */ #endif TEST_LINE( PadC("abcdef", -5) , "" ) TEST_LINE( PadC("abcdef", 0) , "" ) TEST_LINE( PadC("abcdef", 2) , "ab" ) /* QUESTION: CA-Cl*pper "bug", should return: "cd" ? */ TEST_LINE( PadC("abcdef", 5) , "abcde" ) TEST_LINE( PadC("abcdef", 10) , " abcdef " ) TEST_LINE( PadC("abcdef", 10, "1") , "11abcdef11" ) TEST_LINE( PadC("abcdef", 10, "12") , "11abcdef11" ) /* STUFF() */ TEST_LINE( Stuff("ABCDEF", 0, 0, NIL) , "" ) TEST_LINE( Stuff("ABCDEF", 0, 0, "xyz") , "xyzABCDEF" ) TEST_LINE( Stuff("ABCDEF", 1, 0, "xyz") , "xyzABCDEF" ) TEST_LINE( Stuff("ABCDEF", 2, 0, "xyz") , "AxyzBCDEF" ) TEST_LINE( Stuff("ABCDEF", 2, 3, "xyz") , "AxyzEF" ) TEST_LINE( Stuff("ABCDEF", 2, 2, "") , "ADEF" ) TEST_LINE( Stuff("ABCDEF", 2, 1, "xyz") , "AxyzCDEF" ) TEST_LINE( Stuff("ABCDEF", 2, 4, "xyz") , "AxyzF" ) TEST_LINE( Stuff("ABCDEF", 2, 10, "xyz") , "Axyz" ) /* STR() */ TEST_LINE( Str(NIL) , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( Str("A", 10, 2) , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( Str(100, 10, "A") , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( Str(100, 10, NIL) , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( Str(100, NIL, NIL) , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( Str(5000000000.0) , "5000000000.0" ) TEST_LINE( Str(5000000000) , " 5000000000" ) TEST_LINE( Str(-5000000000.0) , " -5000000000.0" ) TEST_LINE( Str(-5000000000) , " -5000000000" ) TEST_LINE( Str(10) , " 10" ) TEST_LINE( Str(10.0) , " 10.0" ) TEST_LINE( Str(10.00) , " 10.00" ) TEST_LINE( Str(10.50) , " 10.50" ) TEST_LINE( Str(100000) , " 100000" ) TEST_LINE( Str(-10) , " -10" ) TEST_LINE( Str(-10.0) , " -10.0" ) TEST_LINE( Str(-10.00) , " -10.00" ) TEST_LINE( Str(-10.50) , " -10.50" ) TEST_LINE( Str(-100000) , " -100000" ) TEST_LINE( Str(10, 5) , " 10" ) TEST_LINE( Str(10.0, 5) , " 10" ) TEST_LINE( Str(10.00, 5) , " 10" ) TEST_LINE( Str(10.50, 5) , " 11" ) TEST_LINE( Str(100000, 5) , "*****" ) TEST_LINE( Str(100000, 8) , " 100000" ) TEST_LINE( Str(-10, 5) , " -10" ) TEST_LINE( Str(-10.0, 5) , " -10" ) TEST_LINE( Str(-10.00, 5) , " -10" ) TEST_LINE( Str(-10.50, 5) , " -11" ) TEST_LINE( Str(-100000, 5) , "*****" ) TEST_LINE( Str(-100000, 6) , "******" ) TEST_LINE( Str(-100000, 8) , " -100000" ) TEST_LINE( Str(10, -5) , " 10" ) TEST_LINE( Str(10.0, -5) , " 10" ) TEST_LINE( Str(10.00, -5) , " 10" ) TEST_LINE( Str(10.50, -5) , " 11" ) TEST_LINE( Str(100000, -5) , " 100000" ) TEST_LINE( Str(100000, -8) , " 100000" ) TEST_LINE( Str(-10, -5) , " -10" ) TEST_LINE( Str(-10.0, -5) , " -10" ) TEST_LINE( Str(-10.00, -5) , " -10" ) TEST_LINE( Str(-10.50, -5) , " -11" ) TEST_LINE( Str(-100000, -5) , " -100000" ) TEST_LINE( Str(-100000, -6) , " -100000" ) TEST_LINE( Str(-100000, -8) , " -100000" ) TEST_LINE( Str(10, 5, 0) , " 10" ) TEST_LINE( Str(10.0, 5, 0) , " 10" ) TEST_LINE( Str(10.00, 5, 0) , " 10" ) TEST_LINE( Str(10.50, 5, 0) , " 11" ) TEST_LINE( Str(100000, 5, 0) , "*****" ) TEST_LINE( Str(-10, 5, 0) , " -10" ) TEST_LINE( Str(-10.0, 5, 0) , " -10" ) TEST_LINE( Str(-10.00, 5, 0) , " -10" ) TEST_LINE( Str(-10.50, 5, 0) , " -11" ) TEST_LINE( Str(-100000, 5, 0) , "*****" ) TEST_LINE( Str(-100000, 6, 0) , "******" ) TEST_LINE( Str(-100000, 8, 0) , " -100000" ) TEST_LINE( Str(10, 5, 1) , " 10.0" ) TEST_LINE( Str(10.0, 5, 1) , " 10.0" ) TEST_LINE( Str(10.00, 5, 1) , " 10.0" ) TEST_LINE( Str(10.50, 5, 1) , " 10.5" ) TEST_LINE( Str(100000, 5, 1) , "*****" ) TEST_LINE( Str(-10, 5, 1) , "-10.0" ) TEST_LINE( Str(-10.0, 5, 1) , "-10.0" ) TEST_LINE( Str(-10.00, 5, 1) , "-10.0" ) TEST_LINE( Str(-10.50, 5, 1) , "-10.5" ) TEST_LINE( Str(-100000, 5, 1) , "*****" ) TEST_LINE( Str(-100000, 6, 1) , "******" ) TEST_LINE( Str(-100000, 8, 1) , "********" ) TEST_LINE( Str(10, 5, -1) , " 10" ) TEST_LINE( Str(10.0, 5, -1) , " 10" ) TEST_LINE( Str(10.00, 5, -1) , " 10" ) TEST_LINE( Str(10.50, 5, -1) , " 11" ) TEST_LINE( Str(100000, 5, -1) , "*****" ) TEST_LINE( Str(-10, 5, -1) , " -10" ) TEST_LINE( Str(-10.0, 5, -1) , " -10" ) TEST_LINE( Str(-10.00, 5, -1) , " -10" ) TEST_LINE( Str(-10.50, 5, -1) , " -11" ) TEST_LINE( Str(-100000, 5, -1) , "*****" ) TEST_LINE( Str(-100000, 6, -1) , "******" ) TEST_LINE( Str(-100000, 8, -1) , " -100000" ) /* STRZERO() */ TEST_LINE( StrZero(NIL) , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( StrZero("A", 10, 2) , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( StrZero(100, 10, "A") , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( StrZero(100, 10, NIL) , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( StrZero(100, NIL, NIL) , "E BASE 1099 Argument error STR F:S" ) TEST_LINE( StrZero(10) , "0000000010" ) TEST_LINE( StrZero(10.0) , "0000000010.0" ) TEST_LINE( StrZero(10.00) , "0000000010.00" ) TEST_LINE( StrZero(10.50) , "0000000010.50" ) TEST_LINE( StrZero(100000) , "0000100000" ) TEST_LINE( StrZero(-10) , "-000000010" ) TEST_LINE( StrZero(-10.0) , "-000000010.0" ) TEST_LINE( StrZero(-10.00) , "-000000010.00" ) TEST_LINE( StrZero(-10.50) , "-000000010.50" ) TEST_LINE( StrZero(-100000) , "-000100000" ) TEST_LINE( StrZero(10, 5) , "00010" ) TEST_LINE( StrZero(10.0, 5) , "00010" ) TEST_LINE( StrZero(10.00, 5) , "00010" ) TEST_LINE( StrZero(10.50, 5) , "00011" ) TEST_LINE( StrZero(100000, 5) , "*****" ) TEST_LINE( StrZero(100000, 8) , "00100000" ) TEST_LINE( StrZero(-10, 5) , "-0010" ) TEST_LINE( StrZero(-10.0, 5) , "-0010" ) TEST_LINE( StrZero(-10.00, 5) , "-0010" ) TEST_LINE( StrZero(-10.50, 5) , "-0011" ) TEST_LINE( StrZero(-100000, 5) , "*****" ) TEST_LINE( StrZero(-100000, 6) , "******" ) TEST_LINE( StrZero(-100000, 8) , "-0100000" ) TEST_LINE( StrZero(10, -5) , "0000000010" ) TEST_LINE( StrZero(10.0, -5) , "0000000010" ) TEST_LINE( StrZero(10.00, -5) , "0000000010" ) TEST_LINE( StrZero(10.50, -5) , "0000000011" ) TEST_LINE( StrZero(100000, -5) , "0000100000" ) TEST_LINE( StrZero(100000, -8) , "0000100000" ) TEST_LINE( StrZero(-10, -5) , "-000000010" ) TEST_LINE( StrZero(-10.0, -5) , "-000000010" ) TEST_LINE( StrZero(-10.00, -5) , "-000000010" ) TEST_LINE( StrZero(-10.50, -5) , "-000000011" ) TEST_LINE( StrZero(-100000, -5) , "-000100000" ) TEST_LINE( StrZero(-100000, -6) , "-000100000" ) TEST_LINE( StrZero(-100000, -8) , "-000100000" ) TEST_LINE( StrZero(10, 5, 0) , "00010" ) TEST_LINE( StrZero(10.0, 5, 0) , "00010" ) TEST_LINE( StrZero(10.50, 5, 0) , "00011" ) TEST_LINE( StrZero(100000, 5, 0) , "*****" ) TEST_LINE( StrZero(-10, 5, 0) , "-0010" ) TEST_LINE( StrZero(-10.0, 5, 0) , "-0010" ) TEST_LINE( StrZero(-10.00, 5, 0) , "-0010" ) TEST_LINE( StrZero(-10.50, 5, 0) , "-0011" ) TEST_LINE( StrZero(-100000, 5, 0) , "*****" ) TEST_LINE( StrZero(-100000, 6, 0) , "******" ) TEST_LINE( StrZero(-100000, 8, 0) , "-0100000" ) TEST_LINE( StrZero(10, 5, 1) , "010.0" ) TEST_LINE( StrZero(10.0, 5, 1) , "010.0" ) TEST_LINE( StrZero(10.50, 5, 1) , "010.5" ) TEST_LINE( StrZero(100000, 5, 1) , "*****" ) TEST_LINE( StrZero(-10, 5, 1) , "-10.0" ) TEST_LINE( StrZero(-10.0, 5, 1) , "-10.0" ) TEST_LINE( StrZero(-10.00, 5, 1) , "-10.0" ) TEST_LINE( StrZero(-10.50, 5, 1) , "-10.5" ) TEST_LINE( StrZero(-100000, 5, 1) , "*****" ) TEST_LINE( StrZero(-100000, 6, 1) , "******" ) TEST_LINE( StrZero(-100000, 8, 1) , "********" ) TEST_LINE( StrZero(10, 5, -1) , "00010" ) TEST_LINE( StrZero(10.0, 5, -1) , "00010" ) TEST_LINE( StrZero(10.50, 5, -1) , "00011" ) TEST_LINE( StrZero(100000, 5, -1) , "*****" ) TEST_LINE( StrZero(-10, 5, -1) , "-0010" ) TEST_LINE( StrZero(-10.0, 5, -1) , "-0010" ) TEST_LINE( StrZero(-10.00, 5, -1) , "-0010" ) TEST_LINE( StrZero(-10.50, 5, -1) , "-0011" ) TEST_LINE( StrZero(-100000, 5, -1) , "*****" ) TEST_LINE( StrZero(-100000, 6, -1) , "******" ) TEST_LINE( StrZero(-100000, 8, -1) , "-0100000" ) /* TRANSFORM() */ TEST_LINE( Transform( "Hallo ", "!!!!!" ) , "HALLO" ) TEST_LINE( Transform( "Hallo ", "!!A!!" ) , "HAlLO" ) TEST_LINE( Transform( "Hallo ", "!!A9!" ) , "HAllO" ) TEST_LINE( Transform( "Hallo ", "!QA9!" ) , "HQllO" ) TEST_LINE( Transform( "Hallo ", "ZQA9!" ) , "ZQllO" ) TEST_LINE( Transform( "Hall" , "ZQA9!" ) , "ZQll" ) TEST_LINE( Transform( "Hallo ", "!AAA" ) , "Hall" ) TEST_LINE( Transform( "Hallo ", "@!" ) , "HALLO " ) TEST_LINE( Transform( "Hallo ", "@! AA" ) , "HA" ) TEST_LINE( Transform( "Hallo ", "@R" ) , "Hallo " ) TEST_LINE( Transform( "Hallo ", "@Z" ) , " " ) TEST_LINE( Transform( "Hallo ", "@R !!" ) , "HA" ) TEST_LINE( Transform( "Hi" , "@R !!!" ) , "HI " ) TEST_LINE( Transform( "Hallo ", "" ) , "Hallo " ) TEST_LINE( Transform( .T. , "" ) , "T" ) TEST_LINE( Transform( .F. , "" ) , "F" ) TEST_LINE( Transform( .T. , "L" ) , "T" ) TEST_LINE( Transform( .F. , "L" ) , "F" ) TEST_LINE( Transform( .T. , "Y" ) , "Y" ) TEST_LINE( Transform( .F. , "Y" ) , "N" ) TEST_LINE( Transform( .T. , "X" ) , "X" ) TEST_LINE( Transform( .F. , "#" ) , "F" ) TEST_LINE( Transform( .T. , "X!" ) , "X" ) TEST_LINE( Transform( .F. , "@R Y" ) , "N" ) TEST_LINE( Transform( .T. , "@R X!" ) , "X!T" ) TEST_LINE( Transform( SToD("19901214") , "99/99/9999" ) , "1990.12.14" ) TEST_LINE( Transform( SToD("19901202") , "99.99.9999" ) , "1990.12.02" ) TEST_LINE( Transform( SToD("") , "99/99/9999" ) , " . . " ) TEST_LINE( Transform( SToD("19901202") , "99/99/99" ) , "1990.12.02" ) TEST_LINE( Transform( SToD("19901214") , "99-99-99" ) , "1990.12.14" ) TEST_LINE( Transform( SToD("20040430") , "99.99.99" ) , "2004.04.30" ) TEST_LINE( Transform( SToD("") , "99/99/99" ) , " . . " ) TEST_LINE( Transform( SToD("19920101") , "THISWRNG" ) , "1992.01.01" ) TEST_LINE( Transform( SToD("19350605") , "999/99/9" ) , "1935.06.05" ) TEST_LINE( Transform( SToD("19101112") , "9#-9#/##" ) , "1910.11.12" ) TEST_LINE( Transform( SToD("19920101") , "" ) , "1992.01.01" ) TEST_LINE( Transform( SToD("19920101") , "DO THIS " ) , "1992.01.01" ) TEST_LINE( Transform( SToD("19920102") , "@E" ) , "02/01/1992" ) /* Bug in CA-Cl*pper, it returns: "2.91901.02" */ TEST_LINE( Transform( 1234 , "@D 9999" ) , "1234.00.0 " ) TEST_LINE( Transform( 1234 , "@BD 9999" ) , "1234.00.0 " ) SET CENTURY OFF TEST_LINE( Transform( SToD("19901214") , "99/99/9999" ) , "90.12.14" ) TEST_LINE( Transform( SToD("19901202") , "99.99.9999" ) , "90.12.02" ) TEST_LINE( Transform( SToD("") , "99/99/9999" ) , " . . " ) TEST_LINE( Transform( SToD("19901202") , "99/99/99" ) , "90.12.02" ) TEST_LINE( Transform( SToD("19901214") , "99-99-99" ) , "90.12.14" ) TEST_LINE( Transform( SToD("20040430") , "99.99.99" ) , "04.04.30" ) TEST_LINE( Transform( SToD("") , "99/99/99" ) , " . . " ) TEST_LINE( Transform( SToD("19920101") , "THISWRNG" ) , "92.01.01" ) TEST_LINE( Transform( SToD("19350605") , "999/99/9" ) , "35.06.05" ) TEST_LINE( Transform( SToD("19101112") , "9#-9#/##" ) , "10.11.12" ) TEST_LINE( Transform( SToD("19920101") , "" ) , "92.01.01" ) TEST_LINE( Transform( SToD("19920101") , "DO THIS " ) , "92.01.01" ) TEST_LINE( Transform( SToD("19920102") , "@E" ) , "02/01/92" ) /* Bug in CA-Cl*pper, it returns: "01.92.02" */ TEST_LINE( Transform( 1234 , "@D 9999" ) , "**.**.* " ) TEST_LINE( Transform( 1234 , "@BD 9999" ) , "**.**.* " ) SET CENTURY ON TEST_LINE( Transform( 15 , "9999" ) , " 15" ) TEST_LINE( Transform( 1.5 , "99.99" ) , " 1.50" ) TEST_LINE( Transform( 1.5 , "9999" ) , " 2" ) TEST_LINE( Transform( 15 , "####" ) , " 15" ) TEST_LINE( Transform( 1.5 , "##.##" ) , " 1.50" ) TEST_LINE( Transform( 1.5 , "####" ) , " 2" ) TEST_LINE( Transform( 15 , " AX##" ) , " AX15" ) TEST_LINE( Transform( 1.5 , "!9XPA.9" ) , "!1XPA.5" ) TEST_LINE( Transform( -15 , "9999" ) , " -15" ) TEST_LINE( Transform( -1.5 , "99.99" ) , "-1.50" ) TEST_LINE( Transform( -15 , "$999" ) , "$-15" ) TEST_LINE( Transform( -1.5 , "*9.99" ) , "-1.50" ) TEST_LINE( Transform( 41 , "$$$9" ) , "$$41" ) TEST_LINE( Transform( 41 , "***9" ) , "**41" ) TEST_LINE( Transform( 15000 , "9999" ) , "****" ) TEST_LINE( Transform( 15000 , "99,999" ) , "15,000" ) TEST_LINE( Transform( 1500 , "99,999" ) , " 1,500" ) TEST_LINE( Transform( 150 , "99,999" ) , " 150" ) TEST_LINE( Transform( 150 , "99,99" ) , " 1,50" ) TEST_LINE( Transform( 41 , "@Z 9999" ) , " 41" ) TEST_LINE( Transform( 0 , "@Z 9999" ) , " " ) #ifdef __HARBOUR__ TEST_LINE( Transform( 41 , "@0 9999" ) , "0041" ) /* Extension in Harbour, in CA-Cl*pper it should return: " 41" */ TEST_LINE( Transform( 0 , "@0 9999" ) , "0000" ) /* Extension in Harbour, in CA-Cl*pper it should return: " 0" */ #endif TEST_LINE( Transform( 41 , "@B 9999" ) , "41 " ) TEST_LINE( Transform( 41 , "@B 99.9" ) , "41.0" ) TEST_LINE( Transform( 7 , "@B 99.9" ) , "7.0 " ) TEST_LINE( Transform( 7 , "@C 99.9" ) , " 7.0 CR" ) TEST_LINE( Transform( -7 , "@C 99.9" ) , "-7.0" ) TEST_LINE( Transform( 7 , "@X 99.9" ) , " 7.0" ) TEST_LINE( Transform( -7 , "@X 99.9" ) , " 7.0 DB" ) TEST_LINE( Transform( 7 , "@( 99.9" ) , " 7.0" ) TEST_LINE( Transform( -7 , "@( 99.9" ) , "(7.0)" ) TEST_LINE( Transform( 7 , "9X9Z5.9" ) , " X7Z5.0" ) TEST_LINE( Transform( -7 , "@R 9X9^" ) , "-X7^" ) TEST_LINE( Transform( -7 , "9X9^" ) , "-X7^" ) TEST_LINE( Transform( 1 , "@R 9HI!" ) , "1HI!" ) TEST_LINE( Transform( 1 , "9HI!" ) , "1HI!" ) TEST_LINE( Transform( -12 , "@( 99" ) , "(*)" ) /* Bug in CA-Cl*pper, it returns: "(2)" */ TEST_LINE( Transform( 12 , "@( 99" ) , "12" ) TEST_LINE( Transform( 1 , "" ) , " 1" ) TEST_LINE( Transform( 32768 , "" ) , " 32768" ) TEST_LINE( Transform( -20 , "" ) , " -20" ) TEST_LINE( Transform( 1048576 , "" ) , " 1048576" ) TEST_LINE( Transform( 21.65 , "" ) , " 21.65" ) TEST_LINE( Transform( -3.33 , "" ) , " -3.33" ) TEST_LINE( Transform( -1234 , "@( 9999" ) , "(***)" ) /* Bug in CA-Cl*pper, it returns: "(234)" */ TEST_LINE( Transform( -1234 , "@B 9999" ) , "****" ) TEST_LINE( Transform( -1234 , "@B( 9999" ) , "(***)" ) /* Bug in CA-Cl*pper, it returns: "(234)" */ TEST_LINE( Transform( 1234 , "@E 9,999.99" ) , "1.234,00" ) TEST_LINE( Transform( 12.2 , "@E 9,999.99" ) , " 12,20" ) TEST_LINE( Transform( -1234 , "@X 9999" ) , "1234 DB" ) TEST_LINE( Transform( -1234 , "@BX 9999" ) , "1234 DB" ) TEST_LINE( Transform( 1234 , "@B 9999" ) , "1234" ) TEST_LINE( Transform( 1234 , "@BX 9999" ) , "1234" ) TEST_LINE( Transform( 0 , "@Z 9999" ) , " " ) TEST_LINE( Transform( 0 , "@BZ 9999" ) , " " ) TEST_LINE( Transform( 2334 , "Xxxxx: #####") , "Xxxxx: 2334" ) RETURN NIL STATIC FUNCTION Main_MISC() /* ASCAN() */ TEST_LINE( aScan() , 0 ) TEST_LINE( aScan( NIL ) , 0 ) TEST_LINE( aScan( "A" ) , 0 ) TEST_LINE( aScan( "A", "A" ) , 0 ) TEST_LINE( aScan( "A", {|| .F. } ) , 0 ) TEST_LINE( aScan( {1,2,3}, {|x| NIL } ) , 0 ) TEST_LINE( aScan( saAllTypes, scString ) , 1 ) #ifdef __HARBOUR__ TEST_LINE( aScan( @saAllTypes, scString ) , 1 ) /* Bug in CA-Cl*pper, it will return 0 */ TEST_LINE( aScan( saAllTypes, @scString ) , 1 ) /* Bug in CA-Cl*pper, it will return 0 */ #endif TEST_LINE( aScan( saAllTypes, scStringE ) , 1 ) TEST_LINE( aScan( saAllTypes, scStringZ ) , 3 ) TEST_LINE( aScan( saAllTypes, snIntZ ) , 4 ) TEST_LINE( aScan( saAllTypes, snDoubleZ ) , 4 ) TEST_LINE( aScan( saAllTypes, snIntP ) , 6 ) TEST_LINE( aScan( saAllTypes, snLongP ) , 7 ) TEST_LINE( aScan( saAllTypes, snDoubleP ) , 8 ) TEST_LINE( aScan( saAllTypes, snIntN ) , 9 ) TEST_LINE( aScan( saAllTypes, snLongN ) , 10 ) TEST_LINE( aScan( saAllTypes, snDoubleN ) , 11 ) TEST_LINE( aScan( saAllTypes, snDoubleI ) , 12 ) TEST_LINE( aScan( saAllTypes, sdDateE ) , 13 ) TEST_LINE( aScan( saAllTypes, slFalse ) , 14 ) TEST_LINE( aScan( saAllTypes, slTrue ) , 15 ) TEST_LINE( aScan( saAllTypes, soObject ) , 0 ) TEST_LINE( aScan( saAllTypes, suNIL ) , 17 ) TEST_LINE( aScan( saAllTypes, sbBlock ) , 0 ) TEST_LINE( aScan( saAllTypes, sbBlockC ) , 0 ) TEST_LINE( aScan( saAllTypes, saArray ) , 0 ) SET EXACT ON TEST_LINE( aScan( saAllTypes, scString ) , 1 ) TEST_LINE( aScan( saAllTypes, scStringE ) , 2 ) TEST_LINE( aScan( saAllTypes, scStringZ ) , 3 ) SET EXACT OFF /* EVAL(), :EVAL */ TEST_LINE( Eval( NIL ) , "E BASE 1004 No exported method EVAL F:S" ) TEST_LINE( Eval( 1 ) , "E BASE 1004 No exported method EVAL F:S" ) #ifdef __HARBOUR__ TEST_LINE( Eval( @sbBlock ) , NIL ) /* Bug in CA-Cl*pper, it will return: "E BASE 1004 No exported method EVAL F:S" */ #endif TEST_LINE( Eval( {|p1| p1 },"A","B") , "A" ) TEST_LINE( Eval( {|p1,p2| p1+p2 },"A","B") , "AB" ) TEST_LINE( Eval( {|p1,p2,p3| p1 },"A","B") , "A" ) /* Harbour compiler not yet handles these */ #ifndef __HARBOUR__ TEST_LINE( suNIL:Eval , "E BASE 1004 No exported method EVAL F:S" ) #endif TEST_LINE( scString:Eval , "E BASE 1004 No exported method EVAL F:S" ) TEST_LINE( snIntP:Eval , "E BASE 1004 No exported method EVAL F:S" ) TEST_LINE( sdDateE:Eval , "E BASE 1004 No exported method EVAL F:S" ) TEST_LINE( slFalse:Eval , "E BASE 1004 No exported method EVAL F:S" ) TEST_LINE( sbBlock:Eval , NIL ) TEST_LINE( saArray:Eval , "E BASE 1004 No exported method EVAL F:S" ) TEST_LINE( soObject:Eval , "E BASE 1004 No exported method EVAL F:S" ) /* STOD() */ /* For these tests in CA-Cl*pper 5.2e the following native STOD() has been used ( not the emulated one written in Clipper ): CLIPPER STOD( void ) { // The length check is a fix to avoid buggy behaviour of _retds() _retds( ( ISCHAR( 1 ) && _parclen( 1 ) == 8 ) ? _parc( 1 ) : " " ); } */ TEST_LINE( SToD() , SToD(" ") ) TEST_LINE( SToD(1) , SToD(" ") ) TEST_LINE( SToD(NIL) , SToD(" ") ) TEST_LINE( SToD("") , SToD(" ") ) TEST_LINE( SToD(" ") , SToD(" ") ) TEST_LINE( SToD(" ") , SToD(" ") ) TEST_LINE( SToD(" ") , SToD(" ") ) TEST_LINE( SToD(" 1234567") , SToD(" ") ) TEST_LINE( SToD("1999 ") , SToD(" ") ) TEST_LINE( SToD("99999999") , SToD(" ") ) TEST_LINE( SToD("99990101") , SToD(" ") ) TEST_LINE( SToD("19991301") , SToD(" ") ) TEST_LINE( SToD("19991241") , SToD(" ") ) TEST_LINE( SToD("01000101") , SToD("01000101") ) TEST_LINE( SToD("29991231") , SToD("29991231") ) TEST_LINE( SToD("19990905") , SToD("19990905") ) TEST_LINE( SToD(" 9990905") , SToD(" ") ) TEST_LINE( SToD("1 990905") , SToD(" ") ) TEST_LINE( SToD("19 90905") , SToD("17490905") ) TEST_LINE( SToD("199 0905") , SToD("19740905") ) TEST_LINE( SToD("1999 905") , SToD(" ") ) TEST_LINE( SToD("19990 05") , SToD(" ") ) TEST_LINE( SToD("199909 5") , SToD(" ") ) TEST_LINE( SToD("1999090 ") , SToD(" ") ) TEST_LINE( SToD("1999 9 5") , SToD(" ") ) TEST_LINE( SToD("1999090" + Chr(0)) , SToD(" ") ) /* DESCEND() */ TEST_LINE( Descend() , NIL ) /* Bug in CA-Cl*pper, it returns undefined trash */ TEST_LINE( Descend( NIL ) , NIL ) TEST_LINE( Descend( { "A", "B" } ) , NIL ) #ifdef __HARBOUR__ TEST_LINE( Descend( @scString ) , "¸»´´±" ) /* Bug in CA-Cl*pper, it will return NIL */ #endif TEST_LINE( Descend( scString ) , "¸»´´±" ) TEST_LINE( Descend( scString ) , "¸»´´±" ) TEST_LINE( Descend( Descend( scString ) ) , "HELLO" ) TEST_LINE( Descend( .F. ) , .T. ) TEST_LINE( Descend( .T. ) , .F. ) TEST_LINE( Descend( 0 ) , 0.00 ) TEST_LINE( Descend( 1 ) , -1.00 ) TEST_LINE( Descend( -1 ) , 1.00 ) TEST_LINE( Descend( Descend( 256 ) ) , 256.00 ) TEST_LINE( Descend( 2.0 ) , -2.00 ) TEST_LINE( Descend( 2.5 ) , -2.50 ) TEST_LINE( Descend( -100.35 ) , 100.35 ) TEST_LINE( Str(Descend( -740.354 )) , " 740.35" ) TEST_LINE( Str(Descend( -740.359 )) , " 740.36" ) TEST_LINE( Str(Descend( -740.354 ), 15, 5) , " 740.35400" ) TEST_LINE( Str(Descend( -740.359 ), 15, 5) , " 740.35900" ) TEST_LINE( Descend( 100000 ) , -100000.00 ) TEST_LINE( Descend( -100000 ) , 100000.00 ) TEST_LINE( Descend( "" ) , "" ) TEST_LINE( Descend( Chr(0) ) , ""+Chr(0)+"" ) TEST_LINE( Descend( Chr(0) + "Hello" ) , ""+Chr(0)+"¸›””‘" ) TEST_LINE( Descend( "Hello"+Chr(0)+"wo" ) , "¸›””‘"+Chr(0)+"‰‘" ) TEST_LINE( Descend( SToD( "" ) ) , 5231808 ) TEST_LINE( Descend( SToD( "01000101" ) ) , 3474223 ) TEST_LINE( Descend( SToD( "19801220" ) ) , 2787214 ) #ifdef __HARBOUR__ /* __COLORINDEX() */ TEST_LINE( __ColorIndex() , "" ) TEST_LINE( __ColorIndex("", -1) , "" ) TEST_LINE( __ColorIndex("", 0) , "" ) TEST_LINE( __ColorIndex("W/R", -1) , "" ) TEST_LINE( __ColorIndex("W/R", 0) , "W/R" ) TEST_LINE( __ColorIndex("W/R", 1) , "" ) TEST_LINE( __ColorIndex("W/R", 2) , "" ) TEST_LINE( __ColorIndex("W/R,GR/0", 0) , "W/R" ) TEST_LINE( __ColorIndex("W/R,GR/0", 1) , "GR/0" ) TEST_LINE( __ColorIndex("W/R,GR/0", 2) , "" ) TEST_LINE( __ColorIndex("W/R,GR/0", 3) , "" ) TEST_LINE( __ColorIndex("W/R, GR/0", 0) , "W/R" ) TEST_LINE( __ColorIndex("W/R, GR/0", 1) , "GR/0" ) TEST_LINE( __ColorIndex("W/R, GR/0", 2) , "" ) TEST_LINE( __ColorIndex("W/R, GR/0", 3) , "" ) TEST_LINE( __ColorIndex("W/R,GR/0 ", 0) , "W/R" ) TEST_LINE( __ColorIndex("W/R,GR/0 ", 1) , "GR/0" ) TEST_LINE( __ColorIndex("W/R,GR/0 ", 2) , "" ) TEST_LINE( __ColorIndex("W/R, GR/0 ", 0) , "W/R" ) TEST_LINE( __ColorIndex("W/R, GR/0 ", 1) , "GR/0" ) TEST_LINE( __ColorIndex("W/R, GR/0 ", 2) , "" ) TEST_LINE( __ColorIndex("W/R, GR/0 ,", 0) , "W/R" ) TEST_LINE( __ColorIndex("W/R, GR/0 ,", 1) , "GR/0" ) TEST_LINE( __ColorIndex("W/R, GR/0 ,", 2) , "" ) TEST_LINE( __ColorIndex(" W/R, GR/0 ,", 0) , "W/R" ) TEST_LINE( __ColorIndex(" W/R, GR/0 ,", 1) , "GR/0" ) TEST_LINE( __ColorIndex(" W/R, GR/0 ,", 2) , "" ) TEST_LINE( __ColorIndex(" W/R , GR/0 ,", 0), "W/R" ) TEST_LINE( __ColorIndex(" W/R , GR/0 ,", 1), "GR/0" ) TEST_LINE( __ColorIndex(" W/R , GR/0 ,", 2), "" ) TEST_LINE( __ColorIndex(" W/R , ,", 1) , "" ) TEST_LINE( __ColorIndex(" W/R ,,", 1) , "" ) TEST_LINE( __ColorIndex(",,", 0) , "" ) TEST_LINE( __ColorIndex(",,", 1) , "" ) TEST_LINE( __ColorIndex(",,", 2) , "" ) TEST_LINE( __ColorIndex(", ,", 2) , "" ) #endif /* FKMAX(), FKLABEL() */ TEST_LINE( FKMax() , 40 ) TEST_LINE( FKMax( 1 ) , 40 ) #ifdef __HARBOUR__ TEST_LINE( FKLabel() , "" ) /* Bug in CA-Cl*pper, it returns: "E BASE 1074 Argument error <= F:S" */ TEST_LINE( FKLabel( NIL ) , "" ) /* Bug in CA-Cl*pper, it returns: "E BASE 1074 Argument error <= F:S" */ TEST_LINE( FKLabel( "A" ) , "" ) /* Bug in CA-Cl*pper, it returns: "E BASE 1074 Argument error <= F:S" */ #endif TEST_LINE( FKLabel( -1 ) , "" ) TEST_LINE( FKLabel( 0 ) , "" ) TEST_LINE( FKLabel( 1 ) , "F1" ) TEST_LINE( FKLabel( 25 ) , "F25" ) TEST_LINE( FKLabel( 40 ) , "F40" ) TEST_LINE( FKLabel( 41 ) , "" ) RETURN NIL #define TEST_RESULT_COL1_WIDTH 1 #define TEST_RESULT_COL2_WIDTH 4 #define TEST_RESULT_COL3_WIDTH 30 #define TEST_RESULT_COL4_WIDTH 55 #define TEST_RESULT_COL5_WIDTH 40 STATIC FUNCTION TEST_BEGIN( cParam ) LOCAL cOs s_nStartTime := Seconds() cOs := OS() IF "OS/2" $ cOs .OR. ; "DOS" $ cOs s_cNewLine := Chr( 13 ) + Chr( 10 ) ELSE s_cNewLine := Chr( 10 ) ENDIF s_lShowAll := "/ALL" $ Upper( cParam ) s_aSkipList := ListToNArray( CMDLGetValue( Upper( cParam ), "/SKIP:", "" ) ) /* Detect presence of shortcutting optimalization */ s_lShortcut := .T. IF .T. .OR. Eval( {|| s_lShortcut := .F. } ) /* Do nothing */ ENDIF /* Decide about output filename */ DO CASE CASE "HARBOUR" $ Upper( Version() ) ; s_cFileName := "rtl_test.hb" CASE "CLIPPER (R)" $ Upper( Version() ) .AND. ; "5.3" $ Version() ; s_cFileName := "rtl_test.c53" CASE "CLIPPER (R)" $ Upper( Version() ) ; s_cFileName := "rtl_test.c5x" ENDCASE s_nFhnd := 1 /* FHND_STDOUT */ s_cFileName := "(stdout)" s_nCount := 0 s_nPass := 0 s_nFail := 0 /* Set up the initial state */ /* TODO: Need to add this, when multi language support will be available to make sure all error messages comes in the original English language. */ /* SET LANGID TO EN */ SET DATE ANSI SET CENTURY ON SET EXACT OFF /* Feedback */ fWrite( s_nFhnd, " Version: " + Version() + s_cNewLine +; " OS: " + OS() + s_cNewLine +; " Date, Time: " + DToS( Date() ) + " " + Time() + s_cNewLine +; " Output: " + s_cFileName + s_cNewLine +; "Shortcut opt.: " + iif( s_lShortcut, "ON", "OFF" ) + s_cNewLine +; " Switches: " + cParam + s_cNewLine +; "===========================================================================" + s_cNewLine ) fWrite( s_nFhnd, PadL( "R", TEST_RESULT_COL1_WIDTH ) + " " +; PadL( "No", TEST_RESULT_COL2_WIDTH ) + ". " +; PadR( "TestCall()", TEST_RESULT_COL3_WIDTH ) + " -> " +; PadR( "Result", TEST_RESULT_COL4_WIDTH ) + " | " +; PadR( "Expected", TEST_RESULT_COL5_WIDTH ) + s_cNewLine +; "---------------------------------------------------------------------------" + s_cNewLine ) /* NOTE: Some basic values we may need for some tests. ( passing by reference, avoid preprocessor bugs, etc. ) */ scString := "HELLO" scStringE := "" scStringZ := "A" + Chr( 0 ) + "B" snIntZ := 0 snDoubleZ := 0.0 snIntP := 10 snLongP := 100000 snDoubleP := 10.567 /* Use different number of decimals than the default */ snIntN := -10 snLongN := -100000 snDoubleN := -10.567 /* Use different number of decimals than the default */ snDoubleI := Log( 0 ) sdDate := SToD( "19800101" ) sdDateE := SToD( "" ) slFalse := .F. slTrue := .T. soObject := ErrorNew() suNIL := NIL sbBlock := {|| NIL } sbBlockC := {|| "(string)" } saArray := { 9898 } saAllTypes := {; scString ,; scStringE ,; scStringZ ,; snIntZ ,; snDoubleZ ,; snIntP ,; snLongP ,; snDoubleP ,; snIntN ,; snLongN ,; snDoubleN ,; snDoubleI ,; sdDateE ,; slFalse ,; slTrue ,; soObject ,; suNIL ,; sbBlock ,; sbBlockC ,; saArray } /* NOTE: mxNotHere intentionally not declared */ PUBLIC mcString := "HELLO" PUBLIC mcStringE := "" PUBLIC mcStringZ := "A" + Chr( 0 ) + "B" PUBLIC mnIntZ := 0 PUBLIC mnDoubleZ := 0.0 PUBLIC mnIntP := 10 PUBLIC mnLongP := 100000 PUBLIC mnDoubleP := 10.567 PUBLIC mnIntN := -10 PUBLIC mnLongN := -100000 PUBLIC mnDoubleN := -10.567 PUBLIC mnDoubleI := Log( 0 ) PUBLIC mdDate := SToD( "19800101" ) PUBLIC mdDateE := SToD( "" ) PUBLIC mlFalse := .F. PUBLIC mlTrue := .T. PUBLIC moObject := ErrorNew() PUBLIC muNIL := NIL PUBLIC mbBlock := {|| NIL } PUBLIC mbBlockC := {|| "(string)" } PUBLIC maArray := { 9898 } RETURN NIL STATIC FUNCTION TEST_CALL( cBlock, bBlock, xResultExpected ) LOCAL xResult LOCAL oError LOCAL bOldError LOCAL lFailed LOCAL lSkipped s_nCount++ IF !( ValType( cBlock ) == "C" ) cBlock := "!! Preprocessor error !!" ENDIF lSkipped := aScan( s_aSkipList, s_nCount ) > 0 IF lSkipped lFailed := .F. xResult := "!! Skipped !!" ELSE bOldError := ErrorBlock( {|oError| Break( oError ) } ) BEGIN SEQUENCE xResult := Eval( bBlock ) RECOVER USING oError xResult := ErrorMessage( oError ) END SEQUENCE ErrorBlock( bOldError ) IF !( ValType( xResult ) == ValType( xResultExpected ) ) IF ValType( xResultExpected) == "C" .AND. ValType( xResult ) $ "ABM" lFailed := !( XToStr( xResult ) == xResultExpected ) ELSE lFailed := .T. ENDIF ELSE lFailed := !( xResult == xResultExpected ) ENDIF ENDIF IF s_lShowAll .OR. lFailed .OR. lSkipped fWrite( s_nFhnd, PadR( iif( lFailed, "!", iif( lSkipped, "S", " " ) ), TEST_RESULT_COL1_WIDTH ) + " " +; Str( s_nCount, TEST_RESULT_COL2_WIDTH ) + ". " +; PadR( cBlock, TEST_RESULT_COL3_WIDTH ) + " -> " +; PadR( XToStr( xResult ), TEST_RESULT_COL4_WIDTH ) + " | " +; PadR( XToStr( xResultExpected ), TEST_RESULT_COL5_WIDTH ) ) fWrite( s_nFhnd, s_cNewLine ) ENDIF IF lFailed s_nFail++ ELSE s_nPass++ ENDIF RETURN NIL STATIC FUNCTION TEST_OPT_Z() RETURN s_lShortCut STATIC FUNCTION TEST_END() s_nEndTime := Seconds() fWrite( s_nFhnd, "===========================================================================" + s_cNewLine +; "Test calls passed: " + Str( s_nPass ) + s_cNewLine +; "Test calls failed: " + Str( s_nFail ) + s_cNewLine +; " ----------" + s_cNewLine +; " Total: " + Str( s_nPass + s_nFail ) +; " ( Time elapsed: " + LTrim( Str( s_nEndTime - s_nStartTime ) ) + " seconds )" + s_cNewLine +; s_cNewLine ) IF s_nFail != 0 IF "CLIPPER (R)" $ Upper( Version() ) fWrite( s_nFhnd, "WARNING ! Failures detected using CA-Clipper." + s_cNewLine +; "Please fix those expected results which are not bugs in CA-Clipper itself." + s_cNewLine ) ELSE fWrite( s_nFhnd, "WARNING ! Failures detected" + s_cNewLine ) ENDIF ENDIF ErrorLevel( iif( s_nFail != 0, 1, 0 ) ) RETURN NIL STATIC FUNCTION XToStr( xValue ) LOCAL cType := ValType( xValue ) DO CASE CASE cType == "C" ; RETURN '"' + StrTran( xValue, Chr(0), '"+Chr(0)+"' ) + '"' CASE cType == "N" ; RETURN LTrim( Str( xValue ) ) CASE cType == "D" ; RETURN 'SToD("' + DToS( xValue ) + '")' CASE cType == "L" ; RETURN iif( xValue, ".T.", ".F." ) CASE cType == "O" ; RETURN xValue:className + " Object" CASE cType == "U" ; RETURN "NIL" CASE cType == "B" ; RETURN '{||...}' CASE cType == "A" ; RETURN '{.[' + LTrim( Str( Len( xValue ) ) ) + '].}' CASE cType == "M" ; RETURN 'M:"' + xValue + '"' ENDCASE RETURN "" STATIC FUNCTION ErrorMessage( oError ) LOCAL cMessage := "" IF ValType( oError:severity ) == "N" DO CASE CASE oError:severity == ES_WHOCARES ; cMessage += "M " CASE oError:severity == ES_WARNING ; cMessage += "W " CASE oError:severity == ES_ERROR ; cMessage += "E " CASE oError:severity == ES_CATASTROPHIC ; cMessage += "C " ENDCASE ENDIF IF ValType( oError:subsystem ) == "C" cMessage += oError:subsystem() + " " ENDIF IF ValType( oError:subCode ) == "N" cMessage += LTrim( Str( oError:subCode ) ) + " " ENDIF IF ValType( oError:description ) == "C" cMessage += oError:description + " " ENDIF IF !Empty( oError:operation ) cMessage += oError:operation + " " ENDIF IF !Empty( oError:filename ) cMessage += oError:filename + " " ENDIF IF oError:canDefault .OR. ; oError:canRetry .OR. ; oError:canSubstitute cMessage += "F:" IF oError:canDefault cMessage += "D" ENDIF IF oError:canRetry cMessage += "R" ENDIF IF oError:canSubstitute cMessage += "S" ENDIF ENDIF RETURN cMessage STATIC FUNCTION ListToNArray( cString ) LOCAL aArray := {} LOCAL nPos IF !Empty( cString ) DO WHILE ( nPos := At( ",", cString ) ) > 0 aAdd( aArray, Val( AllTrim( Left( cString, nPos - 1 ) ) ) ) cString := SubStr( cString, nPos + 1 ) ENDDO aAdd( aArray, Val( AllTrim( cString ) ) ) ENDIF RETURN aArray STATIC FUNCTION CMDLGetValue( cCommandLine, cName, cRetVal ) LOCAL tmp, tmp1 IF ( tmp := At( cName, cCommandLine ) ) > 0 IF ( tmp1 := At( " ", tmp := SubStr( cCommandLine, tmp + Len( cName ) ) ) ) > 0 tmp := Left( tmp, tmp1 - 1 ) ENDIF cRetVal := tmp ENDIF RETURN cRetVal #ifndef __HARBOUR__ #ifndef __XPP__ STATIC FUNCTION SToD( cDate ) LOCAL cOldDateFormat LOCAL dDate IF ValType( cDate ) == "C" cOldDateFormat := Set( _SET_DATEFORMAT, "yyyy/mm/dd" ) dDate := CToD( SubStr( cDate, 1, 4 ) + "/" +; SubStr( cDate, 5, 2 ) + "/" +; SubStr( cDate, 7, 2 ) ) Set( _SET_DATEFORMAT, cOldDateFormat ) ELSE dDate := CToD( "" ) ENDIF RETURN dDate #endif #endif