testDataDeserialization.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 testDataDeserialization.cpp
 * @Description Tests the conversion of Data objects into ValueVectors
 * @Status unknown
 * @Version $Id: testDataDeserialization.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Marco Barbosa
 */

#include "config.h"

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

#include "DataFactory.hpp"
#include "DataValueVector.hpp"


#include <Exception.hpp>
#include <FilePathSearch.hpp>

#include <yarp/os/all.h>

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

using yarp::os::Value;


int main (int argc, char * const argv[])
{
  ACE_Trace::stop_tracing();
  
  int numErrors = 0;
  
  if (argc != 2) {
    cout << "Usage: testDataDeserialization [filename]" << endl;
    return (1);
  }
  
  try {
    std::cerr << "DataStructure framework test" << endl;
    
    FilePathSearch::addSearchPath ("./");
    FilePathSearch::addSearchPath ("/");
    
    shared_ptr<XmlDocument>  doc = shared_ptr<XmlDocument> (new XmlDocument());
    cout << "Reading from file: " << argv[1] << endl;
    doc->parseFile (string (argv[1]));
    DataFactory::loadDataDescription (doc);
    
    
    //test integer
    {
      cout << "Testing single integer" << endl;
      
      Bottle b;
      b.addInt (42);
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("lonely-int", b);
      
      int i = db->getInteger ("lonely");
      
      if (i != 42) {
        throw Exception ("testDataDeserialization : retrieved integer does not have the expected value");
      }
    }
    
    // test integer array static
    {
      cout << "Testing static integer array" << endl;
      
      Bottle b;
      b.addInt (0);
      b.addInt (1);
      b.addInt (2);
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("int-array-static", b);
      
      shared_ptr<IntegerArray> ia = db->getIntegerArray ("intarray");
      
      if (ia->isDynamic() == true) {
        throw Exception ("testDataDeserialization : expected static array");
      }
      
      if (ia->getSize() != 3) {
        throw Exception ("testDataDeserialization : unexpected array size");
      }
      
      for (int j = 0; j < 3; j++) {
        int i = (*ia) [j]->getValue();
        if (j != i) {
          throw Exception ("testDeserialization : unexpected array element value");
        }
      }
      
    }
    
    // test integer dynamic array
    {
      cout << "Testing dynamic integer array" << endl;
      
      Bottle b;
      b.addInt (13);
      
      for (int i = 0; i < 13; i++) {
        b.addInt (i);
      }
      
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("int-array-dynamic", b);
      
      shared_ptr<IntegerArray> array = db->getIntegerArray ("intarray");
      int arraySize = array->getSize();
      
      if (array->isDynamic() == false) {
        throw Exception ("testDataDeserialization : expected dynamic array");
      }
      
      if (arraySize != 13) {
        throw Exception ("testDeserialization : unexpeced array size");
      }
      
      for (int j = 0; j < arraySize; j++) {
        int i = (*array) [j]->getValue();
        
        if (i != j) {
          throw Exception ("testDeserialization : unexpected value in array");
        }
      }
      
    }
    
    // test double
    {
      cout << "Testing single double" << endl;
      
      Bottle b;
      b.addDouble (3.14);
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("lonely-double", b);
      
      double d = db->getDouble ("lonely");
      
      if (d != 3.14) {
        throw Exception ("testDeserialization : unexpected double value");
      }
    }
    
    //test double static array
    {
      cout << "Testing static double array" << endl;
      
      Bottle b;
      b.addDouble (0.0);
      b.addDouble (1.1);
      b.addDouble (2.2);
      
      shared_ptr<DataBox> d = DataFactory::buildDataBoxFromStructureAndBottle ("double-array-static", b);
      
      shared_ptr<DoubleArray> da = d->getDoubleArray ("doublearray");
      
      if (da->isDynamic() == true) {
        throw Exception ("testDataDeserialization : expected static array");
      }
      
      if (da->getSize() != 3) {
        throw Exception ("testDataDeserialization : unexpected array size");
      }
      
      for (int j = 0; j < 3; j++) {
        double i = (*da) [j]->getValue();
        if ( (j*1.1) != i) {
          throw Exception ("testDeserialization : unexpected array element value");
        }
      }
    }
    
    //test double dynamic array
    {
      cout << "Testing dynamic double array" << endl;
      
      Bottle b;
      b.addInt (13);
      
      for (int i = 0; i < 13; i++) {
        b.addDouble (i*1.1);
      }
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("double-array-dynamic", b);
      
      
      shared_ptr<DoubleArray> array = db->getDoubleArray ("doublearray");
      int arraySize = array->getSize();
      
      if (array->isDynamic() == false) {
        throw Exception ("testDataDeserialization : expected dynamic array");
      }
      
      if (arraySize != 13) {
        throw Exception ("testDeserialization : unexpeced array size");
      }
      
      for (int j = 0; j < arraySize; j++) {
        double d = (*array) [j]->getValue();
        if (abs (d - (j*1.1)) > 0.00001) {
          throw Exception ("testDeserialization : unexpected value in array");
        }
      }
    }
    
    
    //test string
    {
      cout << "Testing single string" << endl;
      
      Bottle b;
      b.addString ("hello");
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("lonely-string", b);
      
      std::string s = db->getString ("lonely");
      
      if (s.compare ("hello") != 0) {
        throw Exception ("testDataDeserialization : retrieved string does not have the expected value");
      }
      
    }
    
    //test string static array
    {
      cout << "Testing static string array" << endl;
      
      Bottle b;
      b.addString ("hello");
      b.addString ("world");
      b.addString ("!");
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("string-array-static", b);
      
      shared_ptr<StringArray> sa = db->getStringArray ("stringarray");
      
      if (sa->isDynamic() == true) {
        throw Exception ("testDataDeserialization : expected static array");
      }
      
      if (sa->getSize() != 3) {
        throw Exception ("testDataDeserialization : unexpected array size");
      }
      
      {
        std::string s = (*sa) [0]->getValue();
        if (s.compare ("hello") != 0) {
          throw Exception ("testDeserialization : unexpected array element value");
        }
      }
      
      {
        std::string s = (*sa) [1]->getValue();
        if (s.compare ("world") != 0) {
          throw Exception ("testDeserialization : unexpected array element value");
        }
      }
      
      {
        std::string s = (*sa) [2]->getValue();
        if (s.compare ("!") != 0) {
          throw Exception ("testDeserialization : unexpected array element value");
        }
      }
      
    }
    
    //test string dynamic array
    {
      cout << "Testing dynamic string array" << endl;
      
      Bottle b;
      b.addInt (4);
      b.addString ("The");
      b.addString ("big brown fox");
      b.addString ("jumped over");
      b.addString ("the lazy dog.");
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("string-array-dynamic", b);
      
      shared_ptr<StringArray> array = db->getStringArray ("stringarray");
      int arraySize = array->getSize();
      
      if (array->isDynamic() == false) {
        throw Exception ("testDataDeserialization : expected dynamic array");
      }
      
      if (arraySize != 4) {
        throw Exception ("testDeserialization : unexpeced array size");
      }
      
      
      {
        std::string s = (*array) [0]->getValue();
        if (s.compare ("The") != 0) {
          throw Exception ("testDeserialization : unexpected value in array");
        }
      }
      
      {
        std::string s = (*array) [1]->getValue();
        if (s.compare ("big brown fox") != 0) {
          throw Exception ("testDeserialization : unexpected value in array");
        }
      }
      
      {
        std::string s = (*array) [2]->getValue();
        if (s.compare ("jumped over") != 0) {
          throw Exception ("testDeserialization : unexpected value in array");
        }
      }
      
      {
        std::string s = (*array) [3]->getValue();
        if (s.compare ("the lazy dog.") != 0) {
          throw Exception ("testDeserialization : unexpected value in array");
        }
      }
    }
    
    //test simple data box
    {
      cout << "Testing simple DataBox" << endl;
      
      Bottle b;
      b.addInt (42);
      b.addDouble (3.14);
      b.addString ("Hello world!");
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("simple-data", b);
      
      int i = db->getInteger ("a");
      if (i != 42) {
        throw Exception ("testDeserialization : unexpected value");
      }
      
      double d = db->getDouble ("b");
      if (abs (d - 3.14) > 0.00001) {
        throw Exception ("testDeserialization : unexpected value");
      }
      
      std::string s = db->getString ("c");
      if (s.compare ("Hello world!") != 0) {
        throw Exception ("testDeserialization : unexpected value");
      }
    }
    
    //test complex data box
    {
      cout << "Testing complex DataBox" << endl;
      
      Bottle b;
      b.addInt (42);
      b.addDouble (3.14);
      b.addString ("Hello world!");
      b.addInt (84);
      b.addDouble (6.28);
      b.addString ("Hello hello world world!");
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("complex-data", b);
      
      shared_ptr<DataBox> x = db->getDataBox ("x");
      shared_ptr<DataBox> y = db->getDataBox ("y");
      
      int xa = x->getInteger ("a");
      double xb = x->getDouble ("b");
      std::string xc = x->getString ("c");
      
      if (xa != 42) {
        throw Exception ("testDeserialization : unexpected value");
      }
      
      if (abs (xb - 3.14) > 0.00001) {
        throw Exception ("testDeserialization : unexpected value");
      }
      
      if (xc.compare ("Hello world!") != 0) {
        throw Exception ("testDeserialization : unexpected value");
      }
      
      int ya = y->getInteger ("a");
      double yb = y->getDouble ("b");
      std::string yc = y->getString ("c");
      
      if (ya != 84) {
        throw Exception ("testDeserialization : unexpected value");
      }
      
      if (abs (yb - 6.28) > 0.00001) {
        throw Exception ("testDeserialization : unexpected value");
      }
      
      if (yc.compare ("Hello hello world world!") != 0) {
        throw Exception ("testDeserialization : unexpected value");
      }
    }
    
    //test complex data static array
    {
      cout << "Testing complex DataBox static array" << endl;
      
      Bottle b;
      
      for (int i = 0; i < 5; i++) {
        b.addInt (42*i);
        b.addDouble (3.14*i);
        b.addString ("Hello world!");
      }
      
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("complex-data-array-static", b);
      
      
      shared_ptr<DataBoxArray> x = db->getDataBoxArray ("x");
      shared_ptr<DataBoxArray> y = db->getDataBoxArray ("y");
      
      if (x->isDynamic() != false) {
        throw Exception ("testDataDeserialization : expected static array");
      }
      
      unsigned int xSize = x->getSize();
      if (xSize != 2) {
        throw Exception ("testDataDeserialization : unexpected array size");
      }
      
      
      if (y->isDynamic() != false) {
        throw Exception ("testDataDeserialization : expected static array");
      }
      
      unsigned int ySize = y->getSize();
      if (ySize != 3) {
        throw Exception ("testDataDeserialization : unexpected array size");
      }
      
      
      for (unsigned int i = 0; i < xSize; i++) {
        shared_ptr<DataBox> db = (*x) [i];
        
        int a = db->getInteger ("a");
        double b = db->getDouble ("b");
        std::string c = db->getString ("c");
        
        if (a != (int) (i*42)) {
          throw Exception ("testDataDeserialization : unexpected value");
        }
        
        if (abs (b - (i*3.14)) > 0.00001) {
          throw Exception ("testDataDeserialization : unexpected value");
        }
        
        if (c.compare ("Hello world!") != 0) {
          throw Exception ("testDataDeserialization : unexpected value");
        }
      }
      
      for (unsigned int i = 0; i < ySize; i++) {
        shared_ptr<DataBox> db = (*y) [i];
        
        int a = db->getInteger ("a");
        double b = db->getDouble ("b");
        std::string c = db->getString ("c");
        
        if (a != (int) ( (i + 2) *42)) {
          throw Exception ("testDataDeserialization : unexpected value");
        }
        
        if (abs (b - ( (i + 2) *3.14)) > 0.00001) {
          throw Exception ("testDataDeserialization : unexpected value");
        }
        
        if (c.compare ("Hello world!") != 0) {
          throw Exception ("testDataDeserialization : unexpected value");
        }
      }
      
      
      //db->print();
      //std::cerr << std::endl;
    }
    
    //test complex data dynamic array
    {
      cout << "Testing complex DataBox dynamic array" << endl;
      
      Bottle b;
      
      int arraySize = 50;
      
      b.addInt (arraySize);
      
      for (int i = 0; i < arraySize; i++) {
        b.addInt (i*42);
        b.addDouble (i*3.14);
        b.addString ("Hello world!");
      }
      
      shared_ptr<DataBox> db = DataFactory::buildDataBoxFromStructureAndBottle ("complex-data-array-dynamic", b);
      
      shared_ptr<DataBoxArray> x = db->getDataBoxArray ("x");
      
      if (x->isDynamic() != true) {
        throw Exception ("testDataDeserialization : expected dynamic array");
      }
      
      unsigned int xSize = x->getSize();
      if (xSize != 50) {
        throw Exception ("testDataDeserialization : unexpected array size");
      }
      
      for (unsigned int i = 0; i < xSize; i++) {
        shared_ptr<DataBox> db = (*x) [i];
        
        int a = db->getInteger ("a");
        double b = db->getDouble ("b");
        std::string c = db->getString ("c");
        
        if (a != (int) (i*42)) {
          throw Exception ("testDataDeserialization : unexpected value");
        }
        
        if (abs (b - (i*3.14)) > 0.00001) {
          throw Exception ("testDataDeserialization : unexpected value");
        }
        
        if (c.compare ("Hello world!") != 0) {
          throw Exception ("testDataDeserialization : unexpected value");
        }
      }
      
      //db->print();
      //std::cerr << std::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);
  }
}; // main()