test_big.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 684 行 · 第 1/2 页

//
// Copyright (C) 1991 Texas Instruments Incorporated.
//
// Permission is granted to any individual or institution to use, copy, modify,
// and distribute this software, provided that this complete copyright and
// permission notice is maintained, intact, in all copies and supporting
// documentation.
//
// Texas Instruments Incorporated provides this software "as is" without
// express or implied warranty.
//
// Updated: JAM 08/12/92 -- anach. form() replaced with iomanips

#include <iomanip.h>    // for hex
#include <cool/Bignum.h>
#include <cool/test.h>

int close_enough( double x, double y ) {
    double mx, mn;
    if( x < y ) {
        mn = x;
        mx = y;
    } else {
        mn = y;
        mx = x;
    }
    if( mn == mx ) return 1;
    if( mx == 0 ) return 0;
    if((( mn / mx ) - 1.0 ) < 1e-15 ) {
        return 1;
    }
    return 0;
}

void run_constructor_tests() {
  cout << "\nCoolBignum constructor tests:\n";

  cout << "long constructor:\n";
  {CoolBignum b2(0L);
  TEST ("CoolBignum b2(long(0));", (long)b2 == (long)0, TRUE);}

  {CoolBignum b3(1L);
  TEST ("CoolBignum b3(long(1));", (long)b3 == (long)1, TRUE);}

  {CoolBignum b4(-1L);
  TEST ("CoolBignum b4(long(-1));", (long)b4 == (long)-1, TRUE);}

  {CoolBignum b5((long)(MAXSHORT));
  TEST ("CoolBignum b5(long(MAXSHORT));", (long)b5 == (long)MAXSHORT, TRUE);}
  
  {CoolBignum b6((long)(-MAXSHORT));
  TEST ("CoolBignum b6(long(-MAXSHORT));", (long)b6 == (long)-MAXSHORT, TRUE);}

  {CoolBignum b7((long)(MAXINT));
  TEST ("CoolBignum b7(long(MAXINT));", (long)b7 == (long)MAXINT, TRUE);}

  {CoolBignum b8((long)(-MAXINT));
  TEST ("CoolBignum b8(long(-MAXINT));", (long)b8 == (long)-MAXINT, TRUE);}

  {CoolBignum b9((long)(MAXLONG));
  TEST ("CoolBignum b9(long(MAXLONG));", (long)b9 == (long)MAXLONG, TRUE);}

  {CoolBignum b10((long)(-MAXLONG));
  TEST ("CoolBignum b10(long(-MAXLONG));", (long)b10 == (long)-MAXLONG, TRUE);}

  {CoolBignum b10l((long)(0xF00000l));
  TEST ("CoolBignum b10l(long(0xF00000l));", (long)b10l == 0xF00000, TRUE);}

  cout << "double constructor:\n";
  {CoolBignum b11(0.0);
  TEST ("CoolBignum b11(0.0);", (double)b11 == 0.0, TRUE);}

  {CoolBignum b12(1.0);
  TEST ("CoolBignum b12(1.0);", (double)b12 == 1.0, TRUE);}

  {CoolBignum b13(-1.0);
  TEST ("CoolBignum b13(-1.0);", (double)b13 == -1.0, TRUE);}

  {CoolBignum b14(MAXDOUBLE);
  TEST ("CoolBignum b14(MAXDOUBLE);", (double)b14 == MAXDOUBLE, TRUE);}

  {CoolBignum b15(-MAXDOUBLE);
  TEST ("CoolBignum b15(-MAXDOUBLE);", (double)b15 == -MAXDOUBLE, TRUE);}

  {CoolBignum b16(1234567.0);
  TEST ("CoolBignum b16(1234567.0);", (double)b16 == 1234567.0, TRUE);}

  {CoolBignum b17(-1234567.0);
  TEST ("CoolBignum b17(-1234567.0);", (double)b17 == -1234567.0, TRUE);}

  {CoolBignum b18(1234567000.0);
  TEST ("CoolBignum b18(1234567000.0);", (double)b18 == 1234567000.0, TRUE);}

  {CoolBignum b19(-1234567000.0);
  TEST ("CoolBignum b19(-1234567000.0);", (double)b19 == -1234567000.0, TRUE);}

  {CoolBignum b20((double)(0xF00000)); TEST ("CoolBignum b20(double(0xF00000));",
                                      (double)b20 == (double)0xF00000, TRUE);}

  cout << "char* constructor:\n";
  {CoolBignum b21("-1");
  TEST ("CoolBignum b21(\"-1\");", (long)b21 == -1, TRUE);}

  {CoolBignum b22("+1");
  TEST ("CoolBignum b22(\"+1\");", (long)b22 == 1, TRUE);}

  {CoolBignum b23("1");
  TEST ("CoolBignum b23(\"1\");", (long)b23 == 1, TRUE);}

  {CoolBignum b24("123");
  TEST ("CoolBignum b24(\"123\");", (long)b24 == 123, TRUE);}

  {CoolBignum b25("123e12");
  TEST ("CoolBignum b25(\"123e12\");", (double)b25 == 123e12, TRUE);}

  {CoolBignum b26("123e120");
  TEST ("CoolBignum b26(\"123e120\");", close_enough( (double)b26, 123e120), TRUE);}

  {CoolBignum b27("0x0");
  TEST ("CoolBignum b27(\"0x0\");", (long)b27 == 0x0, TRUE);}

  {CoolBignum b28("0x9");
  TEST ("CoolBignum b28(\"0x9\");", (long)b28 == 0x9, TRUE);}

  {CoolBignum b29("0xa");
  TEST ("CoolBignum b29(\"0xa\");", (long)b29 == 0xa, TRUE);}

  {CoolBignum b30("0xf");
  TEST ("CoolBignum b30(\"0xf\");", (long)b30 == 0xf, TRUE);}

  {CoolBignum b31("0xA");
  TEST ("CoolBignum b31(\"0xA\");", (long)b31 == 0xA, TRUE);}

  {CoolBignum b32("0xF");
  TEST ("CoolBignum b32(\"0xF\");", (long)b32 == 0xF, TRUE);}

  {CoolBignum b33("0x1aF");
  TEST ("CoolBignum b33(\"0x1aF\");", (long)b33 == 0x1aF, TRUE);}

  {CoolBignum b34("0");
  TEST ("CoolBignum b34(\"0\");", (long)b34 == 0, TRUE);}

  {CoolBignum b35("00");
  TEST ("CoolBignum b35(\"00\");", (long)b35 == 0, TRUE);}

  {CoolBignum b36("012334567");
  TEST ("CoolBignum b36(\"012334567\");", (long)b36 == 012334567, TRUE);}

  {CoolBignum b37("9");
  TEST ("CoolBignum b37(\"9\");", (long)b37 == 9, TRUE);}

  {CoolBignum b38("011");
  TEST ("CoolBignum b38(\"011\");", (long)b38 == 9, TRUE);}

  // leading blanks not supported yet
  //{CoolBignum b39(" 9");
  //TEST ("CoolBignum b39(\" 9\");", (long)b39 == 9, TRUE);}

  {CoolBignum b40("0XF");
  TEST ("CoolBignum b40(\"0XF\");", (long)b40 == 0XF, TRUE);}

  cout << "CoolBignum& constructor:\n";
  {CoolBignum b50(CoolBignum(0l));
  TEST ("CoolBignum b50(CoolBignum(0l));", (long)b50 == 0l, TRUE);}

  {CoolBignum b51(CoolBignum(100l));
  TEST ("CoolBignum b51(CoolBignum(100l));", (long)b51 == 100l, TRUE);}
}

void run_conversion_operator_tests() {
  cout << "\nConversion operator tests:\n";

  cout << "short conversion operator:\n";
  TEST("short(CoolBignum(0l)) == 0", short(CoolBignum(0l)) == 0, TRUE);
  TEST("short(CoolBignum(long(MAXSHORT))) == MAXSHORT",
       short(CoolBignum(long(MAXSHORT))) == MAXSHORT, TRUE);
  TEST("short(CoolBignum(long(-MAXSHORT))) == -MAXSHORT",
       short(CoolBignum(long(-MAXSHORT))) == -MAXSHORT, TRUE);

  TEST("short(CoolBignum(long(-MAXSHORT+1))) == short(-MAXSHORT+1)",
       short(CoolBignum(long(-MAXSHORT+1))) == short(-MAXSHORT+1), TRUE);

    // conversion to short fails for MAXSHORT+1
  //TEST("short(CoolBignum(long(MAXSHORT+1))) == short(MAXSHORT+1)",
       //short(CoolBignum(long(MAXSHORT + 1))) == short(MAXSHORT + 1), TRUE);

  cout << "int conversion operator:\n";
  TEST("int(CoolBignum(0l)) == 0", int(CoolBignum(0l)) == 0, TRUE);
  TEST("int(CoolBignum(long(MAXINT))) == MAXINT",
      int(CoolBignum(long(MAXINT))) == MAXINT, TRUE);
  TEST("int(CoolBignum(long(-MAXINT))) == -MAXINT",
       int(CoolBignum(long(-MAXINT))) == -MAXINT, TRUE);

  {CoolBignum b((long)(MAXINT));
  ++b;
  // conversion of bignum MAXINT+1 cannot fit in an int
  //TEST("CoolBignum b(long(MAXINT); b++; (int)b == int(MAXINT+1)",
       //(int)b == int(MAXINT+1), TRUE);

  b = -b;
  ++b;
  TEST("CoolBignum b(long(MAXINT); b++; b=-b; ++b; (int)b == int(-MAXINT)",
       (int)b == int(-MAXINT), TRUE);

  cout << "long conversion operator:\n";
  TEST("long(CoolBignum(0l)) == 0", long(CoolBignum(0l)) == 0, TRUE);
  TEST("long(CoolBignum(MAXLONG)) == MAXLONG",
       long(CoolBignum(MAXLONG)) == MAXLONG, TRUE);
  TEST("long(CoolBignum(-MAXLONG)) == -MAXLONG",
       long(CoolBignum(-MAXLONG)) == -MAXLONG, TRUE);

  b = long(MAXLONG);
  --b;
  TEST("CoolBignum b; b =(long(MAXLONG); b--; (long)b == long(MAXLONG-1)",
       (long)b == long(MAXLONG-1), TRUE);

  b = -b;
  TEST("CoolBignum b = (long(MAXLONG); b--; b=-b; (long)b == long(-(MAXLONG-1))",
       (long)b == long(-(MAXLONG-1)), TRUE);

  cout << "float conversion operator:\n";
  float f;
  TEST("float(CoolBignum(0.0)) == 0.0", ((float) CoolBignum(0.0)) == 0.0, TRUE);
  TEST("float(CoolBignum(99999.0)) == 99999.0",
       ((float) CoolBignum(99999.0)) == 99999.0, TRUE);
  TEST("float(CoolBignum(MAXFLOAT)) == MAXFLOAT",
       ((f = MAXFLOAT) == (float) CoolBignum(MAXFLOAT)), TRUE);
  TEST("float(CoolBignum(-MAXFLOAT)) == -MAXFLOAT",
       ((f = -MAXFLOAT) == float(CoolBignum(-MAXFLOAT))), TRUE);
#if 0
  // these should produce failures because MAXDOUBLE cannot fit in a float
  b = MAXDOUBLE;
  --b;
  f = (float) b;
  TEST("CoolBignum b = MAXDOUBLE; b--; (float)b == float(MAXDOUBLE-1)",
       f == float(MAXDOUBLE-1), TRUE);

  f = (float) (-b);
  TEST("CoolBignum b = MAXDOUBLE; b--, b=-b; (float)b == float(-(MAXDOUBLE-1))",
       f = float(-(MAXDOUBLE-1)), TRUE);
#endif


  cout << "double conversion operator:\n";
  double d;
  TEST("double(CoolBignum(0.0)) == 0.0", ((double) CoolBignum(0.0)) == 0.0, TRUE);
  TEST("double(CoolBignum(99999.0)) == 99999.0",
       (double) CoolBignum(99999.0) == 99999.0, TRUE);
  TEST("double(CoolBignum(1e300)) == 1e300",
       double(CoolBignum(1e300)) == 1e300, TRUE);
  TEST("double(CoolBignum(-1e300)) == -1e300",
       double(CoolBignum(-1e300)) == -1e300, TRUE);
  TEST("double(CoolBignum(MAXFLOAT)) == MAXFLOAT",
       ((d = MAXFLOAT) == (double) CoolBignum(MAXFLOAT)), TRUE);
  TEST("double(CoolBignum(-MAXFLOAT)) == -MAXFLOAT",
       ((d = -MAXFLOAT) == double(CoolBignum(-MAXFLOAT))), TRUE);
  TEST("double(CoolBignum(MAXDOUBLE)) == MAXDOUBLE",
       (double) CoolBignum(MAXDOUBLE) == MAXDOUBLE, TRUE);
  TEST("double(CoolBignum(-MAXDOUBLE)) == -MAXDOUBLE",
       (double) CoolBignum(-MAXDOUBLE) == -MAXDOUBLE, TRUE);
  b = MAXDOUBLE;
  --b;
  ++b;
  b = b / CoolBignum(2L);
  d = (double) b;
  TEST("CoolBignum b = MAXDOUBLE; b--; ++b; b/=2; (double)b == double(MAXDOUBLE/2)",
       close_enough( d, double(MAXDOUBLE/2) ), TRUE);

  d = (double) (-b);
  TEST("CoolBignum b =MAXDOUBLE; b--, ++b; b/=2; b=-b; (double)b == double(-(MAXDOUBLE/2))",
       close_enough( d, double(-(MAXDOUBLE/2)) ), TRUE);
}}

void run_assignment_tests() {
  cout << "\nStarting assignment tests:\n";
  CoolBignum b1;

  TEST_RUN ("CoolBignum b1; b1 = 0xffff;", b1 = 0xffffl,
            long(b1) == 0xffffl, TRUE);

  // double assignment operator
  TEST_RUN ("double(b1) == -1.23e6", b1 = -1.23e6,
            double(b1) == -1.23e6, TRUE);

  // long assignment operator
  TEST_RUN ("long(b1) = -MAXINT", b1 = long(-MAXINT),
            long(b1) == -MAXINT, TRUE);

  // char * assignment operator
  TEST_RUN ("long(b1) = 0x1FFFFFl", b1 = "0x1FFFFF",
            long(b1) == 0x1fffffl, TRUE);


  // CoolBignum& assignment operator
  b1 = "0x1FFFFF";
  CoolBignum b5(0x1FFFFl);
  TEST_RUN ("b1 = b5", b1 = b5, b1 == b5, TRUE);
}

void run_logical_comparison_tests() {
  cout << "\nStarting logical comparison tests:\n";
  CoolBignum b0(0L);
  CoolBignum b1(1L);
  CoolBignum b2((long)(MAXSHORT));
  CoolBignum b3((long)(-MAXSHORT));

  TEST("b0 == b0", b0 == b0, TRUE);
  TEST("b0 == b1", b0 == b1, FALSE);
  TEST("b0 == b2", b0 == b2, FALSE);
  TEST("b0 == b3", b0 == b3, FALSE);
  TEST("b1 == b2", b1 == b2, FALSE);
  TEST("b1 == b3", b1 == b3, FALSE);
  TEST("b2 == b3", b2 == b3, FALSE);

  TEST("b0 != b0", b0 != b0, FALSE);
  TEST("b0 != b1", b0 != b1, TRUE);
  TEST("b0 != b2", b0 != b2, TRUE);
  TEST("b0 != b3", b0 != b3, TRUE);
  TEST("b1 != b2", b1 != b2, TRUE);
  TEST("b1 != b3", b1 != b3, TRUE);
  TEST("b2 != b3", b2 != b3, TRUE);

  TEST("b0 < b0", b0 < b0, FALSE);
  TEST("b0 < b1", b0 < b1, TRUE);
  TEST("b0 < b2", b0 < b2, TRUE);
  TEST("b0 < b3", b0 < b3, FALSE);
  TEST("b1 < b2", b1 < b2, TRUE);
  TEST("b1 < b3", b1 < b3, FALSE);
  TEST("b2 < b3", b2 < b3, FALSE);

  TEST("b0 > b0", b0 > b0, FALSE);
  TEST("b0 > b1", b0 > b1, FALSE);
  TEST("b0 > b2", b0 > b2, FALSE);
  TEST("b0 > b3", b0 > b3, TRUE);
  TEST("b1 > b2", b1 > b2, FALSE);
  TEST("b1 > b3", b1 > b3, TRUE);
  TEST("b2 > b3", b2 > b3, TRUE);

  TEST ("b3 != b2", b3 != b2, TRUE);
  TEST ("b3 != b3", b3 != b3, FALSE);
  TEST ("b3 < b2", b3 < b2, TRUE);
  TEST ("b3 <= b2", b3 <= b2, TRUE);