test_big.c

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

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

void run_division_tests() {
  cout << "\nStarting division tests:\n";

  TEST("long(CoolBignum(0l)/CoolBignum(1l))", long(CoolBignum(0l)/CoolBignum(1l)), 0);
  TEST("long(CoolBignum(-1l)/CoolBignum(1l))", long(CoolBignum(-1l)/CoolBignum(1l)), -1);

  CoolBignum b1,b2,b3;
  long i,j,k,l;
  long div_errors = 0;
  long mod_errors = 0;

  cout << " for (i = 0xFFFFFF; i > 0; i /= 0x10) \n";
  cout << "   for (j = 0x7FFFFFF; j > 0; j /= 0x10) \n";
  cout << "     for (k = 1; k < 17; k++) \n";
  cout << "       for (l = 1; l < 17; l++) \n         ";
  {for (i = 0xFFFFFF; i > 0; i /= 0x10) {
    cout.put('.');
    cout.flush();
    for (j = 0x7FFFFFF; j > 0; j /= 0x10) {
      for (k = 1; k < 17; k++) {
        for (l = 1; l < 17; l++) {
          b1 = CoolBignum(i+k);
          b2 = CoolBignum(j+l);
          b3 = CoolBignum(long((i+k)/(j+l)));
          if (b1/b2 != b3) {
            TEST("(CoolBignum(i+k)/CoolBignum(j+l)) == CoolBignum(long((i+k)/(j+l)))",
                 FALSE, TRUE);
            cout << "i=" << hex << i << ", j=" << hex << j << ", k=" << hex << k << ", l=" << hex << l << "\n" << dec;
            div_errors++;
          }
          b3 = CoolBignum(long((i+k)%(j+l)));
          if (b1%b2 != b3) {
            TEST("(CoolBignum(i+k)%CoolBignum(j+l)) == CoolBignum(long((i+k)%(j+l)))",
                 FALSE, TRUE);
            cout << "i=" << hex << i << ", j=" << hex << j << ", k=" << hex << k << ", l=" << hex << l << "\n" << dec;
            mod_errors++;
          }
        }
      }
    }
  }}

  cout << "\n";
  TEST("(CoolBignum(i+k)/CoolBignum(j+l)) == CoolBignum(long((i+k)/(j+l)))",
       div_errors == 0, TRUE);
  TEST("(CoolBignum(i+k)%CoolBignum(j+l)) == CoolBignum(long((i+k)%(j+l)))",
       mod_errors == 0, TRUE);

/*
  char num[130], den[130];
  CoolBignum b,r;
  
  while (1) {
    cout << "Enter next numerator:  ";
    cin >> num;
    cout << "Enter next denominator:  ";
    cin >> den;

    b = CoolBignum(num)/CoolBignum(den);
    r = CoolBignum(num) % CoolBignum(den);
    cout << "\nquotient  = " << b << "\n";
    cout <<   "            "; b.dump(); cout << "\n";
    cout << "\nremainder = " << r << "\n";
    cout <<   "            "; r.dump(); cout << "\n";

  }
*/
}

void run_multiplication_division_tests() {      
  cout << "\nCheck example in book:\n";

  CoolBignum b2 = "0xFFFFFFFF";                 // Create CoolBignum object
  CoolBignum b3 = "12345e30";                   // Create CoolBignum object

  TEST ("(b2*b3) / b3 = b2", ((b2*b3) / b3 == b2), 1);
  TEST ("(b2*b3) / b2 = b3", ((b2*b3) / b2 == b3), 1);
  TEST ("((b3/b2) * b2) + (b3%b2) = b3", (((b3/b2) * b2) + (b3%b2) == b3), 1);
}

void run_addition_subtraction_tests() {
  cout << "\nStarting addition, subtraction tests:\n";

  long i,j;
  long add_errors = 0;
  long sub_errors = 0;
  CoolBignum bi,bj,bij;

  cout << " for (i = 1; i < 0xFFFFFFF;  i *= 3) \n";
  cout << "   for (j = 1; j < 0xFFFFFFF; j *= 3) \n      ";

  {for (i = 1; i < 0xFFFFFFF;  i *= 3) {
    cout.put('.');
    cout.flush();
    for (j = 1; j < 0xFFFFFFF; j *= 3) {
      bi = i;
      bj = j;
      bij = CoolBignum(i+j);
      if (bi + bj != bij) {
        TEST("bi + bj == CoolBignum(i + j)", FALSE, TRUE);
   cout << "i = " << hex << i << ", j = " << hex << j << "\n" << dec;
        add_errors++;
      }
      bij = CoolBignum(i-j);
      if (bi - bj != bij) {
        TEST("bi - bj == CoolBignum(i - j)", FALSE, TRUE);
   cout << "i = " << hex << i << ", j = " << hex << j << "\n" << dec;
        sub_errors++;
      }
    }
  }}
  cout << "\n";
  TEST("bi + bj == CoolBignum(i + j)", add_errors==0, TRUE);
  TEST("bi - bj == CoolBignum(i - j)", sub_errors==0, TRUE);

  CoolBignum b0(0l);
  CoolBignum zillion("1000000000000000000");
  CoolBignum b1000(1000l), b1000000(1000000l);

  TEST("-b0 == b0", (-b0 == b0), TRUE);
  TEST("-b1000 == CoolBignum(-1l)*b1000", (-b1000 == CoolBignum(-1l)*b1000), TRUE);
  TEST("-(-b1000000) == b1000000", (-(-b1000000) == b1000000), TRUE);
  TEST("b0 + b1000 == b1000", (b0 + b1000 == b1000), TRUE);
  TEST("b0 + b1000000 == b1000000", (b0 + b1000000 == b1000000), TRUE);
  TEST("b1000 + b0 == b1000", (b1000 + b0 == b1000), TRUE);
  TEST("b1000000 + b0 == b1000000", (b1000000 + b0 == b1000000), TRUE);
  TEST("b0 + (-b1000) == -b1000", (b0 + (-b1000) == -b1000), TRUE);
  TEST("-b1000 + b0 == -b1000", (-b1000 + b0 == -b1000), TRUE);
  TEST("-b1000 + (-b1000) == (CoolBignum(2l)*(-b1000))",
       (-b1000 + (-b1000) == (CoolBignum(2l)*(-b1000))), TRUE);
  TEST("-b1000000 + (-b1000000) == (CoolBignum(2l)*(-b1000000))",
       (-b1000000 + (-b1000000) == (CoolBignum(2l)*(-b1000000))), TRUE);
  TEST("b1000000 + (-b1000000) == b0", (b1000000 + (-b1000000) == b0), TRUE);
  TEST("zillion + (-zillion) == b0", (zillion + (-zillion) == b0), TRUE);
  TEST("zillion + b1000 == b1000000*b1000000*b1000000 + b1000",
       (zillion + b1000 == b1000000*b1000000*b1000000 + b1000), TRUE);

  TEST("-b0 == b0", (-b0 == b0), TRUE);
  TEST("-b1000 == CoolBignum(-1l)*b1000", (-b1000 == CoolBignum(-1l)*b1000), TRUE);
  TEST("-(-b1000000) == b1000000", (-(-b1000000) == b1000000), TRUE);

  TEST("b0 - b1000 == -b1000", (b0 - b1000 == -b1000), TRUE);
  TEST("b0 - b1000000 == -b1000000", (b0 -b1000000 == -b1000000), TRUE);
  TEST("b1000 - b0 == b1000", (b1000 - b0 == b1000), TRUE);
  TEST("b1000000 - b0 == b1000000", (b1000000 - b0 == b1000000), TRUE);
  TEST("b0 - (-b1000) == b1000", (b0 - (-b1000) == b1000), TRUE);
  TEST("-b1000 - b0 == -b1000", (-b1000 - b0 == -b1000), TRUE);
  TEST("-b1000 - (-b1000) == b0", (-b1000 - (-b1000) == b0), TRUE);
  TEST("-b1000 - (-zillion) == zillion - b1000",
       (-b1000 - (-zillion) == zillion - b1000), TRUE);
  TEST("-b1000000 - (-b1000000) == b0", (-b1000000 - (-b1000000) == b0), TRUE);
  TEST("-b1000000 - (b1000000) == -CoolBignum(2l)*b1000000",
       (-b1000000 - (b1000000) == -CoolBignum(2l)*b1000000), TRUE);
  TEST("b1000000 - (-b1000000) == CoolBignum(2l)*b1000000",
       (b1000000 - (-b1000000) == CoolBignum(2l)*b1000000), TRUE);
  TEST("zillion - (-zillion) == CoolBignum(2l)*zillion",
       (zillion - (-zillion) == CoolBignum(2l)*zillion), TRUE);
  TEST("zillion - b1000 == b1000000*b1000000*b1000000 - b1000",
       (zillion - b1000 == b1000000*b1000000*b1000000 - b1000), TRUE);
  TEST("-zillion - b1000 == -b1000000*b1000000*b1000000 - b1000",
       (-zillion - b1000 == -b1000000*b1000000*b1000000 - b1000), TRUE);

  // example in book
  CoolBignum b2 = "0xFFFFFFFF";                 // Create CoolBignum object
  CoolBignum b3 = "12345e30";                   // Create CoolBignum object
  TEST ("(b2+b3) - b2 = b3", (b2+b3) - b2 == b3, 1);
  TEST ("(b2+b3) - b3 = b2", (b2+b3) - b3 == b2, 1);
}

void run_multiplication_tests() {
  cout << "\nStarting multiplication tests:\n";

  CoolBignum b0(0l), b1000(1000l), b1000000(1000000l),
  zillion("1000000000000000000");

  
  TEST("b0*b0 == b0", (b0*b0 == b0), TRUE);
  TEST("b0*b1000 == b0", (b0*b1000 == b0), TRUE);
  TEST("b1000*b0 == b0", (b1000*b0 == b0), TRUE);
  TEST("b1000*b1000 == b1000000", (b1000*b1000 == b1000000), TRUE);
  TEST("b1000*b1000000 == b1000000*b1000",
       (b1000*b1000000 == b1000000*b1000), TRUE);
  TEST("-b1000000*b1000000*b1000000 == -zillion",
       (-b1000000*b1000000*b1000000 == -zillion), TRUE);
  TEST("zillion*-b1000 == b1000*-zillion",
       (zillion*-b1000 == b1000*-zillion), TRUE);
}

void run_left_shift_tests() {

  CoolBignum b1(1l);

  // left shift
  TEST("int(b1) == 1",int(b1) == 1,TRUE);
  TEST("long(b1 << 1) == 2",long(operator<<(b1,1)) == 2,TRUE);
  TEST("long(b1 << 2) == 4",long(operator<<(b1,2)) == 4,TRUE);
  TEST("long(b1 << 3) == 8",long(operator<<(b1,3)) == 8,TRUE);
  TEST("long(b1 << 4) == 16",long(operator<<(b1,4)) == 16,TRUE);
  TEST("long(b1 << 5) == 32",long(operator<<(b1,5)) == 32,TRUE);
  TEST("long(b1 << 6) == 64",long(operator<<(b1,6)) == 64,TRUE);
  TEST("long(b1 << 7) == 128",long(operator<<(b1,7)) == 128,TRUE);
  TEST("long(b1 << 8) == 256",long(operator<<(b1,8)) == 256,TRUE);
  TEST("long(b1 << 9) == 512",long(operator<<(b1,9)) == 512,TRUE);
  TEST("long(b1 << 10) == 1024",long(operator<<(b1,10)) == 1024,TRUE);
  TEST("long(b1 << 11) == 2048",long(operator<<(b1,11)) == 2048,TRUE);
  TEST("long(b1 << 12) == 4096",long(operator<<(b1,12)) == 4096,TRUE);
  TEST("long(b1 << 13) == 8192",long(operator<<(b1,13)) == 8192,TRUE);
  TEST("long(b1 << 14) == 16384",long(operator<<(b1,14)) == 16384,TRUE);
  TEST("long(b1 << 15) == 32768",long(operator<<(b1,15)) == 32768,TRUE);
  TEST("long(b1 << 16) == 65536",long(operator<<(b1,16)) == 65536,TRUE);
  TEST("(b1 << 32) == CoolBignum(\"4294967296\")",
       (operator<<(b1,32)) == CoolBignum("4294967296"),TRUE);
  TEST("long(-b1 << 1) == -2",long(-operator<<(b1,1)) == -2,TRUE);
  TEST("long(-b1 << 2) == -4",long(-operator<<(b1,2)) == -4,TRUE);
  TEST("long(-b1 << 3) == -8",long(-operator<<(b1,3)) == -8,TRUE);
  TEST("long(-b1 << 4) == -16",long(-operator<<(b1,4)) == -16,TRUE);
  TEST("long(-b1 << 5) == -32",long(-operator<<(b1,5)) == -32,TRUE);
  TEST("long(-b1 << 6) == -64",long(-operator<<(b1,6)) == -64,TRUE);
  TEST("long(-b1 << 7) == -128",long(-operator<<(b1,7)) == -128,TRUE);
  TEST("long(-b1 << 8) == -256",long(-operator<<(b1,8)) == -256,TRUE);
  TEST("long(-b1 << 9) == -512",long(-operator<<(b1,9)) == -512,TRUE);
  TEST("long(-b1 << 10) == -1024",long(-operator<<(b1,10)) == -1024,TRUE);
  TEST("long(-b1 << 11) == -2048",long(-operator<<(b1,11)) == -2048,TRUE);
  TEST("long(-b1 << 12) == -4096",long(-operator<<(b1,12)) == -4096,TRUE);
  TEST("long(-b1 << 13) == -8192",long(-operator<<(b1,13)) == -8192,TRUE);
  TEST("long(-b1 << 14) == -16384",long(-operator<<(b1,14)) == -16384,TRUE);
  TEST("long(-b1 << 15) == -32768",long(-operator<<(b1,15)) == -32768,TRUE);
  TEST("long(-b1 << 16) == -65536",long(-operator<<(b1,16)) == -65536,TRUE);
  TEST("(-b1 << 32) == CoolBignum(\"-4294967296\")",
       (-operator<<(b1,32)) == CoolBignum("-4294967296"),TRUE);
  TEST("long(b1 << -16) == 0",long(operator<<(b1,-16)) == 0,TRUE);
  TEST("long(-b1 << -16) == 0",long(-operator<<(b1,-16)) == 0,TRUE);
}

void run_right_shift_tests() {
  // right shift
  CoolBignum b2("4294967296");
  TEST("b2 == CoolBignum(\"4294967296\")",b2 == CoolBignum("4294967296"), TRUE);
  TEST("(b2 >> 1) == CoolBignum(\"2147483648\")",
       (operator>>(b2,1)) == CoolBignum("2147483648"),TRUE);
  TEST("long(b2 >> 2) == 1073741824",long(operator>>(b2,2)) == 1073741824l,TRUE);
  TEST("long(b2 >> 3) == 536870912",long(operator>>(b2,3)) == 536870912l,TRUE);
  TEST("long(b2 >> 4) == 268435456",long(operator>>(b2,4)) == 268435456l,TRUE);
  TEST("long(b2 >> 5) == 134217728",long(operator>>(b2,5)) == 134217728l,TRUE);
  TEST("long(b2 >> 6) == 67108864",long(operator>>(b2,6)) == 67108864l,TRUE);
  TEST("long(b2 >> 7) == 33554432",long(operator>>(b2,7)) == 33554432l,TRUE);
  TEST("long(b2 >> 8) == 16777216",long(operator>>(b2,8)) == 16777216l,TRUE);
  TEST("long(b2 >> 9) == 8388608",long(operator>>(b2,9)) == 8388608l,TRUE);
  TEST("long(b2 >> 10) == 4194304",long(operator>>(b2,10)) == 4194304l,TRUE);
  TEST("long(b2 >> 11) == 2097152",long(operator>>(b2,11)) == 2097152l,TRUE);
  TEST("long(b2 >> 12) == 1048576",long(operator>>(b2,12)) == 1048576l,TRUE);
  TEST("long(b2 >> 13) == 524288",long(operator>>(b2,13)) == 524288l,TRUE);
  TEST("long(b2 >> 14) == 262144",long(operator>>(b2,14)) == 262144l,TRUE);
  TEST("long(b2 >> 15) == 131072",long(operator>>(b2,15)) == 131072l,TRUE);
  TEST("long(b2 >> 16) == 65536",long(operator>>(b2,16)) == 65536l,TRUE);
  TEST("long(b2 >> 32) == 1",long(operator>>(b2,32)) == 1l,TRUE);
  TEST("long(b2 >> 33) == 0",long(operator>>(b2,33)) == 0l,TRUE);
  TEST("long(b2 >> 67) == 0",long(operator>>(b2,67)) == 0l,TRUE);
  TEST("(-b2 >> 1) == CoolBignum(\"-2147483648\")",
       (operator>>(-b2,1)) == CoolBignum("-2147483648"),TRUE);
  TEST("long(-b2 >> 2) == -1073741824",long(operator>>(-b2,2)) == -1073741824l,TRUE);
  TEST("long(-b2 >> 3) == -536870912",long(operator>>(-b2,3)) == -536870912l,TRUE);
  TEST("long(-b2 >> 4) == -268435456",long(operator>>(-b2,4)) == -268435456l,TRUE);
  TEST("long(-b2 >> 5) == -134217728",long(operator>>(-b2,5)) == -134217728l,TRUE);
  TEST("long(-b2 >> 6) == -67108864",long(operator>>(-b2,6)) == -67108864l,TRUE);
  TEST("long(-b2 >> 7) == -33554432",long(operator>>(-b2,7)) == -33554432l,TRUE);
  TEST("long(-b2 >> 8) == -16777216",long(operator>>(-b2,8)) == -16777216l,TRUE);
  TEST("long(-b2 >> 9) == -8388608",long(operator>>(-b2,9)) == -8388608l,TRUE);
  TEST("long(-b2 >> 10) == -4194304",long(operator>>(-b2,10)) == -4194304l,TRUE);
  TEST("long(-b2 >> 11) == -2097152",long(operator>>(-b2,11)) == -2097152l,TRUE);
  TEST("long(-b2 >> 12) == -1048576",long(operator>>(-b2,12)) == -1048576l,TRUE);
  TEST("long(-b2 >> 13) == -524288",long(operator>>(-b2,13)) == -524288l,TRUE);
  TEST("long(-b2 >> 14) == -262144",long(operator>>(-b2,14)) == -262144l,TRUE);
  TEST("long(-b2 >> 15) == -131072",long(operator>>(-b2,15)) == -131072l,TRUE);
  TEST("long(-b2 >> 16) == -65536",long(operator>>(-b2,16)) == -65536l,TRUE);
  TEST("long(-b2 >> 32) == -1",long(operator>>(-b2,32)) == -1,TRUE);
  TEST("long(-b2 >> 33) == -0",long(operator>>(-b2,33)) == 0,TRUE);
  TEST("long(-b2 >> 67) == -0",long(operator>>(-b2,67)) == 0,TRUE);
}
void run_shift_tests() {
  cout << "\nStarting shift tests:\n";

  run_left_shift_tests();
  run_right_shift_tests();
/*
  CoolBignum b;
  char s[100];
  int sh;

  while (1) {
    cout << "Enter next CoolBignum:  ";
    cin >> s;
    b = s;
    cout << "Enter shift amount: ";
    cin >> sh;
    cout << "Shift == " << sh << "\n";

    b = b << sh;
  }
*/    
}

void test_leak() {
  for (;;) {
    run_constructor_tests();
    run_conversion_operator_tests();
    run_assignment_tests();
    run_addition_subtraction_tests();
    run_multiplication_tests();
    run_division_tests();
    run_multiplication_division_tests();
    run_shift_tests();
    run_logical_comparison_tests();
  }
}

int main (void) {
  START("CoolBignum");
  run_constructor_tests();
  run_conversion_operator_tests();
  run_assignment_tests();
  run_addition_subtraction_tests();
  run_multiplication_tests();
  run_division_tests();
  run_multiplication_division_tests();
  run_shift_tests();
  run_logical_comparison_tests();
#if LEAK
  test_leak();
#endif
  SUMMARY();
  return 0;
}