DblVecTest.C

Go to the documentation of this file.

#include <stdio.h>
#include "DoubleVec.h"


bool CheckConstructor()
{
  bool rslt = true;
  size_t i;

  DoubleVec empty;
  if (empty.length() != 0) {
    printf("CheckConstructor: 1. bad length.  Length = %d\n", empty.length());
    rslt = false;
  }
  
  if (empty.getRefCnt() != 1) {
    printf("CheckConstructor: 2. bad refCnt.  RefCnt = %d\n", 
           empty.getRefCnt() );
    rslt = false;
  }

  const size_t len = 10;
  DoubleVec vec( len, 0.0 );
  if (vec.length() != len) {
    printf("CheckConstructor: 3. bad length.  Length = %d, should be = %d\n",
           vec.length(), len );
    rslt = false;
  }

  bool isZero = true;
  for (i = 0; i < len; i++) {
    if (vec[i] != 0.0) {
      isZero = false;
      break;
    }
  }
  if (!isZero) {
    printf("CheckConstructor: 4. Array should be initialized to zero\n");
    rslt = false;
  }

  size_t answer = 42;
  DoubleVec TheAnswer( len, answer );
  bool initOK = true;

  for (i = 0; i < len; i++) {
    if (TheAnswer[i] != answer) {
      initOK = false;
      break;
    }
  }
  if (!initOK) {
    printf("CheckConstructor: 5. Array should be initialized to %d\n",
           answer );
    rslt = false;
  }

  const double avacadoNumber = 6.02e23;
  const size_t bigLen = 4000;
  DoubleVec MrBig( bigLen );
  MrBig[ bigLen - 1 ] = avacadoNumber;
  if ((double)MrBig[ bigLen-1 ] != avacadoNumber) {
    printf("CheckConstructor: 6. Assignment to end of a largish array failed");
    printf("(double)MrBig[bigLen-1] = %7.4e\n", (double)MrBig[ bigLen-1 ] );
    rslt = false;
  }
  
  return rslt;
} // CheckConstructor


bool equals( DoubleVec &vec, const double *test)
{
  const size_t len = vec.length();
  bool rslt = true;
  size_t i;

  for (i = 0; i < len; i++) {
    if (vec[i] != test[i]) {
      rslt = false;
      break;
    }
  }

  return rslt;
} // equals

bool AppendNewValues()
{
  bool rslt = true;

  DoubleVec vec;
  
  const size_t len = 16;
  double *testVec = new double[len];
  size_t i;
  for (i = 0; i < len; i++) {
    vec.append( i+1 );
    testVec[i] = i+1;
  }

  if (vec.length() != len) {
    printf("AppendNewValues: 1. length = %d, should be %d\n",
           vec.length(), len);
    rslt = false;
  }

  if (! equals( vec, testVec )) {
    printf("AppendNewValues: 2. short test failed\n");
    rslt = false;
  }
  delete [] testVec;

  const size_t bigger = 6000;
  testVec = new double[bigger];  
  DoubleVec bigVec;
  for (i = 0; i < len; i++) {
    bigVec.append( i+1 );
    testVec[i] = i+1;
  }
  if (! equals( vec, testVec )) {
    printf("AppendNewValues: 3. long test failed\n");
    rslt = false;
  }
  delete [] testVec;

  DoubleVec a( len );
  testVec = new double[len*2];  
  for (i = 0; i < len; i++) {
    a[i] = i;
    testVec[i] = i;
  }
  for (i = len; i < len*2; i++) {
    a.append( i );
    testVec[i] = i;
  }
  if (! equals( a, testVec )) {
    printf("AppendNewValues: 4. append to existing array failed\n");
    rslt = false;
  }
  delete [] testVec;
  
  return rslt;
} // AppendNewValues



bool Assignment()
{
  bool rslt = true;

  const size_t len = 20;
  DoubleVec vec(len);
  size_t i;

  for (i = 0; i < len; i++) {
    vec[i] = i * 2;
  }
  
  DoubleVec a = vec;
  if (a.getRefCnt() != 2) {
    printf("Assignment: 1. refCnt = %d, should be 2\n", a.getRefCnt() );
    rslt = false;
  }

  DoubleVec b(len/2);
  b = a;
  if (b.getRefCnt() != 3) {
    printf("Assignment: 2. refCnt = %d, should be 3\n", b.getRefCnt() );
    rslt = false;
  }

  if (b.length() != len) {
    printf("Assignment: 3. b.length() = %d, should be %d\n", 
           b.length(), len );
    rslt = false;
  }

  bool contentOK = true;
  for (i = 0; i < len; i++) {
    if (b[i] != i * 2) {
      contentOK = false;
      break;
    }
  }
  if (!contentOK) {
    printf("Assignment: 3. Array content is wrong\n");
    rslt = false;
  }

  // Assignment to "self" should not change the reference count
  size_t beforeRefCnt = b.getRefCnt();
  b = b;
  
  if (b.getRefCnt() != beforeRefCnt) {
    printf("Assignment: 4. refCnt = %d, should be %d\n",
           b.getRefCnt(), beforeRefCnt );
    rslt = false;
  }

  contentOK = true;
  for (i = 0; i < len; i++) {
    if (b[i] != i * 2) {
      contentOK = false;
      break;
    }
  }
  if (!contentOK) {
    printf("Assignment: 5. After self assignment, array content is wrong\n");
    rslt = false;
  }

  return rslt;
} // Assignment


DoubleVec globalVec1;

bool checkRef(DoubleVec &vec, size_t len)
{
  bool rslt = true;
  if (vec.getRefCnt() != 1) {
    printf("PassByReference: 1. refCnt = %d, should be 1\n", vec.getRefCnt() );
    rslt = false;
  }

  if (vec.length() != len) {
    printf("PassByReference: 2. length = %d, should be %d\n", 
           vec.length(), len );
    rslt = false;
  }

  DoubleVec a = vec;
  if (vec.getRefCnt() != 2) {
    printf("PassByReference: 3. refCnt = %d, should be 2\n", vec.getRefCnt() );
    rslt = false;
  }

  bool contentOK = true;
  size_t i;
  for (i = 0; i < len; i++) {
    if (a[i] != i) {
      printf("PassByReference: 4. Content is wrong" );
      rslt = false;
      break;
    }
  }

  globalVec1 = a;
  if (vec.getRefCnt() != 3) {
    printf("PassByReference: 5. refCnt = %d, should be 3\n", vec.getRefCnt() );
    rslt = false;
  }

  return rslt;
} // checkRef

bool PassByReference()
{
  bool rslt = true;
  
  size_t len = 17;
  DoubleVec a(len);
  size_t i;

  for (i = 0; i < len; i++) {
    a[i] = i;
  }
  if (! checkRef(a, len)) {
    rslt = false;
  }

  // remember, we assigned to a global variable in checkRef()
  if (a.getRefCnt() != 2) {
    printf("PassByReference: 6. refCnt = %d, should be 2\n", a.getRefCnt() );
    rslt = false;
  }

  // remember, we assigned to a global variable in checkRef()
  if (globalVec1.length() != len) {
    printf("PassByReference: 7. length = %d, should be %d\n", 
           globalVec1.getRefCnt(), len );
    rslt = false;
  }

  bool contentOK = true;
  for (i = 0; i < len; i++) {
    if (globalVec1[i] != i) {
      printf("PassByReference: 8. Content is wrong" );
      rslt = false;
      break;
    }
  }

  return rslt;
} // PassByReference


DoubleVec globalVec2;

bool checkPassByValue( DoubleVec a, size_t len )
{
  bool rslt = true;
  if (a.getRefCnt() != 2) {
    printf("PassByValue: 1. refCnt = %d, should be 2\n", a.getRefCnt());
    rslt = false;
  }

  if (a.length() != len) {
    printf("PassByValue: 2. length = %d, should be %d\n", 
           a.length(), len);
    rslt = false;
  }

  DoubleVec b = a;
  if (a.getRefCnt() != 3) {
    printf("PassByValue: 3. refCnt = %d, should be 3\n", a.getRefCnt());
    rslt = false;
  }

  bool contentOK = true;
  size_t i;
  for (i = 0; i < len; i++) {
    if (b[i] != i) {
      printf("PassByValue: 4. Content is wrong" );
      rslt = false;
      break;
    }
  }

  globalVec2 = a;
  if (b.getRefCnt() != 4) {
    printf("PassByValue: 5. refCnt = %d, should be 4\n", b.getRefCnt());
    rslt = false;
  }

  return rslt;
} // checkPassByValue


bool PassByValue()
{
  bool rslt = true;

  const size_t len = 21;
  DoubleVec a(len);
  size_t i;

  for (i = 0; i < len; i++) {
    a[i] = i;
  }

  if (!checkPassByValue( a, len )) {
    rslt = false;
  }

  // note: copy to globalVec2
  if (a.getRefCnt() != 2) {
    printf("PassByValue: 6. a.getRefCnt() = %d, should be 2\n", 
           a.getRefCnt());
    rslt = false;
  }

  if (globalVec2.getRefCnt() != 2) {
    printf("PassByValue: 7. globalVec2.getRefCnt() = %d, should be 2\n", 
           globalVec2.getRefCnt());
    rslt = false;
  }

  bool contentOK = true;
  for (i = 0; i < len; i++) {
    if (a[i] != i) {
      printf("PassByValue: 8. Content is wrong" );
      rslt = false;
      break;
    }
  }

  contentOK = true;
  for (i = 0; i < len; i++) {
    if (globalVec2[i] != i) {
      printf("PassByValue: 9. Content is wrong" );
      rslt = false;
      break;
    }
  }

  return rslt;
} // PassByValue


DoubleVec DoubleVecFactory(const size_t size)
{
  DoubleVec v(size);
  return v;
} // DoubleVecFactory


DoubleVec &passThrough( DoubleVec &v )
{
  return v;
}


DoubleVec makeCopy(DoubleVec &v )
{
  size_t size = v.length();
  DoubleVec newVec(size);

  for (size_t i = 0; i < size; i++) {
    newVec[i] = (double)v[i];
  }

  return newVec;
} // makeCopy


bool CheckFuncReturn()
{
  bool rslt = true;
  const size_t size = 20;
  DoubleVec v(size);

  size_t i;
  for (i = 0; i < size; i++) {
    v[i] = i + 1;
  }

  DoubleVec a = makeCopy( v );
  for (i = 0; i < size; i++) {
    if (a[i] != v[i]) {
      printf("CheckFuncReturn: 1. bad values\n");
      rslt = false;
      break;
    }
  }

  if (a.getRefCnt() != 1) {
    printf("CheckFuncReturn: 2. unexpected reference count\n");
    rslt = false;
  }

  if (v.getRefCnt() != 1) {
    printf("CheckFuncReturn: 3. unexpected reference count\n");
    rslt = false;
  }

  DoubleVec b = passThrough( v );

  if (b.getRefCnt() != 2) {
    printf("CheckFuncReturn: 4. unexpected reference count\n");
    rslt = false;
  }

  if (v.getRefCnt() != 2) {
    printf("CheckFuncReturn: 5. unexpected reference count\n");
    rslt = false;
  }

  const size_t s = 21;
  DoubleVec c = DoubleVecFactory( 21 );
  if (c.getRefCnt() != 1) {
    printf("CheckFuncReturn: 6. unexpected reference count\n");
    rslt = false;
  }

  if (c.length() != s) {
    printf("CheckFuncReturn: 7. size is not correct\n");
    rslt = false;
  }

  return rslt;
} // CheckFuncReturn


bool Index()
{
  bool rslt = true;
  const size_t len = 31;
  size_t i;
  DoubleVec a;

  for (i = 0; i < len; i++) {
    a.append( i );
  }

  DoubleVec b = a;
  if (b.getRefCnt() != 2) {
    printf("Index: 1. reference count is wrong\n");
    rslt = false;
  }

  a[len/2] = 0;

  if (b.getRefCnt() != 1) {
    printf("Index: 2. reference count is wrong\n");
    rslt = false;
  }

  // b should be unchanged
  bool contentOK = true;
  for (i = 0; i < len; i++) {
    if (b[i] != i) {
      printf("Index: 3. Content is wrong" );
      rslt = false;
      break;
    }
  }

  // a should be changed: a[len/2] == 0
  contentOK = true;
  for (i = 0; i < len; i++) {
    if (i == len/2) {
      if (a[i] != 0) {
        printf("Index: 4. a[%d] = %f, should be 0.0\n",
               i, (double)a[i] );
        rslt = false;
        break;
      }
    }
    else if (a[i] != i) {
      printf("Index: 5. Content is wrong" );
      rslt = false;
      break;
    }
  }

  DoubleVec c(20, 42.0);
  DoubleVec d = c;
  if (c.getRefCnt() != 2) {
    printf("Index: 6. reference count is wrong\n");
    rslt = false;
  }

  return rslt;
} // Index


main()
{
  bool passed = true;

  printf("Check constructors\n");
  if (! CheckConstructor()) {
    passed = false;
  }

  printf("Check append new values\n");
  if (! AppendNewValues()) {
    passed = false;
  }

  printf("Check assignment\n");
  if (! Assignment()) {
    passed = false;
  }

  printf("Check pass by reference\n");
  if (! PassByReference()) {
    passed = false;
  }

  printf("Check function return values\n");
  if (!CheckFuncReturn()) {
    passed = false;
  }

  printf("Check pass by value\n");
  if (! PassByValue()) {
    passed = false;
  }

  printf("Check index operation\n");
  if (! Index()) {
    passed = false;
  }

  if (passed)
    printf("test passed\n");
  else
    printf("test failed\n");
}

---