15795f6330
* contrib/gtwvg/class.prg
* contrib/gtwvg/menubar.prg
* contrib/gtwvg/paint.prg
* contrib/gtwvg/tests/_activex.prg
* contrib/gtwvg/tests/_dyndlgs.prg
* contrib/gtwvg/tests/_modal.prg
* contrib/gtwvg/tests/_tbrowse.prg
* contrib/gtwvg/tests/_utils.prg
* contrib/gtwvg/tests/_wvtcls.prg
* contrib/gtwvg/tests/_xbp.prg
* contrib/gtwvg/tests/demowvg.prg
* contrib/gtwvg/tests/demowvg1.prg
* contrib/gtwvg/tests/demoxbp.prg
* contrib/hbhttpd/core.prg
* contrib/hbhttpd/tests/eshop.prg
* contrib/hbhttpd/widgets.prg
* contrib/hbtip/thtml.prg
* src/debug/dbgtobj.prg
* src/rdd/hbsix/sxini.prg
* src/rtl/hbi18n2.prg
* src/rtl/tbrowse.prg
* utils/hbtest/rt_array.prg
* sync with 3.4 fork (no change in functionality)
501 lines
23 KiB
Plaintext
501 lines
23 KiB
Plaintext
/*
|
|
* Regression tests for the runtime library (array)
|
|
*
|
|
* Copyright 1999-2001 Viktor Szakats (vszakats.net/harbour)
|
|
*
|
|
* 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 program; see the file LICENSE.txt. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA (or visit https://www.gnu.org/licenses/).
|
|
*
|
|
* 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"
|
|
|
|
PROCEDURE Main_ARRAY()
|
|
|
|
/* ARRAY function error conditions. */
|
|
|
|
#ifndef __XPP__
|
|
HBTEST ACopy() IS NIL
|
|
#endif
|
|
HBTEST ACopy( {}, "C" ) IS NIL
|
|
HBTEST ACopy( "C", {} ) IS NIL
|
|
HBTEST ACopy( {}, {} ) IS "{.[0].}"
|
|
HBTEST ACopy( {}, ErrorNew() ) IS "ERROR Object"
|
|
HBTEST ACopy( ErrorNew(), {} ) IS "{.[0].}"
|
|
#ifndef __XPP__
|
|
HBTEST AClone() IS NIL
|
|
#endif
|
|
HBTEST AClone( NIL ) IS NIL
|
|
HBTEST AClone( {} ) IS "{.[0].}"
|
|
HBTEST AClone( ErrorNew() ) IS NIL
|
|
#ifndef __XPP__
|
|
HBTEST AEval() IS "E 1 BASE 2017 Argument error (AEVAL) OS:0 #:0 "
|
|
HBTEST AEval( NIL ) IS "E 1 BASE 2017 Argument error (AEVAL) OS:0 #:0 A:1:U:NIL "
|
|
HBTEST AEval( {} ) IS "E 1 BASE 2017 Argument error (AEVAL) OS:0 #:0 A:1:A:{.[0].} "
|
|
#endif
|
|
HBTEST AEval( {}, NIL ) IS "E 1 BASE 2017 Argument error (AEVAL) OS:0 #:0 A:2:A:{.[0].};U:NIL "
|
|
HBTEST AEval( {}, {|| NIL } ) IS "{.[0].}"
|
|
HBTEST AEval( ErrorNew(), {|| NIL } ) IS "ERROR Object"
|
|
#ifndef __XPP__
|
|
HBTEST AScan() IS 0
|
|
HBTEST AScan( NIL ) IS 0
|
|
HBTEST AScan( "A" ) IS 0
|
|
HBTEST AScan( {} ) IS 0
|
|
#endif
|
|
HBTEST AScan( {}, "" ) IS 0
|
|
HBTEST AScan( ErrorNew(), "NOT_FOUND" ) IS 0
|
|
#ifndef __XPP__
|
|
HBTEST ASort() IS NIL
|
|
#endif
|
|
HBTEST ASort( 10 ) IS NIL
|
|
HBTEST ASort( {} ) IS "{.[0].}"
|
|
HBTEST ASort( ErrorNew() ) IS NIL
|
|
#ifdef HB_CLP_STRICT
|
|
#ifndef __XPP__
|
|
HBTEST AFill() IS "E 1 BASE 2017 Argument error (AEVAL) OS:0 #:0 A:4:U:NIL;B:{||...};U:NIL;U:NIL "
|
|
#endif
|
|
HBTEST AFill( NIL ) IS "E 1 BASE 2017 Argument error (AEVAL) OS:0 #:0 A:4:U:NIL;B:{||...};U:NIL;U:NIL "
|
|
#else
|
|
#ifndef __XPP__
|
|
HBTEST AFill() IS "E 1 BASE 6004 Argument error (AFILL) OS:0 #:0 "
|
|
#endif
|
|
HBTEST AFill( NIL ) IS "E 1 BASE 6004 Argument error (AFILL) OS:0 #:0 A:1:U:NIL "
|
|
#endif
|
|
HBTEST AFill( {} ) IS "{.[0].}"
|
|
HBTEST AFill( {}, 1 ) IS "{.[0].}"
|
|
HBTEST AFill( ErrorNew() ) IS "ERROR Object"
|
|
HBTEST AFill( ErrorNew(), 1 ) IS "ERROR Object"
|
|
#ifndef __XPP__
|
|
HBTEST ADel() IS NIL
|
|
HBTEST ADel( NIL ) IS NIL
|
|
HBTEST ADel( { 1 } ) IS "{.[1].}"
|
|
#endif
|
|
HBTEST ADel( { 1 }, 0 ) IS "{.[1].}"
|
|
HBTEST ADel( { 1 }, 100 ) IS "{.[1].}"
|
|
HBTEST ADel( { 1 }, 1 ) IS "{.[1].}"
|
|
HBTEST ADel( { 1 }, -1 ) IS "{.[1].}"
|
|
HBTEST ADel( { 1 }, 0 ) IS "{.[1].}"
|
|
HBTEST ADel( { 1 }, NIL ) IS "{.[1].}"
|
|
#ifndef __XPP__
|
|
HBTEST ADel( ErrorNew() ) IS "ERROR Object"
|
|
#endif
|
|
HBTEST ADel( ErrorNew(), 0 ) IS "ERROR Object"
|
|
HBTEST ADel( ErrorNew(), 100 ) IS "ERROR Object"
|
|
HBTEST ADel( ErrorNew(), 1 ) IS "ERROR Object"
|
|
HBTEST ADel( ErrorNew(), -1 ) IS "ERROR Object"
|
|
HBTEST ADel( ErrorNew(), 0 ) IS "ERROR Object"
|
|
HBTEST ADel( ErrorNew(), NIL ) IS "ERROR Object"
|
|
#ifndef __XPP__
|
|
HBTEST AIns() IS NIL
|
|
HBTEST AIns( NIL ) IS NIL
|
|
HBTEST AIns( { 1 } ) IS "{.[1].}"
|
|
#endif
|
|
HBTEST AIns( { 1 }, 0 ) IS "{.[1].}"
|
|
HBTEST AIns( { 1 }, 100 ) IS "{.[1].}"
|
|
HBTEST AIns( { 1 }, 1 ) IS "{.[1].}"
|
|
HBTEST AIns( { 1 }, -1 ) IS "{.[1].}"
|
|
HBTEST AIns( { 1 }, 0 ) IS "{.[1].}"
|
|
HBTEST AIns( { 1 }, NIL ) IS "{.[1].}"
|
|
#ifndef __XPP__
|
|
HBTEST AIns( ErrorNew() ) IS "ERROR Object"
|
|
#endif
|
|
HBTEST AIns( ErrorNew(), 0 ) IS "ERROR Object"
|
|
HBTEST AIns( ErrorNew(), 100 ) IS "ERROR Object"
|
|
HBTEST AIns( ErrorNew(), 1 ) IS "ERROR Object"
|
|
HBTEST AIns( ErrorNew(), -1 ) IS "ERROR Object"
|
|
HBTEST AIns( ErrorNew(), 0 ) IS "ERROR Object"
|
|
HBTEST AIns( ErrorNew(), NIL ) IS "ERROR Object"
|
|
#ifndef __XPP__
|
|
HBTEST ATail() IS NIL
|
|
#endif
|
|
HBTEST ATail( NIL ) IS NIL
|
|
HBTEST ATail( "" ) IS NIL
|
|
HBTEST ATail( {} ) IS NIL
|
|
HBTEST ATail( { 1, 2 } ) IS 2
|
|
HBTEST ATail( ErrorNew() ) IS NIL
|
|
#ifndef __XPP__
|
|
#ifdef HB_COMPAT_C53
|
|
HBTEST ASize() IS "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 "
|
|
HBTEST ASize( NIL ) IS "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 ", "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 A:1:U:NIL "
|
|
HBTEST ASize( {} ) IS "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 ", "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 A:1:A:{.[0].} "
|
|
HBTEST ASize( ErrorNew() ) IS "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 ", "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 A:1:O:ERROR Object "
|
|
#else
|
|
HBTEST ASize() IS NIL
|
|
HBTEST ASize( NIL ) IS NIL
|
|
HBTEST ASize( {} ) IS NIL
|
|
HBTEST ASize( ErrorNew() ) IS NIL
|
|
#endif
|
|
#endif
|
|
#ifdef HB_COMPAT_C53
|
|
HBTEST ASize( NIL, 0 ) IS "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 ", "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 A:2:U:NIL;N:0 "
|
|
HBTEST ASize( NIL, 1 ) IS "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 ", "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 A:2:U:NIL;N:1 "
|
|
HBTEST ASize( NIL, -1 ) IS "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 ", "E 1 BASE 2023 Argument error (ASIZE) OS:0 #:0 A:2:U:NIL;N:-1 "
|
|
#else
|
|
HBTEST ASize( NIL, 0 ) IS NIL
|
|
HBTEST ASize( NIL, 1 ) IS NIL
|
|
HBTEST ASize( NIL, -1 ) IS NIL
|
|
#endif
|
|
HBTEST ASize( {}, 0 ) IS "{.[0].}"
|
|
HBTEST ASize( ErrorNew(), 0 ) IS "ERROR Object"
|
|
HBTEST ASize( {}, 1 ) IS "{.[1].}"
|
|
HBTEST ASize( { 1, 2 }, 1 ) IS "{.[1].}"
|
|
HBTEST ASize( { 1, "AAAA" }, 1 ) IS "{.[1].}"
|
|
HBTEST ASize( { "BBB", "AAAA" }, 0 ) IS "{.[0].}"
|
|
HBTEST ASize( ErrorNew(), 1 ) IS "ERROR Object"
|
|
HBTEST ASize( {}, -1 ) IS "{.[0].}"
|
|
HBTEST ASize( { 1 }, -1 ) IS "{.[0].}"
|
|
#ifdef __HARBOUR__
|
|
HBTEST ASize( { 1 }, 5000 ) IS "{.[5000].}"
|
|
#else
|
|
HBTEST ASize( { 1 }, 5000 ) IS "{.[1].}"
|
|
#endif
|
|
HBTEST ASize( ErrorNew(), -1 ) IS "ERROR Object"
|
|
HBTEST ASize( ErrorNew(), 100 ) IS "ERROR Object"
|
|
HBTEST AAdd( NIL, NIL ) IS "E 1 BASE 1123 Argument error (AADD) OS:0 #:0 A:2:U:NIL;U:NIL F:S"
|
|
HBTEST AAdd( {}, NIL ) IS NIL
|
|
HBTEST AAdd( {}, "A" ) IS "A"
|
|
HBTEST AAdd( ErrorNew(), NIL ) IS NIL
|
|
HBTEST AAdd( ErrorNew(), "A" ) IS "A"
|
|
#ifndef __XPP__
|
|
HBTEST Array() IS NIL
|
|
#endif
|
|
HBTEST Array( 0 ) IS "{.[0].}"
|
|
#ifdef __HARBOUR__
|
|
HBTEST Array( 5000 ) IS "{.[5000].}"
|
|
#else
|
|
HBTEST Array( 5000 ) IS "E 2 BASE 1131 Bound error (array dimension) OS:0 #:0 "
|
|
#endif
|
|
HBTEST Array( 1 ) IS "{.[1].}"
|
|
HBTEST Array( -1 ) IS "E 2 BASE 1131 Bound error (array dimension) OS:0 #:0 "
|
|
#ifdef __HARBOUR__
|
|
/* disable Harbour extended optimizations to test correct RTE message */
|
|
#pragma -ko-
|
|
#endif
|
|
HBTEST Array( 1, 0, -10 ) IS "E 2 BASE 1131 Bound error (array dimension) OS:0 #:0 ", "E 2 BASE 1131 Bound error (array dimension) OS:0 #:0 A:3:N:1;N:0;N:-10 "
|
|
HBTEST Array( 1, 0, "A" ) IS NIL
|
|
#ifdef __HARBOUR__
|
|
#pragma -ko+
|
|
#endif
|
|
HBTEST Array( 1, 0, 2 ) IS "{.[1].}"
|
|
HBTEST Array( 4, 3, 2 ) IS "{.[4].}"
|
|
HBTEST Array( 0, 3, 2 ) IS "{.[0].}"
|
|
|
|
/* AFill() */
|
|
|
|
HBTEST TAStr( AFill( TANew(), "X" ) ) IS "XXXXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", NIL, -2 ) ) IS "XXXXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", NIL, 0 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", NIL, 3 ) ) IS "XXX......."
|
|
HBTEST TAStr( AFill( TANew(), "X", NIL, 20 ) ) IS "XXXXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", 0 ) ) IS "XXXXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", 0, -2 ) ) IS "XXXXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", 0, 0 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", 0, 3 ) ) IS "XXX......."
|
|
HBTEST TAStr( AFill( TANew(), "X", 0, 20 ) ) IS "XXXXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", 1 ) ) IS "XXXXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", 1, -2 ) ) IS "XXXXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", 1, 0 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", 1, 3 ) ) IS "XXX......."
|
|
HBTEST TAStr( AFill( TANew(), "X", 1, 20 ) ) IS "XXXXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", 3 ) ) IS "..XXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", 3, -2 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", 3, 0 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", 3, 3 ) ) IS "..XXX....."
|
|
HBTEST TAStr( AFill( TANew(), "X", 3, 20 ) ) IS "..XXXXXXXX"
|
|
HBTEST TAStr( AFill( TANew(), "X", -1 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", -1, -2 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", -1, 0 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", -1, 3 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", -1, 20 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", 21 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", 21, -2 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", 21, 0 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", 21, 3 ) ) IS ".........."
|
|
HBTEST TAStr( AFill( TANew(), "X", 21, 20 ) ) IS ".........."
|
|
|
|
/* ACopy() */
|
|
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, 0 ) ) IS ".........."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, 3 ) ) IS "ABC......."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, 20 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3 ) ) IS "CDEFGHIJ.."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, 0 ) ) IS ".........."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, 3 ) ) IS "CDE......."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, 20 ) ) IS "CDEFGHIJ.."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21 ) ) IS ".........." /* Bug in CA-Cl*pper, it will return: "J.........", fixed in 5.3a */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, 0 ) ) IS ".........."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, 3 ) ) IS ".........." /* Bug in CA-Cl*pper, it will return: "J.........", fixed in 5.3a */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, 20 ) ) IS ".........." /* Bug in CA-Cl*pper, it will return: "J.........", fixed in 5.3a */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, NIL, 1 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, 0, 1 ) ) IS ".........."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, 3, 0 ) ) IS "ABC......."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, 3, 2 ) ) IS ".ABC......"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, 3, 8 ) ) IS ".......ABC"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, 3, 20 ) ) IS ".........A" /* Strange in CA-Cl*pper, it should return: ".........." */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 1, 20, 1 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, NIL, 3 ) ) IS "..CDEFGHIJ"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, 0, 3 ) ) IS ".........."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, 3, 0 ) ) IS "CDE......."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, 3, 2 ) ) IS ".CDE......"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, 3, 8 ) ) IS ".......CDE"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, 3, 20 ) ) IS ".........C" /* Strange in CA-Cl*pper, it should return: ".........." */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 3, 20, 3 ) ) IS "..CDEFGHIJ"
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, NIL, 21 ) ) IS ".........." /* Bug in CA-Cl*pper, it will return: ".........J", fixed in 5.3a */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, 0, 21 ) ) IS ".........."
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, 3, 0 ) ) IS ".........." /* Bug in CA-Cl*pper, it will return: "J.........", fixed in 5.3a */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, 3, 2 ) ) IS ".........." /* Bug in CA-Cl*pper, it will return: ".J........", fixed in 5.3a */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, 3, 8 ) ) IS ".........." /* Bug in CA-Cl*pper, it will return: ".......J..", fixed in 5.3a */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, 3, 20 ) ) IS ".........." /* Bug in CA-Cl*pper, it will return: ".........J", fixed in 5.3a */
|
|
HBTEST TAStr( ACopy( TARng(), TANew(), 21, 20, 21 ) ) IS ".........." /* Bug in CA-Cl*pper, it will return: ".........J", fixed in 5.3a */
|
|
|
|
/* ASort() */
|
|
|
|
/* Different results in Harbour and CA-Cl*pper due to different
|
|
sorting algorithms. Anyhow the results pattern should match.
|
|
[vszakats] */
|
|
#ifdef __HARBOUR__
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| NIL } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| hb_SToD() } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "0" } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "1" } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "2" } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "a" } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "A" } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "" } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "z" } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| .T. } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| .F. } ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| 2 } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| 1 } ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| 0 } ) ) IS "JIHGFEDCBA"
|
|
#else
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| NIL } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| hb_SToD() } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "0" } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "1" } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "2" } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "a" } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "A" } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "" } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| "z" } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| .T. } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| .F. } ) ) IS "DCEABJIHFG"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| 2 } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| 1 } ) ) IS "IHGFEDCBAJ"
|
|
HBTEST TAStr( ASort( TARRv(),,, {|| 0 } ) ) IS "DCEABJIHFG"
|
|
#endif
|
|
HBTEST TAStr( ASort( TARRv() ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(), NIL, NIL ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(), NIL, -2 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(), NIL, 0 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(), NIL, 3 ) ) IS "HIJGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), NIL, 20 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(), -5 ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), -5, -2 ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), -5, 0 ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), -5, 3 ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), -5, 20 ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), 0 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(), 0, -2 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(), 0, 0 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(), 0, 3 ) ) IS "HIJGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), 0, 20 ) ) IS "ABCDEFGHIJ"
|
|
HBTEST TAStr( ASort( TARRv(), 5 ) ) IS "JIHGABCDEF"
|
|
#ifdef __HARBOUR__
|
|
HBTEST TAStr( ASort( TARRv(), 5, -2 ) ) IS "JIHGABCDEF" /* CA-Cl*pper will crash or GPF on that line. */
|
|
#endif
|
|
HBTEST TAStr( ASort( TARRv(), 5, 0 ) ) IS "JIHGABCDEF"
|
|
HBTEST TAStr( ASort( TARRv(), 5, 3 ) ) IS "JIHGDEFCBA"
|
|
HBTEST TAStr( ASort( TARRv(), 5, 20 ) ) IS "JIHGABCDEF"
|
|
HBTEST TAStr( ASort( TARRv(), 20 ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), 20, -2 ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), 20, 0 ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), 20, 3 ) ) IS "JIHGFEDCBA"
|
|
HBTEST TAStr( ASort( TARRv(), 20, 20 ) ) IS "JIHGFEDCBA"
|
|
|
|
/* AScan() */
|
|
|
|
#ifndef __XPP__
|
|
HBTEST AScan() IS 0
|
|
HBTEST AScan( NIL ) IS 0
|
|
HBTEST AScan( "A" ) IS 0
|
|
#endif
|
|
HBTEST AScan( "A", "A" ) IS 0
|
|
HBTEST AScan( "A", {|| .F. } ) IS 0
|
|
HBTEST AScan( { 1, 2, 3 }, {|| NIL } ) IS 0
|
|
HBTEST AScan( saAllTypes, scString ) IS 1
|
|
#ifdef __HARBOUR__
|
|
HBTEST AScan( @saAllTypes, scString ) IS 1 /* Bug in CA-Cl*pper, it will return 0 */
|
|
HBTEST AScan( saAllTypes, @scString ) IS 1 /* Bug in CA-Cl*pper, it will return 0 */
|
|
#endif
|
|
HBTEST AScan( saAllTypes, scStringE ) IS 1
|
|
HBTEST AScan( saAllTypes, scStringZ ) IS 3
|
|
HBTEST AScan( saAllTypes, snIntZ ) IS 4
|
|
HBTEST AScan( saAllTypes, snDoubleZ ) IS 4
|
|
HBTEST AScan( saAllTypes, snIntP ) IS 6
|
|
HBTEST AScan( saAllTypes, snLongP ) IS 7
|
|
HBTEST AScan( saAllTypes, snDoubleP ) IS 8
|
|
HBTEST AScan( saAllTypes, snIntN ) IS 9
|
|
HBTEST AScan( saAllTypes, snLongN ) IS 10
|
|
HBTEST AScan( saAllTypes, snDoubleN ) IS 11
|
|
HBTEST AScan( saAllTypes, snDoubleI ) IS 4
|
|
HBTEST AScan( saAllTypes, sdDateE ) IS 13
|
|
HBTEST AScan( saAllTypes, slFalse ) IS 14
|
|
HBTEST AScan( saAllTypes, slTrue ) IS 15
|
|
HBTEST AScan( saAllTypes, soObject ) IS 0
|
|
HBTEST AScan( saAllTypes, suNIL ) IS 17
|
|
HBTEST AScan( saAllTypes, sbBlock ) IS 0
|
|
HBTEST AScan( saAllTypes, sbBlockC ) IS 0
|
|
HBTEST AScan( saAllTypes, saArray ) IS 0
|
|
Set( _SET_EXACT, .T. )
|
|
HBTEST AScan( saAllTypes, scString ) IS 1
|
|
HBTEST AScan( saAllTypes, scStringE ) IS 2
|
|
HBTEST AScan( saAllTypes, scStringZ ) IS 3
|
|
Set( _SET_EXACT, .F. )
|
|
|
|
HBTEST TAEVSM() IS "N10N 9N 8N 7N 6N 5N 4N 3N 2N 1 0" /* Bug in CA-Cl*pper 5.x */, "N10N 9N 8N 7N 6 5"
|
|
HBTEST TASOSM1() IS "NN 5NN 4NN 3NN 2NN 1NN 0NN 0NN 0NN 0NN 0NN 0NN 0 0{ }" , "NN 5NN 4 3{ 2, 1, 3 }"
|
|
HBTEST TASOSM2() IS "NN 5NN 4NN 3NN 2NN 1NN 0NN 0NN 0NN 0NN 0 0{ }" , "NN 5NN 4 3{ 2, 1, 3 }"
|
|
|
|
RETURN
|
|
|
|
STATIC FUNCTION TAEVSM()
|
|
|
|
LOCAL cString := ""
|
|
LOCAL aArray := Array( 10 )
|
|
|
|
AFill( aArray, 0 )
|
|
AEval( aArray, {| x | cString += ValType( x ) + Str( Len( aArray ), 2 ), ASize( aArray, Len( aArray ) - 1 ) } )
|
|
|
|
RETURN cString + Str( Len( aArray ) )
|
|
|
|
STATIC FUNCTION TASOSM1()
|
|
|
|
LOCAL cString := ""
|
|
LOCAL aArray := { 1, 2, 3, 4, 5 }
|
|
|
|
ASort( aArray, NIL, NIL, {| x, y | cString += ValType( x ) + ValType( y ) + Str( Len( aArray ), 2 ), ASize( aArray, Len( aArray ) - 1 ), x > y } )
|
|
|
|
RETURN cString + Str( Len( aArray ) ) + XToStrX( aArray )
|
|
|
|
STATIC FUNCTION TASOSM2()
|
|
|
|
LOCAL cString := ""
|
|
LOCAL aArray := { 1, 2, 3, 4, 5 }
|
|
|
|
ASort( aArray, NIL, NIL, {| x, y | cString += ValType( x ) + ValType( y ) + Str( Len( aArray ), 2 ), ASize( aArray, Len( aArray ) - 1 ) } )
|
|
|
|
RETURN cString + Str( Len( aArray ) ) + XToStrX( aArray )
|
|
|
|
STATIC FUNCTION TANew( cChar, nLen )
|
|
|
|
LOCAL aArray
|
|
LOCAL tmp
|
|
|
|
IF nLen == NIL
|
|
nLen := 10
|
|
ENDIF
|
|
|
|
IF cChar == NIL
|
|
cChar := "."
|
|
ENDIF
|
|
|
|
aArray := Array( nLen )
|
|
|
|
/* Intentionally not using AFill() here, since this function is
|
|
involved in testing AFill() itself. */
|
|
FOR tmp := 1 TO nLen
|
|
aArray[ tmp ] := cChar
|
|
NEXT
|
|
|
|
RETURN aArray
|
|
|
|
STATIC FUNCTION TARng( nLen )
|
|
|
|
LOCAL aArray
|
|
LOCAL tmp
|
|
|
|
IF nLen == NIL
|
|
nLen := 10
|
|
ENDIF
|
|
|
|
aArray := Array( nLen )
|
|
|
|
FOR tmp := 1 TO nLen
|
|
aArray[ tmp ] := Chr( Asc( "A" ) + tmp - 1 )
|
|
NEXT
|
|
|
|
RETURN aArray
|
|
|
|
STATIC FUNCTION TARRv( nLen )
|
|
|
|
LOCAL aArray
|
|
LOCAL tmp
|
|
|
|
IF nLen == NIL
|
|
nLen := 10
|
|
ENDIF
|
|
|
|
aArray := Array( nLen )
|
|
|
|
FOR tmp := 1 TO nLen
|
|
aArray[ tmp ] := Chr( Asc( "A" ) + nLen - tmp )
|
|
NEXT
|
|
|
|
RETURN aArray
|
|
|
|
STATIC FUNCTION TAStr( aArray )
|
|
|
|
LOCAL cString := ""
|
|
LOCAL tmp
|
|
LOCAL nLen := Len( aArray )
|
|
|
|
FOR tmp := 1 TO nLen
|
|
cString += aArray[ tmp ]
|
|
NEXT
|
|
|
|
RETURN cString
|
|
|
|
/* Don't change the position of this #include. */
|
|
#include "rt_init.ch"
|