testDataStructure.cpp

Go to the documentation of this file.

/*
Copyright 2007, 2008, 2009, 2010, 2011 Instituto de Sistemas e Robotica, Instituto Superior Tecnico

This file is part of MeRMaID.

MeRMaID 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 3 of the License, or
(at your option) any later version.

MeRMaID 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 MeRMaID.  If not, see <http://www.gnu.org/licenses/>.
*/



/**
 * @Filename testDataStructure.cpp
 * @Description Tests the DataStructure framework implementation
 * @Status unknown
 * @Version $Id: testDataStructure.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Marco Barbosa + Nelson Ramos
 */

#include "config.h"

#include <iostream>
#include <sstream>
#include <typeinfo>
#include <ace/Trace.h>

#include "DataFactory.hpp"

#include <Boolean.hpp>

#include <Exception.hpp>



using namespace mermaid::support::data;
using mermaid::support::errorhandling::Exception;
using std::string;
using std::cout;
using std::endl;



int main (int argc, char * const argv[])
{
  ACE_Trace::stop_tracing();
  
  int numErrors = 0;
  
  try {
    std::cerr << "DataStructure framework test" << endl;
    
    //test creation of integer value
    {
      std::cerr << "Testing creation of Integer" << std::endl;
      int testInt = 42;
      shared_ptr<Integer> i1 = DataFactory::buildInteger (testInt);
      int retrievedInt = i1->getValue();
      if (retrievedInt != testInt) {
        numErrors++;
        std::cerr << "ERROR: unexpected value read from Integer, expected " << testInt << ", received " << retrievedInt << std::endl;
      }
    }
    
    //test creation of double value
    {
      std::cerr << "Testing creation of Double" << std::endl;
      double testDouble = 3.14;
      shared_ptr<Double> d1 = DataFactory::buildDouble (testDouble);
      double retrievedDouble = d1->getValue();
      if (retrievedDouble != testDouble) {
        numErrors++;
        std::cerr << "ERROR: unexpected value read from Double, expected " << testDouble << ", received " << retrievedDouble << std::endl;
      }
    }
    
    //test creation of string value
    {
      std::cerr << "Testing creation of String" << std::endl;
      std::string  testString ("Hello MeRMaID");
      shared_ptr<String> s1 = DataFactory::buildString (testString);
      std::string retrievedString = s1->getValue();
      if (retrievedString != testString) {
        numErrors++;
        std::cerr << "ERROR: unexpected value read from String, expected " << testString << ", received " << retrievedString << std::endl;
      }
    }
    
    //test creation of static IntegerArray
    {
      std::cerr << "Testing creation of static IntegerArray" << std::endl;
      int arrayCreationSize = 2048;
      shared_ptr<IntegerArray> array = DataFactory::buildStaticIntegerArray (arrayCreationSize);
      if (array->isDynamic() == true) {
        numErrors++;
        std::cerr << "ERROR: unexpected response to isDynamic expected FALSE, received TRUE" << std::endl;
      }
      int arrayActualSize = array->getSize();
      if (arrayCreationSize != arrayActualSize) {
        numErrors++;
        std::cerr << "ERROR: unexpected static IntegerArray size, expected " << arrayCreationSize << ", received " << arrayActualSize << std::endl;
      }
      //check if all values are 0
      for (unsigned int i = 0; i < array->getSize(); i++) {
        int retrievedInt = ( (*array)) [i]->getValue();
        if (retrievedInt != 0) {
          numErrors++;
          std::cerr << "ERROR: unexpected value read from IntegerArray, expected 0, received " << retrievedInt << std::endl;
        }
      }
      
      //assign all values their order number
      for (unsigned int i = 0; i < array->getSize(); i++) {
        (* (*array) [i]) = i;
      }
      
      //verify that all values have been assigned
      for (unsigned int i = 0; i < array->getSize(); i++) {
        int retrievedInt = ( (*array)) [i]->getValue();
        if (retrievedInt != (signed) i) {
          numErrors++;
          std::cerr << "ERROR: unexpected value read from IntegerArray, expected " << i << ", received " << retrievedInt << std::endl;
        }
      }
    } // test static IntegerArray
    
    //test creation of dynamic IntegerArray
    {
      std::cerr << "Testing creation of dynamic IntegerArray" << std::endl;
      unsigned int arrayTargetSize = 2048;
      shared_ptr<IntegerArray> array = DataFactory::buildDynamicIntegerArray();
      if (array->isDynamic() == false) {
        numErrors++;
        std::cerr << "ERROR: unexpected response to isDynamic expected TRUE, received FALSE" << std::endl;
      }
      
      if (array->getSize() != 0) {
        numErrors++;
        std::cerr << "ERROR: unexpected dynamic IntegerArray size, expected 0, received " << array->getSize() << std::endl;
      }
      
      //fill with ordered values
      for (unsigned int i = 0; i < arrayTargetSize; i++) {
        array->pushBack (i);
      }
      
      if (array->getSize() != arrayTargetSize) {
        numErrors++;
        std::cerr << "ERROR: unexpected dynamic IntegerArray size, expected " << arrayTargetSize << ", received " << array->getSize() << std::endl;
      }
      
      //verify that all values have been assigned
      for (unsigned int i = 0; i < array->getSize(); i++) {
        int retrievedInt = ( (*array)) [i]->getValue();
        if (retrievedInt != (signed) i) {
          numErrors++;
          std::cerr << "ERROR: unexpected value read from IntegerArray, expected " << i << ", received " << retrievedInt << std::endl;
        }
      }
    } // test dynamic IntegerArray
    
    //test creation of static DoubleArray
    {
      std::cerr << "Testing creation of static DoubleArray" << std::endl;
      int arrayCreationSize = 2048;
      shared_ptr<DoubleArray> array = DataFactory::buildStaticDoubleArray (arrayCreationSize);
      if (array->isDynamic() == true) {
        numErrors++;
        std::cerr << "ERROR: unexpected response to isDynamic expected FALSE, received TRUE" << std::endl;
      }
      int arrayActualSize = array->getSize();
      if (arrayCreationSize != arrayActualSize) {
        numErrors++;
        std::cerr << "ERROR: unexpected static DoubleArray size, expected " << arrayCreationSize << ", received " << arrayActualSize << std::endl;
      }
      //check if all values are 0
      for (unsigned int i = 0; i < array->getSize(); i++) {
        double retrievedDouble = ( (*array)) [i]->getValue();
        if (retrievedDouble != 0) {
          numErrors++;
          std::cerr << "ERROR: unexpected value read from DoubleArray, expected 0, received " << retrievedDouble << std::endl;
        }
      }
      
      //assign all values their order number
      for (unsigned int i = 0; i < array->getSize(); i++) {
        (* (*array) [i]) = (double) i;
      }
      
      //verify that all values have been assigned
      for (unsigned int i = 0; i < array->getSize(); i++) {
        double retrievedDouble = ( (*array)) [i]->getValue();
        if (retrievedDouble != (signed) i) {
          numErrors++;
          std::cerr << "ERROR: unexpected value read from DoubleArray, expected " << i << ", received " << retrievedDouble << std::endl;
        }
      }
    } // test static DoubleArray
    
    //test creation of dynamic DoubleArray
    {
      std::cerr << "Testing creation of dynamic DoubleArray" << std::endl;
      unsigned int arrayTargetSize = 2048;
      shared_ptr<DoubleArray> array = DataFactory::buildDynamicDoubleArray();
      if (array->isDynamic() == false) {
        numErrors++;
        std::cerr << "ERROR: unexpected response to isDynamic expected TRUE, received FALSE" << std::endl;
      }
      if (array->getSize() != 0) {
        numErrors++;
        std::cerr << "ERROR: unexpected dynamic DoubleArray size, expected 0, received " << array->getSize() << std::endl;
      }
      
      //fill with ordered values
      for (unsigned int i = 0; i < arrayTargetSize; i++) {
        array->pushBack ( (double) i);
      }
      
      if (array->getSize() != arrayTargetSize) {
        numErrors++;
        std::cerr << "ERROR: unexpected dynamic DoubleArray size, expected " << arrayTargetSize << ", received " << array->getSize() << std::endl;
      }
      
      //verify that all values have been assigned
      for (unsigned int i = 0; i < array->getSize(); i++) {
        double retrievedDouble = ( (*array)) [i]->getValue();
        if (retrievedDouble != (double) i) {
          numErrors++;
          std::cerr << "ERROR: unexpected value read from DoubleArray, expected " << ( (double) i) << ", received " << retrievedDouble << std::endl;
        }
      }
    } // test dynamic DoubleArray
    
    //test creation of static StringArray
    {
      std::cerr << "Testing creation of static StringArray" << std::endl;
      int arrayCreationSize = 2048;
      shared_ptr<StringArray> array = DataFactory::buildStaticStringArray (arrayCreationSize);
      if (array->isDynamic() == true) {
        numErrors++;
        std::cerr << "ERROR: unexpected response to isDynamic expected FALSE, received TRUE" << std::endl;
      }
      int arrayActualSize = array->getSize();
      if (arrayCreationSize != arrayActualSize) {
        numErrors++;
        std::cerr << "ERROR: unexpected static StringArray size, expected " << arrayCreationSize << ", received " << arrayActualSize << std::endl;
      }
      //check if all values are 0
      for (unsigned int i = 0; i < array->getSize(); i++) {
        string retrievedString = ( (*array)) [i]->getValue();
        if (retrievedString != "") {
          numErrors++;
          std::cerr << "ERROR: unexpected value read from StringArray, expected \"\", received \"" << retrievedString << "\"" << std::endl;
        }
      }
      
      //assign all values their order number
      for (unsigned int i = 0; i < array->getSize(); i++) {
        std::stringstream ss;
        ss << i;
        (* (*array) [i]) = ss.str();
      }
      
      //verify that all values have been assigned
      for (unsigned int i = 0; i < array->getSize(); i++) {
        std::string retrievedString = ( (*array)) [i]->getValue();
        std::stringstream ss;
        ss << i;
        if (retrievedString != ss.str()) {
          numErrors++;
          std::cerr << "ERROR: unexpected value read from StringArray, expected \"" << ss.str() << "\", received \"" << retrievedString << "\"" << std::endl;
        }
      }
    } // test static StringArray
    
    //test creation of dynamic StringArray
    {
      std::cerr << "Testing creation of dynamic StringArray" << std::endl;
      unsigned int arrayTargetSize = 2048;
      shared_ptr<StringArray> array = DataFactory::buildDynamicStringArray();
      if (array->isDynamic() == false) {
        numErrors++;
        std::cerr << "ERROR: unexpected response to isDynamic expected TRUE, received FALSE" << std::endl;
      }
      if (array->getSize() != 0) {
        numErrors++;
        std::cerr << "ERROR: unexpected dynamic StringArray size, expected 0, received " << array->getSize() << std::endl;
      }
      
      //fill with ordered values
      for (unsigned int i = 0; i < arrayTargetSize; i++) {
        std::stringstream ss;
        ss << i;
        array->pushBack (ss.str());
      }
      
      if (array->getSize() != arrayTargetSize) {
        numErrors++;
        std::cerr << "ERROR: unexpected dynamic StringArray size, expected " << arrayTargetSize << ", received " << array->getSize() << std::endl;
      }
      
      //verify that all values have been assigned
      for (unsigned int i = 0; i < array->getSize(); i++) {
        std::string retrievedString = ( (*array)) [i]->getValue();
        std::stringstream ss;
        ss << i;
        if (retrievedString != ss.str()) {
          numErrors++;
          std::cerr << "ERROR: unexpected value read from IntegerArray, expected " << ss.str() << ", received " << retrievedString << std::endl;
        }
      }
    } // test dynamic StringArray
    
    cout << "Ok." << endl;
    
  }
  catch (Exception &exception) {
    cout << "ERROR:" << endl;
    cout << "\t" << exception.what() << endl;
    numErrors++;
  }
  catch (...) {
    cout << "How the hell did I end up here?!" << endl;
    numErrors++;
  }
  
  if (numErrors > 0) {
    return (1);
  }
  else {
    return (0);
  }
};