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


#include "config.h"


#include "DataBox.hpp"
#include "DataFactory.hpp"
#include <Exception.hpp>

#include <FilePathSearch.hpp>

#include <iostream>
#include <ace/Trace.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::Bottle;


int main (int argc, char * const argv[])
{
  ACE_Trace::stop_tracing();
  
  bool errorOccured = false;
  
  if (argc != 2) {
    cout << "Usage: testDataDescription [filename]" << endl;
    return (1);
  }
  
  try {
    std::cerr << "DataStructure description 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);
    
    try {
      DataFactory::buildDataBox ("xpto");
      std::cerr << "ERROR:\tExpected to get an Exception for invalid data structure type name" << std::endl;
      errorOccured = true;
    }
    catch (Exception &exception) {
      std::cerr << "OK:\tGot an Exception due to an invalid data structure type name" << std::endl;
      //all ok
    }
    
    {
      std::cerr << "Building \"simple-data\"" << std::endl;
      shared_ptr<DataBox> db1 = DataFactory::buildDataBox ("simple-data");
      
      if (db1) {
        cout << "db1 structure:\t" << db1->getBoxStructureName() << endl;
        
        {
          shared_ptr<DataValue> dva = db1->getValue ("a");
          string dvas = *dva;
          
          cout << "db1: a: " << dvas << endl;
        }
        
        {
          shared_ptr<DataValue> dvb = db1->getValue ("b");
          string dvbs = *dvb;
          
          cout << "db1: b: " << dvbs << endl;
        }
        
        {
          shared_ptr<DataValue> dvc = db1->getValue ("c");
          string dvcs = *dvc;
          
          cout << "db1: c: " << dvcs << endl;
        }
      }
      else {
        cout << "ERROR:\tDataFactory did not build a valid Data for structure type name \"simple-data\"" << std::endl;
        errorOccured = true;
      };
    }
    
    
    {
      shared_ptr<DataBox> db = DataFactory::buildDataBox ("lonely-int");
      
      shared_ptr<DataValue> boxvalue = db->getValue ("lonely");
      shared_ptr<DataValue> vectorvalue = db->getDataValueVector()->getValue (0);
      
      if (boxvalue.get() != vectorvalue.get()) {
        cout << "ERROR:\tPointers are not equal when accessing by name or by the value vector" << std::endl;
        errorOccured = true;
      }
    }
    
    {
      shared_ptr<DataBox> db = DataFactory::buildDataBox ("int-array-dynamic");
      shared_ptr<IntegerArray> intarray = db->getIntegerArray ("intarray");
      std::cerr << (std::string) ( (*intarray)) << std::endl;
      
      intarray->pushBack (42);
      std::cerr << (std::string) ( (*intarray)) << std::endl;
    }
    
    {
      shared_ptr<DataBox> db = DataFactory::buildDataBox ("int-array-static");
      shared_ptr<IntegerArray> intarray = db->getIntegerArray ("intarray");
      std::cerr << (std::string) ( (*intarray)) << std::endl;
      
      /*intarray->pushBack(42);
      std::cerr << (std::string)(*intarray.get()) << std::endl;*/
    }
    
    {
      shared_ptr<DataBox> db = DataFactory::buildDataBox ("double-array-dynamic");
      shared_ptr<DoubleArray> doublearray = db->getDoubleArray ("doublearray");
      std::cerr << (std::string) ( (*doublearray)) << std::endl;
      
      doublearray->pushBack (3.14);
      std::cerr << (std::string) ( (*doublearray)) << std::endl;
    }
    
    {
      shared_ptr<DataBox> db = DataFactory::buildDataBox ("double-array-static");
      shared_ptr<DoubleArray> doublearray = db->getDoubleArray ("doublearray");
      std::cerr << (std::string) ( (*doublearray)) << std::endl;
      
      /*doublearray->pushBack(3.14);
      std::cerr << (std::string)(*doublearray.get()) << std::endl;*/
    }
    
    {
      shared_ptr<DataBox> db = DataFactory::buildDataBox ("string-array-dynamic");
      shared_ptr<StringArray> stringarray = db->getStringArray ("stringarray");
      std::cerr << (std::string) ( (*stringarray)) << std::endl;
      
      stringarray->pushBack ("Hello MeRMaID");
      std::cerr << (std::string) ( (*stringarray)) << std::endl;
    }
    
    {
      shared_ptr<DataBox> db = DataFactory::buildDataBox ("string-array-static");
      shared_ptr<StringArray> stringarray = db->getStringArray ("stringarray");
      std::cerr << (std::string) ( (*stringarray)) << std::endl;
      
      //stringarray->pushBack("Hello MeRMaID");
      //std::cerr << (std::string)(*stringarray.get()) << std::endl;
    }
    
    {
      std::cerr << "Building \"complex-data\"" << std::endl;
      shared_ptr<DataBox> db1 = DataFactory::buildDataBox ("complex-data");
//             db1->print();
      shared_ptr<DataBox> boxX = db1->getDataBox ("x");
      shared_ptr<DataBox> boxY = db1->getDataBox ("y");
      
      boxX->setInteger ("a", 1);
      boxY->setInteger ("a", 2);
      
      if (boxX->getInteger ("a") != 1) {
        cout << "ERROR: expected boxX.a to be 1, instead it is " << boxX->getInteger ("a") << endl;
        errorOccured = true;
      }
    }
    
  }
  catch (Exception &exception) {
    cout << "ERROR:";
    cout << "\t" << exception.what() << endl;
    errorOccured = true;
  }
  catch (...) {
    cout << "How the hell did I end up here?!" << endl;
    errorOccured = true;
  }
  
  if (errorOccured) {
    std::cerr << "ERROR occured" << std::endl;
    return (1);
  }
  else {
    std::cerr << "All went well." << std::endl;
    return (0);
  }
};