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

#include "config.h"

#include <ace/Trace.h>

#include <iostream>
#include <sstream>
#include <typeinfo>
#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: testDataSerialization [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;
      shared_ptr<DataBox> i = DataFactory::buildDataBox ("lonely-int");
      Bottle b;
      DataFactory::writeDataBoxToBottle (i, b);
      
      if (b.size() != 1) {
        throw Exception ("testDataSerialization : Bottle for single integer does not have size 1");
      }
      
      Value v = b.get (0);
      if (v.isInt() == false) {
        throw Exception ("testDataSerialization : Value for single integer does not have type INTEGER");
      }
    }
    
    // test integer array static
    {
      cout << "Testing static integer array" << endl;
      shared_ptr<DataBox> i = DataFactory::buildDataBox ("int-array-static");
      Bottle b;
      DataFactory::writeDataBoxToBottle (i, b);
      
      int arraySize = 3;
      
      if (b.size() != (arraySize)) {
        throw Exception ("testDataSerialization : Bottle for static integer array does not have expected size");
      }
      
      for (int j = 0; j < arraySize; j++) {
        Value v = b.get (j);
        if (v.isInt() == false) {
          throw Exception ("testDataSerialization : Value for single integer does not have type INTEGER");
        }
      }
    }
    
    // test integer dynamic array
    {
      cout << "Testing dynamic integer array" << endl;
      shared_ptr<DataBox> i = DataFactory::buildDataBox ("int-array-dynamic");
      // filling dynamic array with some data
      int arraySize = 13;
      shared_ptr<IntegerArray> array = i->getIntegerArray ("intarray");
      for (int j = 0; j < arraySize; j++) {
        array->pushBack (j);
      }
      
      Bottle b;
      DataFactory::writeDataBoxToBottle (i, b);
      
      if (b.size() != (arraySize + 1)) {
        throw Exception ("testDataSerialization : Bottle for dynamic integer array does not have expected size");
      }
      
      Value v = b.get (0);
      if (v.isInt() == false) {
        throw Exception ("testDataSerialization : Value for dynamic integer array size does not have type INTEGER");
      }
      
      for (int j = 1; j < (arraySize + 1); j++) {
        Value v = b.get (j);
        if (v.isInt() == false) {
          throw Exception ("testDataSerialization : Value for single integer does not have type INTEGER");
        }
      }
    }
    
    // test double
    {
      cout << "Testing single double" << endl;
      shared_ptr<DataBox> d = DataFactory::buildDataBox ("lonely-double");
      Bottle b;
      DataFactory::writeDataBoxToBottle (d, b);
      
      if (b.size() != 1) {
        throw Exception ("testDataSerialization : Bottle for single double does not have size 1");
      }
      
      Value v = b.get (0);
      if (v.isDouble() == false) {
        throw Exception ("testDataSerialization : Value for single double does not have type DOUBLE");
      }
    }
    
    //test double static array
    {
      cout << "Testing static double array" << endl;
      shared_ptr<DataBox> d = DataFactory::buildDataBox ("double-array-static");
      Bottle b;
      DataFactory::writeDataBoxToBottle (d, b);
      
      int arraySize = 3;
      
      if (b.size() != (arraySize)) {
        throw Exception ("testDataSerialization : Bottle for static double array does not have expected size");
      }
      
      for (int j = 0; j < arraySize; j++) {
        Value v = b.get (j);
        if (v.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for single double does not have type DOUBLE");
        }
      }
    }
    
    //test double dynamic array
    {
      cout << "Testing dynamic double array" << endl;
      shared_ptr<DataBox> d = DataFactory::buildDataBox ("double-array-dynamic");
      // filling dynamic array with some data
      int arraySize = 13;
      shared_ptr<DoubleArray> array = d->getDoubleArray ("doublearray");
      for (int j = 0; j < arraySize; j++) {
        array->pushBack ( (double) j);
      }
      
      Bottle b;
      DataFactory::writeDataBoxToBottle (d, b);
      
      if (b.size() != (arraySize + 1)) {
        throw Exception ("testDataSerialization : Bottle for dynamic integer array does not have expected size");
      }
      
      Value v = b.get (0);
      if (v.isInt() == false) {
        throw Exception ("testDataSerialization : Value for dynamic double array size does not have type INTEGER");
      }
      
      for (int j = 1; j < (arraySize + 1); j++) {
        Value v = b.get (j);
        if (v.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for single double does not have type DOUBLE");
        }
      }
    }
    
    
    //test string
    {
      cout << "Testing single string" << endl;
      shared_ptr<DataBox> s = DataFactory::buildDataBox ("lonely-string");
      Bottle b;
      DataFactory::writeDataBoxToBottle (s, b);
      
      if (b.size() != 1) {
        throw Exception ("testDataSerialization : Bottle for single string does not have size 1");
      }
      
      Value v = b.get (0);
      if (v.isString() == false) {
        throw Exception ("testDataSerialization : Value for single double does not have type STRING");
      }
    }
    
    //test string static array
    {
      cout << "Testing static string array" << endl;
      shared_ptr<DataBox> s = DataFactory::buildDataBox ("string-array-static");
      Bottle b;
      DataFactory::writeDataBoxToBottle (s, b);
      
      int arraySize = 3;
      
      if (b.size() != (arraySize)) {
        throw Exception ("testDataSerialization : Bottle for static string array does not have expected size");
      }
      
      for (int j = 0; j < arraySize; j++) {
        Value v = b.get (j);
        if (v.isString() == false) {
          throw Exception ("testDataSerialization : Value for single string does not have type STRING");
        }
      }
    }
    
    //test string dynamic array
    {
      cout << "Testing dynamic string array" << endl;
      shared_ptr<DataBox> s = DataFactory::buildDataBox ("string-array-dynamic");
      // filling dynamic array with some data
      int arraySize = 13;
      shared_ptr<StringArray> array = s->getStringArray ("stringarray");
      for (int j = 0; j < arraySize; j++) {
        std::stringstream ss;
        ss << j;
        array->pushBack (ss.str());
      }
      
      Bottle b;
      DataFactory::writeDataBoxToBottle (s, b);
      
      if (b.size() != (arraySize + 1)) {
        throw Exception ("testDataSerialization : Bottle for dynamic string array does not have expected size");
      }
      
      Value v = b.get (0);
      if (v.isInt() == false) {
        throw Exception ("testDataSerialization : Value for dynamic string array size does not have type INTEGER");
      }
      
      for (int j = 1; j < (arraySize + 1); j++) {
        Value v = b.get (j);
        if (v.isString() == false) {
          throw Exception ("testDataSerialization : Value for single string does not have type STRING");
        }
      }
    }
    
    //test simple data box
    {
      cout << "Testing simple DataBox" << endl;
      shared_ptr<DataBox> d = DataFactory::buildDataBox ("simple-data");
      Bottle b;
      DataFactory::writeDataBoxToBottle (d, b);
      
      if (b.size() != 3) {
        throw Exception ("testDataSerialization : Bottle for simple-data does not have size 3");
      }
      
      {
        Value v0 = b.get (0);
        if (v0.isInt() == false) {
          throw Exception ("testDataSerialization : Value for simple-data at position #0 does not have type INTEGER");
        }
      }
      
      {
        Value v1 = b.get (1);
        if (v1.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for simple-data at position #1 does not have type DOUBLE");
        }
      }
      
      {
        Value v2 = b.get (2);
        if (v2.isString() == false) {
          throw Exception ("testDataSerialization : Value for simple-data at position #2 does not have type STRING");
        }
      }
    }
    
    //test complex data box
    {
      cout << "Testing complex DataBox" << endl;
      shared_ptr<DataBox> d = DataFactory::buildDataBox ("complex-data");
      Bottle b;
      DataFactory::writeDataBoxToBottle (d, b);
      
      if (b.size() != 6) {
        throw Exception ("testDataSerialization : Bottle for complex-data does not have size 6");
      }
      
      {
        Value v0 = b.get (0);
        if (v0.isInt() == false) {
          throw Exception ("testDataSerialization : Value for complex-data at position #0 does not have type INTEGER");
        }
      }
      
      {
        Value v1 = b.get (1);
        if (v1.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for complex-data at position #1 does not have type DOUBLE");
        }
      }
      
      {
        Value v2 = b.get (2);
        if (v2.isString() == false) {
          throw Exception ("testDataSerialization : Value for complex-data at position #2 does not have type STRING");
        }
      }
      
      {
        Value v3 = b.get (3);
        if (v3.isInt() == false) {
          throw Exception ("testDataSerialization : Value for complex-data at position #3 does not have type INTEGER");
        }
      }
      
      {
        Value v4 = b.get (4);
        if (v4.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for complex-data at position #4 does not have type DOUBLE");
        }
      }
      
      {
        Value v5 = b.get (5);
        if (v5.isString() == false) {
          throw Exception ("testDataSerialization : Value for complex-data at position #5 does not have type STRING");
        }
      }
    }
    
    //test complex data static array
    {
      cout << "Testing complex DataBox static array" << endl;
      shared_ptr<DataBox> d = DataFactory::buildDataBox ("complex-data-array-static");
      Bottle b;
      DataFactory::writeDataBoxToBottle (d, b);
      
      if (b.size() != 15) {
        throw Exception ("testDataSerialization : Bottle for complex-data-array-static does not have size 15");
      }
      
      {
        Value v0 = b.get (0);
        if (v0.isInt() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type INTEGER");
        }
      }
      
      {
        Value v1 = b.get (1);
        if (v1.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type DOUBLE");
        }
      }
      
      {
        Value v2 = b.get (2);
        if (v2.isString() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type STRING");
        }
      }
      
      {
        Value v3 = b.get (3);
        if (v3.isInt() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type INTEGER");
        }
      }
      
      {
        Value v4 = b.get (4);
        if (v4.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type DOUBLE");
        }
      }
      
      {
        Value v5 = b.get (5);
        if (v5.isString() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type STRING");
        }
      }
      
      {
        Value v6 = b.get (6);
        if (v6.isInt() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type INTEGER");
        }
      }
      
      {
        Value v7 = b.get (7);
        if (v7.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type DOUBLE");
        }
      }
      
      {
        Value v8 = b.get (8);
        if (v8.isString() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type STRING");
        }
      }
      
      {
        Value v9 = b.get (9);
        if (v9.isInt() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type INTEGER");
        }
      }
      
      {
        Value v10 = b.get (10);
        if (v10.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type DOUBLE");
        }
      }
      
      {
        Value v11 = b.get (11);
        if (v11.isString() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type STRING");
        }
      }
      
      {
        Value v12 = b.get (12);
        if (v12.isInt() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type INTEGER");
        }
      }
      
      {
        Value v13 = b.get (13);
        if (v13.isDouble() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type DOUBLE");
        }
      }
      
      {
        Value v14 = b.get (14);
        if (v14.isString() == false) {
          throw Exception ("testDataSerialization : Value for complex-data-array-static at position #0 does not have type STRING");
        }
      }
    }
    
    //test complex data dynamic array
    {
      cout << "Testing complex DataBox dynamic array" << endl;
      shared_ptr<DataBox> d = DataFactory::buildDataBox ("complex-data-array-dynamic");
      Bottle b;
      int arraySize = 10;
      shared_ptr<DataBoxArray> array = d->getDataBoxArray ("x");
      for (int j = 0; j < arraySize; j++) {
        std::stringstream ss;
        shared_ptr<DataBox> data = DataFactory::buildDataBox ("simple-data");
        array->pushBack (data);
      }
      
      DataFactory::writeDataBoxToBottle (d, b);
      
      if (b.size() != 31) {
        throw Exception ("testDataSerialization : Bottle for complex-data-array-dynamic does not have size 31");
      }
    }
    
    
  }
  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()