/*
 * 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"