TestArray2D.cpp

/* This file is part of the BIAS library (Basic ImageAlgorithmS).

   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/

/**
   @file TestArray2D.cpp
   @relates Array2D
   @brief Test Array 2D
   @ingroup g_tests
   @author MIP
*/

#include <Base/Common/Array2D.hh>
#include <Base/Debug/Error.hh>
#include <Base/Debug/Exception.hh>

#include <vector>

using namespace BIAS;
using namespace std;


const bool verbose = true;

/// macro testing if command has thrown an exception
#define SHOULD_THROW(command) \
{ \
  bool has_thrown = false; \
  try { command; } \
  catch ( BaseException b ) { has_thrown = true; } \
  if (!has_thrown) { \
    if (verbose) cout << #command << " was expected to throw an exception"\
                      <<", but it has not thrown. Test failed. \n"<<endl; \
    BIASABORT; \
  } \
}

void TestInit();

void TestAccess();

void TestIterator();

void TestCompileErrors();

int main(int argc, char *argv[])
{
  TestInit();
  TestAccess();
  TestIterator();
  TestCompileErrors();

  return 0;
}


void TestInit()
{
  const unsigned nrow = 5, ncol = 7;

  Array2D<int> foo;
  if (!foo.empty()) { BIASABORT; }
  if (foo.nrows() != 0) { BIASABORT; }
  if (foo.ncols() != 0) { BIASABORT; }
  if (foo.size() != 0) { BIASABORT; }

  Array2D<unsigned> foo2(nrow, ncol);
  if (foo2.empty()) { BIASABORT; }
  if (foo2.nrows() != nrow) { BIASABORT; }
  if (foo2.ncols() != ncol) { BIASABORT; }
  if (foo2.size() != ncol * nrow) { BIASABORT; }

  Array2D<unsigned> cp(foo2);
  if (cp.empty()) { BIASABORT; }
  if (cp.nrows() != nrow) { BIASABORT; }
  if (cp.ncols() != ncol) { BIASABORT; }
  
  Array2D<unsigned> uta = cp;
  if (uta.empty()) { BIASABORT; }
  if (uta.nrows() != nrow) { BIASABORT; }
  if (uta.ncols() != ncol) { BIASABORT; }
  
  foo2.clear();
  if (!foo2.empty()) { BIASABORT; }
  if (foo2.nrows() != 0) { BIASABORT; }
  if (foo2.ncols() != 0) { BIASABORT; }

  foo2.resize(nrow, ncol);
  if (foo2.empty()) { BIASABORT; }
  if (foo2.nrows() != nrow) { BIASABORT; }
  if (foo2.ncols() != ncol) { BIASABORT; }
  if (foo2.size() != ncol * nrow) { BIASABORT; }
  
}


void TestAccess()
{
  const unsigned nrow = 11, ncol = 17;
  const unsigned prow = nrow-1, pcol = ncol-1;
  const int val = -1, val2 = 42;
  // test checked access using round brackets
  Array2D<int> foo(nrow, ncol);
  foo.fill(val);
  foo(prow, pcol) = val2;
  for (unsigned r=0; r<nrow; r++){
    for (unsigned c=0; c<ncol; c++){
      if (r==prow && c==pcol){
        if (foo(r,c) != val2) { BIASABORT; } 
      } else {
        if (foo(r,c) != val) { BIASABORT; } 
      }
    }
  }
  // check if operator() throws if accessing out of range
  SHOULD_THROW(foo(nrow, 0));
  SHOULD_THROW(foo(0, ncol));
  SHOULD_THROW(foo(nrow, ncol));
  SHOULD_THROW(foo(nrow+42, 0));
  SHOULD_THROW(foo(0, ncol+42));
  SHOULD_THROW(foo(nrow+42, ncol+42));
  //


  // test access using square brackets
  foo.fill(val2);
  foo[prow][pcol] = val;
  for (unsigned r=0; r<nrow; r++){
    for (unsigned c=0; c<ncol; c++){
      if (r==prow && c==pcol){
        if (foo[r][c] != val) { BIASABORT; } 
      } else {
        if (foo[r][c] != val2) { BIASABORT; } 
      }
    }
  }
}


void TestIterator()
{
  const unsigned nrow = 3, ncol = 4;
  const unsigned prow = nrow-1, pcol = ncol-1;
  const int val = -1, val2 = 42;
  Array2D<int> foo(nrow, ncol);
  foo.fill(val2);
  foo[prow][pcol] = val;

  // test const_iterator access
  const Array2D<int> cfoo(foo);
  Array2D<int>::const_iterator cit;
  unsigned pos = 0;
  for (cit = cfoo.begin(); cit != cfoo.end(); cit++, pos++){
    if (pos == prow * ncol + pcol){
      if (*cit != val) { BIASABORT; }
    } else {
      if (*cit != val2) { BIASABORT; }
    }
  }

  // test iterator access
  Array2D<int>::iterator it;
  int ipos = 0;
  for (it = foo.begin(); it != foo.end(); it++, ipos++){
    *it = ipos;
  }
  for (unsigned r=0; r<nrow; r++){
    for (unsigned c=0; c<ncol; c++){
      if (foo[r][c] != (int)(r*ncol + c)) { BIASABORT; } 
    }
  }

  // test operator-> of const iterator
  Array2D<vector<int> > vfoo(nrow, ncol);
  const vector<int> vval(1, val2), vval2(1, val);
  vfoo.fill(vval);
  vfoo[prow][pcol] = vval2;
  Array2D<vector<int> > cvfoo(vfoo);

  Array2D<vector<int> >::const_iterator cvit;
  Array2D<vector<int> >::iterator vit;
  pos = 0;
  for (cvit = cvfoo.begin(); cvit != cvfoo.end(); cvit++, pos++){
    if (pos == prow * ncol + pcol){
      if (cvit->operator[](0) != val) { BIASABORT; }
    } else {
      if (cvit->operator[](0) != val2) { BIASABORT; }
    }
  }

  // test operator-> of iterator
  ipos = 0;
  for (vit = vfoo.begin(); vit != vfoo.end(); vit++, ipos++){
    vit->resize(2);
    vit->operator[](1) = ipos;
  }
  for (unsigned r=0; r<nrow; r++){
    for (unsigned c=0; c<ncol; c++){
      if (vfoo[r][c][1] != (int)(r*ncol + c)) { BIASABORT; } 
    }
  }
  
}


void TestCompileErrors()
{
  const unsigned nrow = 11, ncol = 17;
  Array2D<int> foo(nrow, ncol);
  foo.fill(-1);
  const Array2D<int> cfoo(foo);
  // non-const iterator from non-const object
  Array2D<int>::iterator it = foo.begin();
  // const_iterator from const object
  Array2D<int>::const_iterator cit = cfoo.begin();
  // const_iterator from non-const object
  Array2D<int>::const_iterator cit2 = foo.begin();

#ifdef TEST_COMPILE_TIME_ERROR_ConstIterator
  // cannot take iterator from const object
  Array2D<int>::iterator it2 = cfoo.begin(); 
#endif

#ifdef TEST_COMPILE_TIME_ERROR_TemplateMismatch
  // template type mismatch
  Array2D<unsigned>::iterator uit = foo.begin(); 
#endif

}