Power-Programmierung/CD1.mdf/pascal/library/dos/toadhall/long/toadtest.pas

Pascal/Delphi Source File | 1988-05-24 | 52.4 KB | 1,590 lines

{TOADTEST.PAS}

PROGRAM toadtest;
{$V-}  {relax string parm testing}

(*
 Sample program to test some procedures in TOADLONG.INC,
 TOADINT.INC, TOADCONV.INC, and show off the usefulness
 of TOADTIME.INC.

 Released for personal or educational use for non-commercial,
 non-profit purposes.

 You may freely distribute, upload, download, and use this source code
 (or any portions thereof) for any personal or educational purposes.

 You may NOT use any portions of this code (source or compiled)
 in any product or program intended for licensing, sale, rent,
 "Freeware", or for any commercial purpose.

 You may NOT divide, separate, delete, or remove any portions of this
 source code for further distribution.

 You may NOT publish any portions of this code without a CASE-BY-CASE
 specific release, in writing, from me.

 You may NOT remove these restrictions or credits.  If you incorporate
 any portions of this code in your own program, you MUST include the
 following credit text (in visible ASCII characters) in the source and
 object code:

   "Includes TOAD HALL Long Integer functions.
    Copyright (c) 1988 David P Kirschbaum"

THIS IS NOT PUBLIC DOMAIN CODE!  I RESERVE ALL RIGHTS FOR THIS SOFTWARE!

   Copyright (C) 1988 David P Kirschbaum  All Rights Reserved

 (I know, not in the TRUE interest of public domain,
 but if you wanna get rich and famous off this hack,
 you're gonna at LEAST have to recode it!
 Else, contact me for a license.)

 Contact me via EMail (or worst case, telephone) if you find
 a need for any more long integer-related functions, or (naturally)
 if you find any bugs.  I kinda enjoy tweaking these suckers!

 V1.3, May 88
       Broke out unsigned integer functions to TOADINT.INC.
       Broke out power/sqr/sqrt functions to TOADPOWR.INC.
       Broke out integer/real/long conversion functions to TOADCONV.INC
       Converted long comparisons to assembler.
       Added the following procedures/functions:
         Sqr16           A FAST 16-bit integer square (integer result)
         Long_Sqr        Square a long
         Long_Sqrt       Get a long's square root (integer result)
         Sqrt16          Get an integer's square root (integer result)
         Long_Mod        MOD two longs (long result)
         Real_Mod        MOD two reals (real result)
         Unsigned_To_Real Convert an integer to an unsigned real.
         Byte32_Str      Return a long's bits as a string
           and probably more...

       I THINK I have all the bugs and logical errors out of the newer
       procedures.  Release 1.2 was inadequately tested (very embarrassing,
       stupid logical errors, lack of clear understanding on DIVs and MULs).
       Still have to clean up uniform setting of global CF and ZF flags.

 V1.2, May 88:
       Added the following procedures:
         Long_Mul_I      multiply long by integer
         Long_Div_I      divide long by integer
         Long_Mul        multiply long by long *** seems to work now ***
         Long_Div        divide long by long  *** still broken ***
         AnyNumStr       Return any number (int,real,long) as a string
                         in base 10 or 16 (hex) (function)
         Real_To_Long    convert real to long integer
         long_To_Real    convert long integer to real (function)
         Global Carry
       Tweaked other long procedures a little.
       No reported bugs to date (e.g., no reports at all!)

 V1.1:  Vastly improved inline assembler in TOADLONG.INC
        (was doing v1.0 for relaxation and musta been
        REALLY tired to write such Freshman assembler
        (no offense to Freshmen).
        Fixed a logic error in Long_RcR and Long_RcL,
        and a math error (stupid damned signed integers) in long_To_Real.
        Added a bunch more long integer functions in TOADLONG.INC.
        Added some more flashy tests, nicer interface, in TOADTEST.PAS.
        Split out timer stuff to TOADTIME.INC.


  Many credits to L. David Baldwin, author of INLINE v2.02.  The use of
  this public domain utility for hacking the inline assembler code
  was invaluable!  (Now if he'd only put back the ability to quote a
  character instead of having to use ASCII values!)

  David Kirschbaum
  Toad Hall
  [e-mail]
  (and in the other world...
    7573 Jennings Lane
    Fayetteville NC  28303 (the howling wilderness of computerdom)
    [phone]
  )
*)

{$I TOADINT.INC   unsigned integer functions with a couple TYPEs }
{$I TOADLONG.INC  long integer functions/procedures }
                  { with some TYPEs, CONSTants, and VARs }
{$I TOADPOWR.INC  sqr,sqrt, power-related functions }
{$I TOADCONV.INC  various conversion utilities }
{$I TOADTIME.INC  same thing here }

TYPE
  Str80 = STRING[80];

CONST
  CR = #$0D;
  LF = #$0A;

VAR Ch :CHAR;

PROCEDURE Prompt;
  {Support procedure.  Wait for user's key to continue}
  VAR Ch : CHAR;
  BEGIN
    WRITE(LF, 'Press any key to continue: ');
    REPEAT UNTIL KeyPressed;  READ(Kbd,Ch);
    WRITELN(LF);
  END;  {of Prompt}


FUNCTION Tab(col : INTEGER) : Str80;
  {Figure current line position, build a string of spaces
   long enough to fill to col.  Just for pretty displays.
  }
  VAR
    x : INTEGER;
    Temp : Str80;
  BEGIN
    FillChar(Temp,81,' ');              {fill a string with blanks}
    x := WhereX;
    IF col > x THEN x := col - x        {distance to col}
    ELSE x := 0;                        {0 length}
    Temp[0] := CHR(x);                  {force string length}
    Tab := Temp;
  END;  {of Tab}


PROCEDURE Do_End(N2,T2 : Str80);
  {Support function.  Common elapsed time, final result display}
  BEGIN
    GotoXY(44,whereY);
    WRITELN(N2, Tab(60), T2);           {elapsed time}
  END;  {of Do_End}


PROCEDURE Test_Date_Time;
  BEGIN
    WRITELN('Date and Time String Test:');
    Date;
    WRITELN('DateStr: [', DateStr, ']');
    Time;
    WRITELN('TimeStr: [', TimeStr, ']');
    Prompt;
  END;  {of Test_Date_Time}


PROCEDURE Test_Long_Add_Long;
  {Add long to long}
  VAR
    i,j : INTEGER;
    long1,long2 : long_int;
    T1  : STRING[20];
  BEGIN
    Zero_Long(long1);                   {initialize a working long int}
    Make_Long(0,100, long2);

    WRITE('Long + Long Add',
          Tab(28), AnyNum_Str(long1, longtyp),
          Tab(45), 'Running...' );

    Time;                               {update global time variables}

    FOR i := 1 TO MAXINT DO
      FOR j := 1 TO 2 DO                {twice for Kb}
        Long_Add(long1,long2);          {long + long}
    FOR j := 1 TO 2 DO
      Long_Add(long1,long2);            {correct MAXINT shortage}
    long2.lo := 1;                      {a wee little add}
    Long_Add(long1,long2);              {make it obvious}

    T1 := Now;                          {remember elapsed time}
    Do_End(AnyNum_Str(long1, longtyp),T1); {display final results}
  END;  {of Test_Long_Add_Long}


PROCEDURE Test_Real_Add_Real;
  {Same numbers as Test_Long_Add_Long, to let you compare
   elapsed times and results.
  }
  VAR
    i,j   : INTEGER;
    r1,r2 : REAL;
    T1    : STRING[20];
  BEGIN
    r1 := 0.0;                          {let's test with reals now}
    r2 := 100.0;

    WRITE('Real + Real Add',
          Tab(28), AnyNum_Str(r1,realtyp),
          Tab(45), 'Running');

    Time;                               {update global time variables}

    FOR i := 1 TO MAXINT DO
      FOR j := 1 TO 2 DO                {twice for Kb}
        r1 := r1 + r2;                  {real + real}
    FOR j := 1 TO 2 DO
      r1 := r1 + r2;                    {correct MAXINT shortage}
    r2 := 1.0;                          {a wee little add}
    r1 := r1 + r2;                      {make it obvious}

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(r1, realtyp),T1); {display final results}
  END;  {of Test_Real_Add_Real}


PROCEDURE Test_Long_Add_Integer;
  {Adding big numbers real fast, but not so intuitively obvious
   it's working right!
  }
  VAR
    i,j   : INTEGER;
    long1 : long_int;
    T1    : STRING[20];
  BEGIN
    Zero_Long(long1);                   {initialize a working long int}
    WRITE('Long + Integer Add',
          Tab(28), AnyNum_Str(long1,longtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO MAXINT DO
      FOR j := 1 TO 2 DO                {twice for Kb}
        Long_Add_I(long1,100);          {long + integer}
    FOR j := 1 TO 2 DO
      Long_Add_I(long1,100);            {correct MAXINT shortage}
    Long_Add_I(long1,1);                {a wee little add}

    T1 := Now;                          {remember elapsed time}
    Do_End(AnyNum_Str(long1, longtyp),T1);  {display final results}
  END;  {of Test_Long_Add_Integer}


PROCEDURE Test_Real_Add_Integer;
  {Same numbers as Test_Long_Add_Integer_2, to let you compare
   elapsed times and (!) results (!).
  }
  VAR
    i,j : INTEGER;
    r   : REAL;
    T1  : STRING[20];
  BEGIN
    r := 0.0;                           {let's test with reals now}
    WRITE('Real + Integer Add',
          Tab(28), AnyNum_Str(r, realtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO MAXINT DO
      FOR j := 1 TO 2 DO                {twice for Kb}
        r := r + 100;                   {real + integer}
    FOR j := 1 TO 2 DO
      r := r + 100;                     {correct MAXINT shortage}
    r := r + 1.0;                       {a wee little add}

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(r,realtyp),T1);   {display final results}
  END;  {of Test_Real_Add_Integer}


PROCEDURE Test_Long_Inc;
  {Same numbers, but we're just gonna increment the long int.}
  VAR
    i,j   : INTEGER;
    long1 : long_int;
    T1    : STRING[20];
  BEGIN
    Make_Long(1,0, long1);              {start with a nice big number}

    WRITE('Increment Long',
          Tab(28), AnyNum_Str(long1, longtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO MAXINT DO
      FOR j := 1 TO 2 DO                {twice for Kb}
        Long_inc(long1);                {increment long}
    FOR j := 1 TO 3 DO
      Long_inc(long1);                  {correct MAXINT shortage, +1}

    T1 := Now;                          {remember expended time}
    Do_End(AnyNum_Str(long1,longtyp),T1);  {display final results}
  END;  {of Test_Long_Inc}


PROCEDURE Test_Real_Inc;
  {Same numbers, but we're just gonna increment the real.}
  VAR
    i,j   : INTEGER;
    long1 : long_int;
    r     : REAL;
    T1    : STRING[20];
  BEGIN
    Make_Long(1,0, long1);              {start with a nice big number}
    r := long_To_Real(long1);           {insure we have same number}

    WRITE('Increment Real',
          Tab(28), AnyNum_Str(r, realtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO MAXINT DO
      FOR j := 1 TO 2 DO                {twice for Kb}
        r := r + 1.0;                   {increment real}
    FOR j := 1 TO 3 DO
      r := r + 1.0;                     {correct MAXINT error, +1}

    T1 := Now;                          {remember expended time}
    Do_End(AnyNum_Str(r, realtyp),T1);  {display final results}
  END;  {of Test_Real_Inc}


PROCEDURE Test_Long_Dec;
  {Same numbers, but we're just gonna decrement the long int.}
  VAR
    i,j   : INTEGER;
    long1 : long_int;
    T1    : STRING[20];
  BEGIN
    Make_Long($FFFF,0, long1);          {start with a nice big number}

    WRITE('Decrement Long',
          Tab(28), AnyNum_Str(long1, longtyp),
         Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO MAXINT DO
      FOR j := 1 TO 2 DO                {twice for Kb}
        Long_dec(long1);                {decrement long}
    FOR j := 1 TO 3 DO
      Long_dec(long1);                  {correct MAXINT shortage, -1}

    T1 := Now;                          {remember expended time}
    Do_End(AnyNum_Str(long1, longtyp),T1);  {display final results}
  END;  {of Test_Long_Dec}


PROCEDURE Test_Real_Dec;
  {Same numbers, but we're just gonna decrement the real.}
  VAR
    i,j   : INTEGER;
    long1 : long_int;
    r     : REAL;
    T1    : STRING[20];
  BEGIN
    Make_Long($FFFF,0, long1);          {start with a nice big number}
    r := long_To_Real(long1);           {insure we have same number}

    WRITE('Decrement Real',
          Tab(28), AnyNum_Str(r,realtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO MAXINT DO
      FOR j := 1 TO 2 DO                {twice for Kb}
        r := r - 1.0;                   {decrement real}
    FOR j := 1 TO 3 DO
      r := r - 1.0;                     {correct MAXINT error, -1}

    T1 := Now;                          {remember expended time}
    Do_End(AnyNum_Str(r, realtyp),T1);  {display final results}
  END;  {of Test_Real_Dec}


PROCEDURE Test_Long_Mul_Integer;
  {Multiply long * integer.
   We can't blindly do nr := nr * INT too often, or even the REALs
   will overflow!  For this reason, we just multiply our long
   by the loop counter.
  }
  VAR
    i,j   : INTEGER;
    long1,
    long2 : long_int;
    T1    : STRING[20];
  BEGIN
    Make_Long(0,8,long1);               {init a multiplicand}

    WRITE('Long * Integer Mul',
          Tab(28), AnyNum_Str(long1, longtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch our test time}
      long2 := long1;                   {refresh working multiplicand}
      FOR j := 1 TO 8 DO BEGIN
        Long_Mul_I(long2,7);            {long * integer}
        IF CF THEN Writeln(' !OVERFLOW! ');
      END;
    END;

    T1 := Now;                          {remember elapsed time}
    Do_End(AnyNum_Str(long2, longtyp),T1); {display final results}
  END;  {of Test_Long_Mul_Integer}


PROCEDURE Test_Real_Mul_Integer;
  {Same numbers as Test_Long_Mul_Integer, to let you compare
   elapsed times and (!) results (!).
   We can't blindly multiply nr := nr * integer too often, or even the REALs
   will overflow!  For this reason, we just multiply our real by a constant
   in an inner loop.
  }
  VAR
    i,j   : INTEGER;
    r1,r2 : REAL;
    long1 : long_int;
    T1    : STRING[20];
  BEGIN
    r1 := 8.0;                          {initialize a multiplicand}

    WRITE('Real * Integer Mul',
          Tab(28), AnyNum_Str(r1, realtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch our test time}
      r2 := r1;                         {refresh working multiplicand}
      FOR j := 1 TO 8 DO BEGIN
        r2 := r2 * 7;                   {real * integer}
        IF CF THEN ;                    {keep time test fair}
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(r2, realtyp),T1); {display final results}
  END;  {of Test_Real_Mul_Integer}


PROCEDURE Test_Long_Mul_Long;
  {Multiplying long * long.
   We can't blindly do nr := nr * nr too often, or even the REALs
   will overflow!
  }
  VAR
    i,j    : INTEGER;
    long1,
    long2,
    long3  : long_int;
    T1     : STRING[20];
  BEGIN
    Make_Long(0,8,long1);               {long multiplicand}
    Make_Long(0,7,long2);               {long multiplier}

    WRITE('Long * Long Mul',
          Tab(28), AnyNum_Str(long1, longtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch out test time}
      long3 := long1;                   {refresh long multiplicand}
      FOR j := 1 TO 8 DO BEGIN
        Long_Mul(long3,long2);          {long * long}
        IF CF THEN Writeln(' !Overflow Error!');
      END;
    END;

    T1 := Now;                          {remember elapsed time}
    Do_End(AnyNum_Str(long3, longtyp),T1);  {display final results}
  END;  {of Test_Long_Mul_Long}


PROCEDURE Test_Real_Mul_Real;
  {Same numbers as Test_Long_Mul_Long, to let you compare
   elapsed times and (!) results (!).
   We can't blindly multiply nr := nr * nr too often, or even the REALs
   will overflow!
  }
  VAR
    i,j      : INTEGER;
    r1,r2,r3 : REAL;
    T1       : STRING[20];
  BEGIN
    r1 := 8.0;                          {real multiplicand "constant" }
    r2 := 7.0;                          {real multiplier}

    WRITE('Real * Real Mul',
          Tab(28), AnyNum_Str(r1, realtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch out test time}
      r3 := r1;                         {refresh working dividend}
      FOR j := 1 TO 8 DO BEGIN
        r3 := r3 * r2;                  {real * real}
        IF CF THEN ;                    {keep time test fair}
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(r3, realtyp),T1); {display final results}
  END;  {of Test_Real_Mul_Real}


PROCEDURE Test_Long_Div_Integer;
  {Dividing long integer by integer.
   Can't blindly do a nr := nr divided by INT too long, or even the REALs
   will overflow or get a DIV 0 problem.  For this reason, we just divide
   a nice big long by the loop counter.
  }
  VAR
    i,j   : INTEGER;
    long1,
    long2 : long_int;
    T1    : STRING[20];
  BEGIN
    Make_Long($FFFF,$FFFE,long1);       {make a working dividend}

    WRITE('Long / Integer Div',
          Tab(28), AnyNum_Str(long1, longtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch our test time}
      long2 := long1;                   {refresh our working dividend}
      FOR j := 1 TO 9 DO BEGIN
        Long_Div_I(long2,7);            {long / integer}
        IF CF THEN Writeln(' !OVERFLOW! ');
      END;
    END;

    T1 := Now;                          {remember elapsed time}
    Do_End(AnyNum_Str(long2, longtyp), T1);   {display final results}
  END;  {of Test_Long_Div_Integer}


PROCEDURE Test_Real_Div_Integer;
  {Same numbers as Test_Long_Div_Integer, to let you compare
   elapsed times and (!) results (!).
   Can't blindly do a nr := nr divided by INT too long, or even the REALs
   will overflow or get a DIV 0 problem.  For this reason, we just divide
   a nice big REAL by the loop counter.
  }
  VAR
    i,j   : INTEGER;
    long1 : long_int;
    r1,r2 : REAL;
    T1    : STRING[20];
  BEGIN
    Make_Long($FFFF,$FFFE,long1);       {make a working dividend}
    r1 := long_To_Real(long1);          {insure we have same number}

    WRITE('Real / Integer Div',
           Tab(28), AnyNum_Str(r1, realtyp),
           Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch our test time}
      r2 := r1;                         {refresh working real dividend}
      FOR j := 1 TO 9 DO BEGIN
        r2 := r2 / 7;                   {real / integer}
        IF CF THEN;                     {keep time test fair}
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(r2, realtyp), T1);{display final results}
  END;  {of Test_Real_Div_Integer}


PROCEDURE Test_Long_Div_Long;
  {Dividing big numbers (long / long).
   We can't blindly do nr := nr / nr too often, or even the REALs
   will overflow or get a DIV 0 error!  For this reason, we just
   divide our long by a long loop counter.
  }
  VAR
    i,j,k : INTEGER;
    long1,
    long2,
    long3  : long_int;
    T1     : STRING[20];
  BEGIN
    Make_Long($FFFF,$FFFE,long1);       {long dividend}
    Make_Long(0,7,long2);               {long divisor}

    WRITE('Long / Long Div',
          Tab(28), AnyNum_Str(long1, longtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch out test time}
      long3 := long1;                   {refresh working dividend}
      FOR j := 1 TO 9 DO BEGIN
        Long_Div(long3,long2);          {long / long}
        IF CF THEN Writeln(' !OVERFLOW! ');
      END;
    END;

    T1 := Now;                          {remember elapsed time}
    Do_End(AnyNum_Str(long3, longtyp),T1);  {display final results}
  END;  {of Test_Long_Div_Long}


PROCEDURE Test_Real_Div_Real;
  {Same numbers as Test_Long_Div_Long, to let you compare
   elapsed times and (!) results (!).
   We can't blindly divide nr := nr / nr too often, or even the REALs
   will overflow or get a DIV 0 error!  For this reason, we just
   divide our real by the loop counter.
  }
  VAR
    i,j      : INTEGER;
    r1,r2,r3 : REAL;
    long1    : long_int;
    T1       : STRING[20];
  BEGIN
    Make_Long($FFFF,$FFFE,long1);       {long dividend}
    r1 := long_To_Real(long1);          {insure we have same number}

    WRITE('Real / Real Div',
          Tab(28), AnyNum_Str(r1, realtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch out test time}
      r3 := r1;                         {refresh working dividend}
      FOR j := 1 TO 9 DO BEGIN
        r3 := r3 / 7.0;                 {real / real}
        IF CF THEN;                     {keep time test fair}
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(r3, realtyp),T1); {display final results}
  END;  {of Test_Real_Div_Real}


PROCEDURE Test_Int_Sqr;
  {Test the built-in Turbo square function with an INTEGER}
  VAR
    i,j,k,l: INTEGER;
    T1     : STRING[20];
  BEGIN
    l := 3;                             {a likely number to square}

    WRITE('Integer Sqr (Turbo)',
          Tab(28), AnyNum_Str(l, inttyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 10000 DO BEGIN        {stretch out test time}
      k := l;                           {refresh our integer}
      FOR j := 1 TO 4 DO BEGIN
        k := Sqr(k);                    {integer square}
        IF CF THEN;                     {keep time test fair}
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(k, inttyp),T1);   {display final results}
  END;  {of Test_Int_Sqr}

PROCEDURE Test_Sqr32;
  {Test the sqr32 procedure (product is long int)}
  VAR
    i,j : INTEGER;
    long1,
    long2 : long_int;
    T1    : STRING[20];
  BEGIN
    Make_Long(0,3,long1);               {long1.lo = a likely integer to square}

    WRITE('Sqr32',
          Tab(28), AnyNum_Str(long1.lo, inttyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 10000 DO BEGIN        {stretch out test time}
      long2 := long1;                   {refresh our long2.lo int,
                                         clear long2.hi}
      FOR j := 1 TO 4 DO BEGIN
        Sqr32(long2.lo,long2);          {square int, product in long2}
        IF CF THEN Writeln(' !OVERFLOW! ');
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(long2, longtyp),T1); {display final results}
  END;  {of Test_Sqr32}

PROCEDURE Test_Long_Sqr;
  {Test the long square procedure}
  VAR
    i,j    : INTEGER;
    long1,
    long2  : long_int;
    T1     : STRING[20];
  BEGIN
    Make_Long(0,3,long1);               {a likely number to square}

    WRITE('Long    Sqr',
          Tab(28), AnyNum_Str(long1, longtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 10000 DO BEGIN        {stretch out test time}
      long2 := long1;                   {refresh our long}
      FOR j := 1 TO 4 DO BEGIN
        Long_Sqr(long2);                {long square}
        IF CF THEN Writeln(' !OVERFLOW! ');
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(long2, longtyp),T1); {display final results}
  END;  {of Test_Long_Sqr}

PROCEDURE Test_Real_Sqr;
  {Test the built-in Turbo square function with REALs}
  VAR
    i,j    : INTEGER;
    r1,r2  : REAL;
    T1     : STRING[20];
  BEGIN
    r1 := 3.0;                          {a likely number to square}

    WRITE('Real    Sqr (Turbo)',
          Tab(28), AnyNum_Str(r1, realtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 10000 DO BEGIN        {stretch out test time}
      r2 := r1;                         {refresh our real}
      FOR j := 1 TO 4 DO BEGIN
        r2 := Sqr(r2);                  {real square}
        IF CF THEN;                     {keep time test fair}
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(r2, realtyp),T1); {display final results}
(* If you wish to examine the actual REAL result
   (including decimal points), enable this:

Write('The actual real: ', r2:10:10);
*)
  END;  {of Test_Real_Sqr}


PROCEDURE Test_Int_Sqrt16;
  {Test our integer square root function Sqrt16}
  VAR
    i,j,
    k,l : INTEGER;
    r   : REAL;
    T1  : STRING[20];
  BEGIN
    k := 81*81;                         {a likely square 3^4 = 81^2}

    WRITE('Integer Sqrt16',
          Tab(28), AnyNum_Str(k, inttyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 3333 DO BEGIN         {stretch out test time}
      l := k;                           {refresh integer square}
      FOR j := 1 TO 3 DO                {from 6561 down to 3}
        l := Sqrt16(l);                 {integer square root => integer}
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(l, inttyp),T1); {display final results}
  END;  {of Test_Int_Sqrt}

PROCEDURE Test_Real_Sqrt;
  {Test the built-in Turbo square root function
   (which returns a REAL), which we convert to an integer.
  }
  VAR
    i,j,k,l: INTEGER;
    r      : REAL;
    T1     : STRING[20];
  BEGIN
    k := 81*81;                         {a likely square 3^4 = 81^2}

    WRITE('Integer Sqrt (Turbo)',
          Tab(28), AnyNum_Str(k, inttyp),
          Tab(45), 'Running..a REAL slug!');

    Time;                               {update global time variables}

    FOR i := 1 TO 3333 DO BEGIN         {stretch out test time}
      l := k;                           {refresh integer square}
      FOR j := 1 TO 3 DO                {from 6561 down to 3}
        l := TRUNC(Sqrt(l));            {integer square root => real => int}
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(l, inttyp),T1);   {display final results}
(* If you wish to examine the actual REAL result
   (including decimal points), enable this:

l := k;
FOR j := 1 TO 3 DO BEGIN
  r := Sqrt(l);
  l := TRUNC(r);
END;
Write('The actual real: ', r:10:10);
*)
  END;  {of Test_Real_Sqrt}


PROCEDURE Test_Long_Sqrt_Int;
  {Test the long square root function, using values > 65535}
  VAR
    i,j    : INTEGER;
    long1,
    long2  : long_int;
    T1     : STRING[20];
  BEGIN
    Make_Long($0290,$D741,long1);       {an unlikely square, 81^4}

    WRITE('Long    Sqrt',
          Tab(28), AnyNum_Str(long1, longtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch out test time}
      long2 := long1;                   {refresh our square}
      FOR j := 1 TO 4 DO BEGIN          {from 65536 down to 2}
        long2.lo := Long_Sqrt(long2);   {long square root => integer}
        long2.hi := 0;                  {artificial, but for testing...}
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(long2, longtyp),T1); {display final results}
  END;  {of Test_Long_Sqrt_Int}

PROCEDURE Test_Real_Sqrt_Real;
  {Test the built-in Turbo square root function
   (which returns a REAL)
  }
  VAR
    i,j    : INTEGER;
    long1  : long_int;
    r1,r2  : REAL;
    T1     : STRING[20];
  BEGIN
    Make_Long($0290,$D741,long1);       {an unlikely square, 81^4}
    r1 := long_To_Real(long1);          {insure we have same number}

    WRITE('Real    Sqrt (Turbo)',
          Tab(28), AnyNum_Str(r1, realtyp),
          Tab(45), 'Running..a REAL slug!');

    Time;                               {update global time variables}

    FOR i := 1 TO 2500 DO BEGIN         {stretch out test time}
      r2 := r1;                         {refresh our square}
      FOR j := 1 TO 4 DO BEGIN          {from 65536 down to 2}
        r2 := Sqrt(r2);                 {real square root}
        long1.hi := 0;                  {keep it honest}
      END;
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(r2, realtyp),T1); {display final results}
(* If you wish to examine the actual REAL result
   (including decimal points), enable this:

Write('The actual real: ', r2:10:10);
*)
  END;  {of Test_Real_Sqrt_Real}


PROCEDURE Test_Long_Mod;
  {Long modulus}
  VAR
    i,j    : INTEGER;
    long1,
    long2,
    long3  : long_int;
    T1     : STRING[20];
  BEGIN
    Make_Long(20,1,long1);              {long dividend}
    Make_Long(10,0,long2);              {long divisor}

    WRITELN('Long Modulus',
          Tab(28), AnyNum_Str(long1, longtyp));
    WRITE(Tab(24), 'mod ',
          AnyNum_Str(long2, longtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 10000 DO BEGIN        {stretch out test time}
      Long_Mod(long1,long2,long3);      {long mod => long3}
      IF CF THEN Writeln(' !OVERFLOW! ');
    END;

    T1 := Now;                          {remember elapsed time}
    Do_End(AnyNum_Str(long3, longtyp),T1);  {display final results}
  END;  {of Test_Long_Mod}


PROCEDURE Test_Real_Mod;
  {Same numbers as Test_Long_Mod, to let you compare
   elapsed times and (!) results (!).
   You can't really use MOD with REALs, so we must do it the hard way.
  }
  VAR
    i,j      : INTEGER;
    r1,r2,r3 : REAL;
    long1,long2 : long_int;
    S1,
    T1       : STRING[20];
  BEGIN
    Make_Long(20,1,long1);              {long dividend}
    Make_Long(10,0,long2);              {long divisor}

    r1 := long_To_Real(long1);          {insure we have same number}
    r2 := long_To_Real(long2);

    WRITELN('Real Modulus',
          Tab(28), AnyNum_Str(r1, realtyp));
    WRITE(Tab(24),'mod ',
          AnyNum_Str(r2, realtyp),
          Tab(45), 'Running...');

    Time;                               {update global time variables}

    FOR i := 1 TO 10000 DO BEGIN        {stretch out test time}
      r3 := real_Mod(r1,r2);            {a function in TOADCONV.INC}
      IF CF THEN;                       {keep it honest}
    END;

    T1 := Now;                          {remember time}
    Do_End(AnyNum_Str(r3, realtyp),T1); {display final results}
END;  {of Test_Real_Mod}


PROCEDURE Long_vs_Real;
  {The next tests have timers built in, remember final values,
   etc., so you can get a comparison of elapsed time and accuracy
   between adding really big numbers with long ints and Reals.
  }
  BEGIN
    WRITELN('Speed and accuracy competition between Toadlongs');
    WRITELN('and Turbo Reals, in the following math tests:');
    WRITELN('Long := Long + Long  vs  Real := Real + Real');
    WRITELN('Long := Long + Int   vs  Real := Real + Int');
    WRITELN('Long := SUCC(Long)   vs  Real := Real + 1');
    WRITELN('Long := PRED(Long)   vs  Real := Real - 1');
    WRITELN('Long := Long * Int   vs  Real := Real * Int');
    WRITELN('Long := Long / Int   vs  Real := Real / Int');
    WRITELN('Long := Long * Long  vs  Real := Real * Real');
    WRITELN('Long := Long / Long  vs  Real := Real / Real');
    WRITELN('Long := Sqr(Int)     vs');
    WRITELN('Long := Sqr(Long)   and  Real := Sqr(Real)');
    WRITELN('                    and  Int  := Sqr(Int)');
    WRITELN('Int  := Sqrt16(Int)  vs  Real := Sqrt(Int)');
    WRITELN('Int  := Sqrt32(Long) vs  Real := Sqrt(Real)');
    WRITELN('Long := Long MOD Long vs Real := Real MOD Real');
    WRITELN(LF, 'Fairly large loops are being used to');
    WRITELN('provide some significant times and differences.');
    WRITELN(LF,'Start the competition when ready.');
    Prompt;

WRITELN(
'    Test', Tab(28), 'Orig value', Tab(44), 'Final Value',
Tab(60), 'Elapsed Time');
    radix := 16;               {display in Hex}
(*
    Test_Long_Add_Long;        {add long to long}
    Test_Real_Add_Real;        {add real to real}
    Test_Long_Add_Integer;     {add integer to long}
    Test_Real_Add_Integer;     {add integer to real}
    Writeln;
    Test_Long_Inc;             {long increments}
    Test_Real_Inc;             {real increments}
    Test_Long_Dec;             {long decrements}
    Test_Real_Dec;             {real decrements}
    Prompt;                    {let him read the results}

    Test_Long_Mul_Integer;     {long multiplication}
    Test_Real_Mul_Integer;     {real multiplication}
    Test_Long_Mul_Long;        {long multiplication}
    Test_Real_Mul_Real;        {real multiplication}
    Writeln;
    Test_Long_Div_Integer;     {long division}
    Test_Real_Div_Integer;     {real division}
    Test_Long_Div_Long;        {long division}
    Test_Real_Div_Real;        {real division}
    Prompt;                    {let him read the results}
*)
    Test_Int_Sqr;              {integer square => integer}
    Test_Sqr32;                {integer square => long}
    Test_Long_Sqr;             {long square => long}
    Test_Real_Sqr;             {real square => real}
    Writeln;
    Test_Int_Sqrt16;           {integer square root => integer}
    Test_Real_Sqrt;            {Normal Turbo sqrt function => real => integer}
    Writeln;

    Test_Long_Sqrt_Int;        {long square root => integer}
    Test_Real_Sqrt_Real;       {Normal Turbo sqrt function w/reals}
    Prompt;                    {let him read the results}

    Test_Long_Mod;             {long modulus}
    Test_Real_Mod;             {real modulus, the hard way}
    Prompt;                    {let him read the results}
  END;  {of Long_vs_Real}


{The next require binary (bit-level) display functions}

PROCEDURE Test_Long_Add_Integer_1;
  {Adding not so very big numbers, but intuitively obvious it works.}
  VAR
    i,loop  : INTEGER;
    long1   : long_int;
    T1      : STRING[20];
    Ch      : CHAR;
    Visible : BOOLEAN;
  BEGIN
    WRITELN(LF, 'Long Add Integer Test:', LF);
    WRITELN('Incrementing a long integer by 1024.');
    WRITELN('Enter V for a Visual display (1000 loops, long screen dumps),');
    WRITELN('or any other key for a speed run');
    WRITELN('(', MAXINT, ' loops to give a measurable time).');

    WRITE('Enter "V" for visual, or any other key for speed run: ');
    REPEAT UNTIL Keypressed;
    READ(Kbd,Ch);
    Visible := (Ch IN ['V','v']);
    WRITELN;

    Zero_Long(long1);

    IF Visible THEN loop := 1000 ELSE BEGIN
      loop := MAXINT;                   {make it kinda big}
      WRITELN(LF,
'    Test', Tab(28), 'Orig value', Tab(44), 'Final Value',
Tab(60), 'Elapsed Time');

    WRITE('Long + Integer Add',
          Tab(28), LHex(long1),
          Tab(44), 'Running...' );
      Time;                             {update timer values}
    END;

    FOR i := 1 TO loop DO BEGIN
      Long_Add_I(long1, 1024);          {do the add}
      IF Visible THEN BEGIN
        WRITE(i:3, '[', LHex(long1), 'H] ');
        IF i MOD 5 = 0 THEN WRITELN;    {wrap around}
      END;
    END;

    T1 := Now;                          {remember elapsed time}
    IF Visible THEN WRITELN
    ELSE Do_End(LHex(long1), T1);       {display final results}

    Prompt;
  END;  {of Test_Long_Add_Integer_1}


PROCEDURE Test_Long_ShL;
  {Shows 32-bit Shift Left via visual display so you can watch
   the patterns flow.
  }
  VAR
    i     : INTEGER;
    long1 : long_int;
  BEGIN
    WRITELN(LF, 'Long Shift Left Test:', LF);
    long1 := LONG_ONE;
    WRITELN('Start ', LHex(long1), ' ',
            LHex(long1), ' ', Byte32_Str(long1), LF );

    FOR i := 1 TO 31 DO BEGIN
      WRITE(i:3, ' = ', LHex(long1) , ' ');      {hit, }
      Long_ShL(long1,1);                         {shift, }
      WRITELN(LHex(long1), ' ',
              Byte32_Str(long1) );
    END;                                         {rotate! (joke)}
    Prompt;
  END;  {of Test_Long_ShL}


PROCEDURE Test_Long_ShR;
  {Same as Shift Left, but in the other direction.}
  VAR
    i     : INTEGER;
    long1 : long_int;
  BEGIN
    WRITELN(LF, 'Long Shift Right Test:', LF);
    Make_Long($8000,0, long1);
    WRITELN('Start ', LHex(long1), ' ',
            LHex(long1), ' ', Byte32_Str(long1) , LF);

    FOR i := 1 TO 31 DO BEGIN
      WRITE(i:3, ' = ', LHex(long1) , ' ');      {hit, }
      Long_ShR(long1,1);                         {shift, }
      WRITELN(LHex(long1), ' ',
              Byte32_Str(long1) );
    END;                                         {rotate! (joke)}
    Prompt;
  END;  {of Test_Long_ShR}


PROCEDURE Test_Long_RcL;
  {32-bit Rotate Carry Left.
   In a Rotate Carry, the bits falling off the end are expected
   to drop into the "flags" carry register, and the "flags" carry
   be stuffed into the other end.  Got a little tricky with double registers.
  }
  VAR
    i     : INTEGER;
    long1 : long_int;
  BEGIN
    WRITELN(LF, 'Long RcL Test:', LF);

    i := (1 + 4 + 16 + 64 + 256) ShL 4;         {set some pattern}
    Make_Long(i,i,long1);                       { in both words}

    WRITELN('Start ', LHex(long1), ' ',
            LHex(long1), ' ', Byte32_Str(long1) );

    Clc;                                        {function in TOADLONG.INC
                                                 to clear our carry flag}
    FOR i := 1 TO 31 DO BEGIN
      WRITE(i:3, ' = ', LHex(long1) , ' ');     {hit, }
      Long_RcL(long1,1);                        {RcL, }
      WRITELN(LHex(long1), ' ',
              Byte32_Str(long1) );
    END;                                        {rotate! (joke)}
    Prompt;
  END;  {of Test_Long_RcL}


PROCEDURE Test_Long_RcR;
  {32-bit Rotate Carry Right, again with bits falling off the right
   coming back in as "flags" to the "high" bit on the left.
  }
  VAR
    i     : INTEGER;
    long1 : long_int;
  BEGIN
    WRITELN(LF, 'Long RcR Test:', LF);

    i := 1 + 4 + 16 + 64 + 256;                 {make a pretty pattern}
    Make_Long(i,i,long1);                       { in both words}

    WRITELN('Start ', LHex(long1), ' ',
            LHex(long1), ' ', Byte32_Str(long1) );

    Clc;                                        {function in TOADLONG.INC
                                                 to clear our carry flag}
    FOR i := 1 TO 31 DO BEGIN
      WRITE(i:3, ' = ', LHex(long1) , ' ');     {hit, }
      Long_RcR(long1,1);                        {RcR, }
      WRITELN(LHex(long1), ' ',
              Byte32_Str(long1) );
    END;                                        {rotate! (joke)}
    Prompt;
  END;  {of Test_Long_RcR}


PROCEDURE Test_Long_Cmp;
  {Perform extensive tests on the long integer "Cmp"
   relational operators.
  }
    CONST  {some likely typed long integer constants}
      LONG_0         : long_int = (Lo:0     ; Hi:0);
      LONG_1         : long_int = (Lo:1     ; Hi:0);
      LONG_MAXINT    : long_int = (Lo:MAXINT; Hi:0);
      LONG_MAXINT1   : long_int = (Lo:$8000 ; Hi:0);     {MAXINT+1}
      LONG_HIMAXINT  : long_int = (Lo:0     ; Hi:MAXINT);
      LONG_HIMAXINT1 : long_int = (Lo:0     ; Hi:$8000); {MAXINT+1}

(* Some other longs you may wish to play with:
      LONG_256  : long_int = (Lo:256 ; Hi:0);
      LONG_65K  : long_int = (Lo:1024; Hi:1);  {got that, right?}
      LONG_256K : long_int = (Lo:0   ; Hi:4);  {so you obviously got this}
*)
      OpStr : ARRAY[Rel_Op] OF STRING[7] =  {for testing}
        ('Eq (= )', 'Gt (> )', 'Lt (< )', 'Ne (<>)', 'Ge (>=)', 'Le (<=)');

(* Enable the following if you wish to pass INTEGER parameters
  PROCEDURE Cmp_Test(hi1,lo1, hi2,lo2 : INTEGER);
*)
(* Enable the following if you wish to pass long integer parameters *)
  PROCEDURE Cmp_Test(VAR long1,long2 : long_int);

    {common 32-bit long int relational operators.
     Long constants are explained/defined in TOADLONG.INC.
    }
    VAR
(* Enable the following if you're passing INTEGER parameters
      long1,long2 : long_int;
*)
      N1,N2 : STRING[20];
      op : Rel_Op;  {defined in TOADLONG.INC}
    BEGIN
      WRITELN(LF, 'Long Integer Relational Operator Tests:',LF);
(* Enable the following if you're passing INTEGER parameters
      Make_Long(hi1,lo1, long1);
      Make_Long(hi2,lo2, long2);
*)
      LStr_Hex(long1, N1);   {make some long integer hex strings}
      LStr_Hex(long2, N2);

      Writeln(
{
     0000:0000 cmp 0000:0000  0000:0000 cmp 0000:0000  0000:0000 cmp 0000:0000
}
'    ', N1,  ' cmp ', N2,  '  ', N2,  ' cmp ', N1,  '  ', N1,  ' cmp ', N1);
      FOR op := Eq TO Le DO
        WRITELN(OpStr[op], ': ',
                Tab(15), Long_Cmp(long1, op, long2),
                Tab(40), Long_Cmp(long2, op, long1),
                Tab(65), Long_Cmp(long1, op, long1) );
      Prompt;
    END;  {of Cmp_Test}

  BEGIN  {Test_Long_Cmp}
(* You can pass long integer parameters as integers to a function or procedure
   (in this case, Cmp_Test just above, letting Cmp_Test build the long integers
   itself) ...
    Cmp_Test(0,1, 0,0);
    Cmp_Test(0,MAXINT+1, 0,MAXINT);
    Cmp_Test(MAXINT+1,0, MAXINT,0);
*)
(* Or you can pass long integers themselves to a function or procedure:
*)
   Cmp_Test(LONG_1, LONG_0);
   Cmp_Test(LONG_MAXINT1, LONG_MAXINT);
   Cmp_Test(LONG_HIMAXINT1, LONG_HIMAXINT);

  END;  {of Test_Long_Cmp}


(******** Long NOT Testing ********)

PROCEDURE Test_Long_Not;
  {Test our Long_Not procedure and its sister Long_Not_Test
   boolean function.
  }
  VAR long1 : long_int;

  PROCEDURE Not_Test(local1 : long_int);
    {NOT the long int local1, then test it against the NOT product.
     Notice in the procedure line above that you do NOT have to declare
     local1 a VAR ("VAR local1 : long_int").
     However, WARNING!  Turbo is passing an address to local 1 as the
     parameter, NOT the actual record itself.  In other words, Turbo is
     still acting EXACTLY as if you had said "VAR local1"!
     local1 is going to be changed by ANYTHING you do to it here!
     Don't forget that!  It bit me BIG TIME until I got used to it.
    }
    VAR
      localNot : long_int;
      Boo      : BOOLEAN;
    BEGIN
      Long_Not(local1, localNot);               {first get a NOTted long
                                                 localNot := local1 NOT local1}
      Boo := Long_Not_Test(local1, localNot);   {test for NOTted match}

      Writeln(
'Original long    NOTted long    Is it NOT?    long - 1    Is it NOT?');
      Write(LHex(local1),
            '        ', LHex(localNot),
            '      ', Boo);

      Long_Dec(local1);                         {change the long a bit}
      Boo := Long_Not_Test(local1, localNot);   {do the test again}
      Writeln('          ',LHex(local1),
              '   ', Boo);
    END;  {of Not_Test}


  BEGIN   {Test_Long_Not}
    WRITELN(LF, 'Long NOT and NOT NOT Tests:',LF);

    Make_Long(0,0, long1);     Not_Test(long1);
    Make_Long(0,1, long1);     Not_Test(long1);
    Make_Long($FF,0, long1);   Not_Test(long1);
    Make_Long($FF,$FF, long1); Not_Test(long1);

    Prompt;
  END;  {of Test_Long_Not}


PROCEDURE Test_Long_Xor;
  {Long integer Exclusive Or test}
  VAR
    long1, long2 : long_int;
    N0, N1, N2, N3 : Str12;
  BEGIN
    WRITELN(LF, 'Long Xor Test:', LF);
    Make_Long(64,64, long1);            {create a constant for XORing}
    LStr_Hex(long1, N0);                {remember it}

    long2.hi := (1 + 4 + 16 + 64 + 256) ShL 4;  {set some pattern}
    long2.lo := long2.hi;
    LStr_Hex(long2, N1);                {Remember original value}


  { long2 := long2 XOR long1 }
    Long_Xor(long2, long1);             {first get an XORed long}
    LStr_Hex(long2, N2);                {remember first XORed value}

    Long_Xor(long2, long1);             {XOR it with same value}
    LStr_Hex(long2, N3);                {(answer should be same as original)}

    Writeln(
'Original long     XORed with      XORed long      XORed again');
    WRITELN('  ', N1,
            '       ', N0,
            '       ', N2,
            '       ', N3 );

    Long_Xor(long2, long2);             {should produce a 0}
    LStr_Hex(long2, N1);                {remember product}
    Long_Xor(long2, long2);
    LStr_Hex(long2, N2);                {remember product}

    Writeln('  ', N3,
            '       ', N3,
            '       ', N1,
            '       ', N2 );
    Prompt;

  END;  {of Test_Long_Xor}


PROCEDURE Test_Long_Mul_Integer_1;
  {v1.3 Multiplying not so very big numbers, but intuitively obvious it works.}
  VAR
    i,loop  : INTEGER;
    long1   : long_int;
    T1      : STRING[20];
    Ch      : CHAR;
    Visible : BOOLEAN;
  BEGIN
    WRITELN(LF, 'Long * Integer Multiply Test:', LF);
    WRITELN('Multiplying a long integer by 2.');
    WRITELN('Enter V for a Visual display (1000 loops, long screen dumps),');
    WRITELN('or any other key for a speed run');
    WRITELN('(', MAXINT, ' loops to give a measurable time).');

    WRITE('Enter "V" for visual, or any other key for speed run: ');
    REPEAT UNTIL Keypressed;
    READ(Kbd,Ch);
    Visible := (Ch IN ['V','v']);
    WRITELN;

    Make_Long(1,1,long1);  {so long.hi and long.lo both have a value}

    IF Visible THEN loop := 1000 ELSE BEGIN
      loop := MAXINT;                   {make it kinda big}
      WRITELN(LF,
'    Test', Tab(28), 'Orig value', Tab(44), 'Final Value',
Tab(60), 'Elapsed Time');

    WRITE('Long * Integer Multiply',
          Tab(28), LHex(long1),
          Tab(44), 'Running...' );
      Time;                             {update timer values}
    END;

    FOR i := 1 TO loop DO BEGIN
      Long_Mul_I(long1, 2);    {do the multiplication}
      IF Visible THEN BEGIN
        WRITE(i:3, '[', LHex(long1), 'H] ');
        IF i MOD 5 = 0 THEN WRITELN;    {wrap around}
      END;
    END;

    T1 := Now;                          {remember elapsed time}
    IF Visible THEN WRITELN
    ELSE Do_End(LHex(long1), T1);       {display final results}

    Prompt;
  END;  {of Test_Long_Mul_Integer_1}


PROCEDURE Test_Long_Div_Integer_1;
  {v1.3 Dividing not so very big numbers, but intuitively obvious it works.}
  VAR
    i,loop  : INTEGER;
    long1   : long_int;
    T1      : STRING[20];
    Ch      : CHAR;
    Visible : BOOLEAN;
  BEGIN
    WRITELN(LF, 'Long / Integer Division Test:', LF);
    WRITELN('Dividing a long integer by 2.');
    WRITELN('Enter V for a Visual display (1000 loops, long screen dumps),');
    WRITELN('or any other key for a speed run');
    WRITELN('(', MAXINT, ' loops to give a measurable time).');

    WRITE('Enter "V" for visual, or any other key for speed run: ');
    REPEAT UNTIL Keypressed;
    READ(Kbd,Ch);
    Visible := (Ch IN ['V','v']);
    WRITELN;

    Make_Long($FFFF,$FFFF,long1);  {so long.hi and long.lo both have a value}

    IF Visible THEN loop := 1000 ELSE BEGIN
      loop := MAXINT;                   {make it kinda big}
      WRITELN(LF,
'    Test', Tab(28), 'Orig value', Tab(44), 'Final Value',
Tab(60), 'Elapsed Time');

    WRITE('Long * Integer Division',
          Tab(28), LHex(long1),
          Tab(44), 'Running...' );
      Time;                             {update timer values}
    END;

    FOR i := 1 TO loop DO BEGIN
      Long_Div_I(long1, 2);       {do the division}
      IF Visible THEN BEGIN
        WRITE(i:3, '[', LHex(long1), 'H] ');
        IF i MOD 5 = 0 THEN WRITELN;    {wrap around}
      END;
    END;

    T1 := Now;                          {remember elapsed time}
    IF Visible THEN WRITELN
    ELSE Do_End(LHex(long1), T1);       {display final results}

    Prompt;
  END;  {of Test_Long_Div_Integer_1}


PROCEDURE Test_LongReal;
  VAR long : long_int;

  PROCEDURE Do_Test;
    VAR
      long1 : long_int;
      r     : REAL;
      L16_1,L16_2,R16,
      L10_1,L10_2,R10 : STRING[20];
    BEGIN
      radix := 16;                              {display the original long}
      L16_1 := AnyNum_Str(long,longtyp);        {convert to hex string}
      r     := long_To_Real(long);              {long to real conversion}
      R16   := AnyNum_Str(r,realtyp);           {convert to hex string}
      Real_To_Long(r,long1);                    {back to long}
      L16_2 := AnyNum_Str(long1,longtyp);       {convert to hex string}

      radix := 10;                              {switch to base 10}
      L10_1 := AnyNum_Str(long,longtyp);        {convert to base 10 string}
      R10   := AnyNum_Str(r,realtyp);           {convert to base 10 string}
      L10_2 := AnyNum_Str(long1,longtyp);       {convert to base 10 string}

      Writeln('long         : ', L16_1, L10_1:20);
      Writeln(' long to real: ', R16  , R10  :20);
      Writeln(' real to long: ', L16_2, L10_2:20);
    END;  {of Do_Test}

  BEGIN  {Test_LongReal}
    Writeln('Testing Long <> REAL conversion:');

    Make_Long(0,1,long);            Do_Test;
    Make_Long(0,$7FFF,long);        Do_Test;  {tough area around MAXINT}
    Make_Long(0,$8000,long);        Do_Test;
    Make_Long(0,$8001,long);        Do_Test;
    Make_Long(0,$FFFF,long);        Do_Test;
    Make_Long(1,0,long);            Do_Test;
    Long_Inc(long);                 Do_Test;
    Make_Long(MAXINT,0,long);       Do_Test;
    Make_Long($FFFF,$FFFF, long);   Do_Test;
    Prompt;
  END;  {of Test_LongReal}


PROCEDURE Test_AnyNum_Str;
  VAR
    typ : numtype;
    i : INTEGER;
    long : long_int;

  PROCEDURE Do_Test;
    VAR
      i : INTEGER;
      r : REAL;
    BEGIN
      r := long_To_Real(long);  {test our long-to-real conversion also}
      i := long.lo;
      radix := 16;
      WRITE('long:',
            Tab(30), AnyNum_Str(long, longtyp));
      radix := 10;
      Writeln(Tab(60), AnyNum_Str(long, longtyp));
      radix := 16;
      WRITE('=> real:',
            Tab(30), AnyNum_Str(r,    realtyp));
      radix := 10;
      Writeln(Tab(60), AnyNum_Str(r,    realtyp));
      radix := 16;
      WRITE(' => integer:',
            Tab(30), AnyNum_Str(i,    inttyp ));
      radix := 10;
      Writeln(Tab(60), AnyNum_Str(i,    inttyp));
    END;  {of Do_Test}

  BEGIN  {Test_AnyNum_Str}
    Writeln('AnyNum_Str Test:',
            Tab(40), 'Radix 16',
            Tab(60), 'Radix 10');
    Make_Long(0,1,long);          Do_Test;
    Make_Long(0,$7FFF,long);      Do_Test;  {tough area around MAXINT}
    Make_Long(0,$8000,long);      Do_Test;
    Make_Long(0,$8001,long);      Do_Test;
    Make_Long(0,$FFFF,long);      Do_Test;
    Make_Long(1,0,long);          Do_Test;
    Make_Long($FFFF,$FFFF,long);  Do_Test;
    Prompt;
  END;  {of Test_AnyNum_Str}


BEGIN  {ToadTest main}

  Test_Date_Time;            {system time, date/time strings}

  Test_AnyNum_Str;           {generic number>string formatting}

  Test_LongReal;             {long <= => REAL conversion}

  Long_Vs_Real;              {speed test before boring stuff}

  Test_Long_Add_Integer_1;   {simple add integer to long int}

  Test_Long_Cmp;             {long integer relational operator tests}

  Test_Long_Not;             {long integer NOT function}

  Test_Long_ShL;             {Long shift/rotate tests}
  Test_Long_ShR;

  Test_Long_RcL;
  Test_Long_RcR;

  Test_Long_Xor;             {Long exclusive or}

  WRITELN('Toad Test completed.  Rivvvtt');
END.