TestSparseArray2D.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 TestSparseArray2D.cpp
   @relates SparseArray2D
   @brief Test sparsely occupied Array2D
   @ingroup g_tests
   @author MIP
*/

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

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();

template <class T>
void Fill(SparseArray2D<T> &arg, const T& val);

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

  return 0;
}


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

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

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

  SparseArray2D<unsigned> cp(foo2);
  if (cp.empty()) { BIASABORT; }
  if (cp.nrows() != nrow) { BIASABORT; }
  if (cp.ncols() != ncol) { BIASABORT; }
  
  SparseArray2D<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
  SparseArray2D<int> foo(nrow, ncol);
  Fill(foo, 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));

}

void TestIterator()
{
  const unsigned nrow = 3, ncol = 4;
  const unsigned prow = nrow-1, pcol = ncol-1;
  const int val = -1, val2 = 42;
  SparseArray2D<int> foo(nrow, ncol);
  Fill(foo, val2);
  foo(prow, pcol) = val;

  // test const_iterator access
  const SparseArray2D<int> cfoo(foo);
  SparseArray2D<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
  SparseArray2D<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; } 
    }
  }
}


void TestCompileErrors()
{
  const unsigned nrow = 11, ncol = 17;
  SparseArray2D<int> foo(nrow, ncol);
  Fill(foo, -1);
  const SparseArray2D<int> cfoo(foo);
  SparseArray2D<int>::iterator it = foo.begin();;
  SparseArray2D<int>::const_iterator cit;

  cit = cfoo.begin(); // const_iterator from const object
  cit = foo.begin();  // const_iterator from non-const object

#ifdef TEST_COMPILE_TIME_ERROR_ConstIterator
  it = cfoo.begin(); // cannot take iterator from const object
#endif

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

}

template <class T>
void Fill(SparseArray2D<T> &arg, const T& val)
{
  const unsigned nr=arg.nrows(), nc=arg.ncols();
  unsigned r, c;
  for (r=0; r<nr; r++){
    for (c=0; c<nc; c++){
      arg(r, c) = val;
    }
  }
}