test1.cpp

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

#include <math.h>
#include <stdlib.h>
#include <iostream.h>

#pragma inline_depth 0;

#include "field.h"

# define Assert(ex)	{if (!(ex)){(void)printf("Failed test: file \"%s\", line %d\n", __FILE__, __LINE__);exit(1);}}

static int flag = 0;	// Used in test for virtuality of destructor

double ret_double( double *p )
{
    return *p;
}

double force_double( double x )
{
    return ret_double( &x );
}

main(){
    #if defined(__386__)
    __chipbug = (__typeof(__chipbug)) ~0;
    #endif
  register i;
  FILE *tmp = tmpfile();

// Default constructor
  {
    field a, b;
    Assert(a.Length() == 0);	// Default constructor creates length 0 field
    b = field(10, 0.0);		// length 0 field may be assigned to
    field c;
    Assert(fwrite(b, tmp));
    rewind(tmp);
    Assert(fread(c, tmp));	// length 0 field may be fread to
    Assert(c.Length() == 10);
    for (i=0; i<10; i++) 
      Assert(c[i] == 0.0);
  }

// Constructor with size argument (only)
  {
    field a(7);
    Assert(a.Length() == 7);	// Correct number of elements allocated
  }

// Constructor with size and initialization
  {
    field a(5, 10.0);
    Assert(a.Length() == 5);	// Correct length
    for (i=0; i<5; i++) 
      Assert(a[i] = 10.0);	// Correct data
  }

// Conversion from C array
  {
    static const double data[5] = { 5., 4., 3., 2., 1.};
    field a(5, data);
    Assert(a.Length() == 5);	// Correct length
    for (i=0; i<5; i++) 
      Assert(a[i] == data[i]);	// Correct data
  }

// Copy constructor
  {
    field a(22, 3.1416);
    field b(a);
    Assert(b.Length() == 22);	// Correct length
    for (i=0; i<22; i++) 
      Assert(b[i] == 3.1416);	// Correct data
  }

// Conversion from ifield
  {
    ifield q(10, 3);
    field d = q;
    Assert(d.Length() == 10);	// Correct length
    for (i=0; i<10; i++) 
      Assert(d[i] == 3.0);	// Correct data
  }

// Is destructor virtual?

  {
    class Derived_Field : public field {
      private:
        int *flag;
      public:
        Derived_Field(void) : flag(&::flag) { *flag = 1; }
        ~Derived_Field(void){ *flag = 0; }
    } *derived;
    derived = new Derived_Field;
    field *base = derived;
    delete base;
    Assert(flag == 0);		// Was the correct destructor called?
  }

// Test of assignment
  {
    field a(7, 2.);
    field b(3, 10.);
    a = b;
    Assert(a.Length() == 3);	// Correct length
    for (i=0; i<3; i++) 
      Assert(a[i] == 10.0);	// Correct data
  }

// Test of assignment of double
  {
    field a(7, 2.);
    a = 5.;
    Assert(a.Length() == 7);	// Correct length
    for (i=0; i<7; i++) 
      Assert(a[i] == 5.0);	// Correct data
  }

// Subscript and pointer conversion operators
  {
    field a(10, 0.0);
    field b;
    Assert(a[0] == 0.0);	
    Assert((a[0] = 2., a[0]) == 2.);	// Correct access
    Assert(&a[1+2] == &a[1]+2);		// Correct reference
    b = a;
    Assert(&a[0] != &b[0]);		// Uniqueness
    Assert(&a[0] == (double*)a);	// Correspondence
    Assert(&a[3] == (double*)a + 3);
    double &ref = a[0];
    b = a;
    Assert(&ref == &a[0]);
  }

// Operations
  {
    static const double data[] = {1., 2., 3., 4., 5.};
    field a;
    size_t l = sizeof(data)/sizeof(double);
    a = field(l, data); 
    Assert(a.Length() == 5);	// Correct length
    for (i=0; i<5; i++) 
      Assert(a[i] == data[i]);	// Correct data

// Unary operators
    {
      field b = +a;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == a[i]);
      b = -a;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == -a[i]);
    }

// Operators with scalar constants
    {
      field b = a*3.0;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == 3.0*a[i]);

      b = 3.0*a;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == 3.0*a[i]);

      b = a;
      b *= 3.0;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == 3.0*a[i]);


      b = a/3.0;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == a[i]/3.0);

      b = 3.0/a;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == 3.0/a[i]);

      b = a;
      b /= 3.0;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == a[i]/3.0);


      b = a+3.0;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == a[i]+3.0);

      b = 3.0+a;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == 3.0+a[i]);

      b = a;
      b += 3.0;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == a[i]+3.0);


      b = a-3.0;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == a[i]-3.0);

      b = 3.0-a;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == 3.0-a[i]);

      b = a;
      b -= 3.0;
      Assert(b.Length() == l);
      for (i=0; i<l; i++)
        Assert(b[i] == a[i]-3.0);
    }

// Operators with other double fields
    {
      field b = a;
      field c;


      c = a * b;
      Assert(c.Length() == l);
      for (i=0; i<l; i++)
        Assert(c[i] == a[i] * b[i]);

      c = a;
      c *= b;
      Assert(c.Length() == l);
      for (i=0; i<l; i++)
        Assert(c[i] == a[i] * b[i]);


      c = a / b;
      Assert(c.Length() == l);
      for (i=0; i<l; i++)
        Assert(c[i] == a[i] / b[i]);

      c = a;
      c /= b;
      Assert(c.Length() == l);
      for (i=0; i<l; i++)
        Assert(c[i] == a[i] / b[i]);


      c = a + b;
      Assert(c.Length() == l);
      for (i=0; i<l; i++)
        Assert(c[i] == a[i] + b[i]);

      c = a;
      c += b;
      Assert(c.Length() == l);
      for (i=0; i<l; i++)
        Assert(c[i] == a[i] + b[i]);


      c = a - b;
      Assert(c.Length() == l);
      for (i=0; i<l; i++)
        Assert(c[i] == a[i] - b[i]);

      c = a;
      c -= b;
      Assert(c.Length() == l);
      for (i=0; i<l; i++)
        Assert(c[i] == a[i] - b[i]);
    }

// Operators returning ifield
    {
      field b = a;
      field c = 2.0*a;
      ifield ib, ic;


      ib = (a == 2.0);
      Assert(ib.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (a[i] == 2.0));
      }

      ib = (2.0 == a);
      Assert(ib.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (2.0 == a[i]));
      }

      ib = (a == b);
      ic = (a == c);
      Assert(ib.Length() == l);
      Assert(ic.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (a[i] == b[i]));
        Assert(ic[i] == (a[i] == c[i]));
      }


      ib = (a != 2.0);
      Assert(ib.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (a[i] != 2.0));
      }

      ib = (2.0 != a);
      Assert(ib.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (2.0 != a[i]));
      }

      ib = (a != b);
      ic = (a != c);
      Assert(ib.Length() == l);
      Assert(ic.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (a[i] != b[i]));
        Assert(ic[i] == (a[i] != c[i]));
      }


      ib = (a < 2.0);
      Assert(ib.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (a[i] < 2.0));
      }

      ib = (2.0 < a);
      Assert(ib.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (2.0 < a[i]));
      }

      ib = (a < b);
      ic = (a < c);
      Assert(ib.Length() == l);
      Assert(ic.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (a[i] < b[i]));
        Assert(ic[i] == (a[i] < c[i]));
      }


      ib = (a > 2.0);
      Assert(ib.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (a[i] > 2.0));
      }

      ib = (2.0 > a);
      Assert(ib.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (2.0 > a[i]));
      }

      ib = (a > b);
      ic = (a > c);
      Assert(ib.Length() == l);
      Assert(ic.Length() == l);
      for (i=0; i<l; i++){
        Assert(ib[i] == (a[i] > b[i]));
        Assert(ic[i] == (a[i] > c[i]));
      }


      ib = (a <= 2.0);
      Assert(ib.Length() == l);