/*=========================================================================

  Program:   Visualization Toolkit
  Module:    otherArrays.cxx

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/

#include "vtkDebugLeaks.h"
#include "vtkCharArray.h"
#include "vtkUnsignedCharArray.h"
#include "vtkIntArray.h"
#include "vtkUnsignedIntArray.h"
#include "vtkLongArray.h"
#include "vtkUnsignedLongArray.h"
#include "vtkShortArray.h"
#include "vtkUnsignedShortArray.h"
#include "vtkFloatArray.h"
#include "vtkDoubleArray.h"
#include "vtkIdTypeArray.h"

#include <sstream>

#define SIZE 1000

template <class T, class A, class V>
int doArrayTest (ostream& strm, T *ptr, A *array, V value, int size)
{
  float tuple1[SIZE/100];
  double tuple3[SIZE/100];
  double *tuple2;
  int i;
  int errors = 0;

  strm << "\tResize(0)...";
  ptr->Resize(0);
  strm << "OK" << endl;

  strm << "\tResize(10)...";
  ptr->Resize(10);
  strm << "OK" << endl;

  strm << "\tResize(5)...";
  ptr->Resize(5);
  strm << "OK" << endl;

  strm << "\tResize(size)...";
  ptr->Resize(size);
  strm << "OK" << endl;

  strm << "\tSetNumberOfTuples...";
  ptr->SetNumberOfTuples (100);
  if (ptr->GetNumberOfTuples() == 100) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }
  strm << "\tSetNumberOfComponents...";
  ptr->SetNumberOfComponents (10);
  if (ptr->GetNumberOfComponents() == 10) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tSetVoidArray...";
  ptr->SetVoidArray(array, size, 1);
  strm << "OK" << endl;

  strm << "CreateDefaultLookupTable" << endl;
  ptr->CreateDefaultLookupTable();
  strm << *ptr;

  strm << "\tGetTuple(i)...";
  tuple2 = ptr->GetTuple (2);
  int passed = 1;
  if (tuple2)
    {
    for (i = 0; i < 10; i++)
      {
      strm << *(tuple2 + i) << " ";
      if (*(tuple2 + i) != (20 + i))
        {
        passed = 0;
        break;
        }
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tGetTuple(i, double *tuple)...";
  ptr->GetTuple (4, tuple3);
  passed = 1;
  for (i = 0; i < 10; i++)
    {
    tuple1[i] = static_cast<float>(tuple3[i]);
    strm << tuple3[i] << " ";
    if (tuple3[i] != (40 + i))
      {
      passed = 0;
      break;
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tvtkDataArray::GetTuple(i, double *tuple)...";
  static_cast<vtkDataArray*>(ptr)->GetTuple (4, tuple3);
  passed = 1;
  for (i = 0; i < 10; i++)
    {
    strm << tuple3[i] << " ";
    if (tuple3[i] != (40 + i))
      {
      passed = 0;
      break;
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tSetValue(i, value)...";
  ptr->SetValue (99, value);
  if (ptr->GetValue (99) == value) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertValue(i, value)...";
  ptr->InsertValue (500, value);
  if (ptr->GetValue (500) == value) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertNextValue(value)...";
  if (ptr->GetValue (ptr->InsertNextValue (static_cast<char>(22.0))) == 22.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertComponent(i, j, 5.0)...";
  ptr->InsertComponent (500, 9, 5.0);
  if (ptr->GetComponent (500, 9) == 5.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tSetTuple(i, float *tuple)...";
  ptr->SetTuple (99, tuple1);
  for (i=0; i < 10; i++) tuple3[i] = 0;
  ptr->GetTuple (99, tuple3);
  passed = 1;
  for (i = 0; i < 10; i++)
    {
    strm << tuple3[i] << " ";
    if (tuple3[i] != (40 + i))
      {
      passed = 0;
      break;
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tSetTuple(i, double *tuple)...";
  ptr->SetTuple (99, tuple3);
  for (i=0; i < 10; i++) tuple3[i] = 0;
  ptr->GetTuple (99, tuple3);
  passed = 1;
  for (i = 0; i < 10; i++)
    {
    strm << tuple3[i] << " ";
    if (tuple3[i] != (40 + i))
      {
      passed = 0;
      break;
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertTuple(i, float *tuple)...";
  ptr->InsertTuple (100, tuple1);
  for (i=0; i < 10; i++) tuple3[i] = 0;
  ptr->GetTuple (100, tuple3);
  passed = 1;
  for (i = 0; i < 10; i++)
    {
    strm << tuple3[i] << " ";
    if (tuple3[i] != (40 + i))
      {
      passed = 0;
      break;
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertTuple(i, double *tuple)...";
  ptr->InsertTuple (100, tuple3);
  for (i=0; i < 10; i++) tuple3[i] = 0;
  ptr->GetTuple (100, tuple3);
  passed = 1;
  for (i = 0; i < 10; i++)
    {
    strm << tuple3[i] << " ";
    if (tuple3[i] != (40 + i))
      {
      passed = 0;
      break;
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertNextTuple(float *tuple)...";
  for (i=0; i < 10; i++) tuple1[i] = 30 + i;
  ptr->GetTuple (ptr->InsertNextTuple (tuple1), tuple3);
  passed = 1;
  for (i = 0; i < 10; i++)
    {
    strm << tuple3[i] << " ";
    if (tuple3[i] != (30 + i))
      {
      strm << "Expected " << 30 + 1 << " ";
      passed = 0;
      break;
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertNextTuple(double *tuple)...";
  for (i=0; i < 10; i++) tuple3[i] = 40 + i;
  ptr->GetTuple (ptr->InsertNextTuple (tuple3), tuple3);
  passed = 1;
  for (i = 0; i < 10; i++)
    {
    strm << tuple3[i] << " ";
    if (tuple3[i] != (40 + i))
      {
      strm << "Expected " << 40 + 1;
      passed = 0;
      break;
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tvtkDataArray::GetData...";
  vtkDoubleArray *farray = vtkDoubleArray::New();
  farray->SetNumberOfComponents(1);
  ptr->vtkDataArray::GetData (0, 59, 1, 1,  farray);
  passed = 1;
  for (i = 0; i < 10; i++)
    {
    strm << farray->GetTuple(i)[0] << " ";
    if (farray->GetTuple(i)[0] != (1 + i*10))
      {
      passed = 0;
      break;
      }
    }
  if (passed) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }


  strm << "\tSetTuple1...";
  ptr->SetNumberOfComponents(1);
  ptr->SetNumberOfTuples(100);
  ptr->SetTuple1(50,10.0);
  if (ptr->GetTuple1(50) == 10.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tSetTuple2...";
  ptr->SetNumberOfComponents(2);
  ptr->SetNumberOfTuples(100);
  ptr->SetTuple2(50,10.0,20.0);
  if (ptr->GetTuple2(50)[0] == 10.0 &&
      ptr->GetTuple2(50)[1] == 20.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tSetTuple3...";
  ptr->SetNumberOfComponents(3);
  ptr->SetNumberOfTuples(100);
  ptr->SetTuple3(50,10.0,20.0,30.0);
  if (ptr->GetTuple3(50)[0] == 10.0 &&
      ptr->GetTuple3(50)[1] == 20.0 &&
      ptr->GetTuple3(50)[2] == 30.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tSetTuple4...";
  ptr->SetNumberOfComponents(4);
  ptr->SetNumberOfTuples(100);
  ptr->SetTuple4(50,10.0,20.0,30.0,40.0);
  if (ptr->GetTuple4(50)[0] == 10.0 &&
      ptr->GetTuple4(50)[1] == 20.0 &&
      ptr->GetTuple4(50)[2] == 30.0 &&
      ptr->GetTuple4(50)[3] == 40.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tSetTuple9...";
  ptr->SetNumberOfComponents(9);
  ptr->SetNumberOfTuples(100);
  ptr->SetTuple9(50,10.0,20.0,30.0,40.0,50.0,60.0,70.0,80.0,90.0);
  if (ptr->GetTuple9(50)[0] == 10.0 &&
      ptr->GetTuple9(50)[1] == 20.0 &&
      ptr->GetTuple9(50)[2] == 30.0 &&
      ptr->GetTuple9(50)[3] == 40.0 &&
      ptr->GetTuple9(50)[4] == 50.0 &&
      ptr->GetTuple9(50)[5] == 60.0 &&
      ptr->GetTuple9(50)[6] == 70.0 &&
      ptr->GetTuple9(50)[7] == 80.0 &&
      ptr->GetTuple9(50)[8] == 90.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertTuple1...";
  ptr->SetNumberOfComponents(1);
  ptr->SetNumberOfTuples(100);
  ptr->InsertTuple1(502,10.0);
  if (ptr->GetTuple1(502) == 10.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertTuple2...";
  ptr->SetNumberOfComponents(2);
  ptr->SetNumberOfTuples(100);
  ptr->InsertTuple2(502,10.0,20.0);
  if (ptr->GetTuple2(502)[0] == 10.0 &&
      ptr->GetTuple2(502)[1] == 20.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertTuple3...";
  ptr->SetNumberOfComponents(3);
  ptr->SetNumberOfTuples(100);
  ptr->InsertTuple3(502,10.0,20.0,30.0);
  if (ptr->GetTuple3(502)[0] == 10.0 &&
      ptr->GetTuple3(502)[1] == 20.0 &&
      ptr->GetTuple3(502)[2] == 30.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertTuple4...";
  ptr->SetNumberOfComponents(4);
  ptr->SetNumberOfTuples(100);
  ptr->InsertTuple4(502,10.0,20.0,30.0,40.0);
  if (ptr->GetTuple4(502)[0] == 10.0 &&
      ptr->GetTuple4(502)[1] == 20.0 &&
      ptr->GetTuple4(502)[2] == 30.0 &&
      ptr->GetTuple4(502)[3] == 40.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertTuple9...";
  ptr->SetNumberOfComponents(9);
  ptr->SetNumberOfTuples(100);
  ptr->InsertTuple9(502,10.0,20.0,30.0,40.0,50.0,60.0,70.0,80.0,90.0);
  if (ptr->GetTuple9(502)[0] == 10.0 &&
      ptr->GetTuple9(502)[1] == 20.0 &&
      ptr->GetTuple9(502)[2] == 30.0 &&
      ptr->GetTuple9(502)[3] == 40.0 &&
      ptr->GetTuple9(502)[4] == 50.0 &&
      ptr->GetTuple9(502)[5] == 60.0 &&
      ptr->GetTuple9(502)[6] == 70.0 &&
      ptr->GetTuple9(502)[7] == 80.0 &&
      ptr->GetTuple9(502)[8] == 90.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertNextTuple1...";
  ptr->SetNumberOfComponents(1);
  ptr->SetNumberOfTuples(100);
  ptr->InsertNextTuple1(10.0);
  if (ptr->GetTuple1(100) == 10.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << " FAILED" << endl;
    }
  strm << "\tInsertNextTuple2...";
  ptr->SetNumberOfComponents(2);
  ptr->SetNumberOfTuples(100);
  ptr->InsertNextTuple2(10.0,20.0);
  if (ptr->GetTuple2(100)[0] == 10.0 &&
      ptr->GetTuple2(100)[1] == 20.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertNextTuple3...";
  ptr->SetNumberOfComponents(3);
  ptr->SetNumberOfTuples(100);
  ptr->InsertNextTuple3(10.0,20.0,30.0);
  if (ptr->GetTuple3(100)[0] == 10.0 &&
      ptr->GetTuple3(100)[1] == 20.0 &&
      ptr->GetTuple3(100)[2] == 30.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertNextTuple4...";
  ptr->SetNumberOfComponents(4);
  ptr->SetNumberOfTuples(100);
  ptr->InsertNextTuple4(10.0,20.0,30.0,40.0);
  if (ptr->GetTuple4(100)[0] == 10.0 &&
      ptr->GetTuple4(100)[1] == 20.0 &&
      ptr->GetTuple4(100)[2] == 30.0 &&
      ptr->GetTuple4(100)[3] == 40.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }

  strm << "\tInsertNextTuple9...";
  ptr->SetNumberOfComponents(9);
  ptr->SetNumberOfTuples(100);
  ptr->InsertNextTuple9(10.0,20.0,30.0,40.0,50.0,60.0,70.0,80.0,90.0);
  if (ptr->GetTuple9(100)[0] == 10.0 &&
      ptr->GetTuple9(100)[1] == 20.0 &&
      ptr->GetTuple9(100)[2] == 30.0 &&
      ptr->GetTuple9(100)[3] == 40.0 &&
      ptr->GetTuple9(100)[4] == 50.0 &&
      ptr->GetTuple9(100)[5] == 60.0 &&
      ptr->GetTuple9(100)[6] == 70.0 &&
      ptr->GetTuple9(100)[7] == 80.0 &&
      ptr->GetTuple9(100)[8] == 90.0) strm << "OK" << endl;
  else
    {
    errors++;
    strm << "FAILED" << endl;
    }


  farray->Delete();


  strm << "PrintSelf..." << endl;
  strm << *ptr;

  return errors;
}

int otherArraysTest(ostream& strm)
{
  int errors = 0;
  {
  strm << "Test CharArray" << endl;
  vtkCharArray *ptr = vtkCharArray::New();
  char *array = new char[SIZE];
  char value = static_cast<char>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test UnsignedCharArray" << endl;
  vtkUnsignedCharArray *ptr = vtkUnsignedCharArray::New();
  unsigned char *array = new unsigned char[SIZE];
  unsigned char value = static_cast<unsigned char>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test IntArray" << endl;
  vtkIntArray *ptr = vtkIntArray::New();
  int *array = new int[SIZE];
  int value = static_cast<int>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test UnsignedIntArray" << endl;
  vtkUnsignedIntArray *ptr = vtkUnsignedIntArray::New();
  unsigned int *array = new unsigned int[SIZE];
  unsigned int value = static_cast<unsigned int>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test LongArray" << endl;
  vtkLongArray *ptr = vtkLongArray::New();
  long *array = new long[SIZE];
  long value = static_cast<long>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test UnsignedLongArray" << endl;
  vtkUnsignedLongArray *ptr = vtkUnsignedLongArray::New();
  unsigned long *array = new unsigned long[SIZE];
  unsigned long value = static_cast<unsigned long>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test ShortArray" << endl;
  vtkShortArray *ptr = vtkShortArray::New();
  short *array = new short[SIZE];
  short value = static_cast<short>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test UnsignedShortArray" << endl;
  vtkUnsignedShortArray *ptr = vtkUnsignedShortArray::New();
  unsigned short *array = new unsigned short[SIZE];
  unsigned short value = static_cast<unsigned short>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test FloatArray" << endl;
  vtkFloatArray *ptr = vtkFloatArray::New();
  float *array = new float[SIZE];
  float value = static_cast<float>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test DoubleArray" << endl;
  vtkDoubleArray *ptr = vtkDoubleArray::New();
  double *array = new double[SIZE];
  double value = static_cast<double>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }

  {
  strm << "Test IdTypeArray" << endl;
  vtkIdTypeArray *ptr = vtkIdTypeArray::New();
  vtkIdType *array = new vtkIdType[SIZE];
  vtkIdType value = static_cast<vtkIdType>(1);
  for (int i = 0; i < SIZE; i++) *(array + i ) = i;
  errors += doArrayTest (strm, ptr, array, value, SIZE);
  ptr->Delete();
  delete []array;
  }
  return errors;
}

int otherArrays(int, char *[])
{
  return otherArraysTest(cerr);
}
