testXml.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 testXml.cpp
 * @Description Tests the Xml framework implementation
 * @Status unknown
 * @Version $Id: testXml.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Nelson Ramos (nmsra@mega.ist.utl.pt)
 */

#include "config.h"

#include <iostream>
using std::cerr;
using std::endl;
#include <string>
using std::string;

#include "XmlDocument.hpp"
#include "XmlElement.hpp"
using namespace mermaid::support::xml;

#include <FilePathSearch.hpp>
using mermaid::support::system::FilePathSearch;





void printChildren (shared_ptr<XmlElement> xmlElement, int tab)
{
  XmlElementVector elements = xmlElement->getChildrenElements();
  
  for (XmlElementVector::iterator it = elements.begin();
       it != elements.end();
       it++) {
    shared_ptr<XmlElement> element = *it;
    
    cerr << string (tab, '\t');
    
    cerr << "ELEMENT Name: " << element->getName();
    
    cerr <<  "\tCharData: ";
    shared_ptr<XmlCharData> c = element->getFirstNonBlankCharData();
    if (c) {
      cerr << "\"" << static_cast<string> (*c) << "\"" << endl;
    }
    else {
      cerr << "NO_CHAR_DATA" << endl;
    }
    
    XmlAttributeVector attributes = element->getAttributes();
    for (XmlAttributeVector::iterator ait = attributes.begin();
         ait != attributes.end();
         ait++) {
      shared_ptr<XmlAttribute> attribute = *ait;
      
      cerr << string (tab, '\t');
      
      cerr << "  ATTRIBUTE name: " << attribute->getName();
      cerr << "\tvalue: \"" << attribute->getValue() << "\"";
      cerr << endl;
    }
    
    printChildren (element, tab + 1);
  }
}



int main (int argc, char * const argv[])
{
  // insert code here...
  
  cerr << "Xml framework test" << endl;
  
  if (argc != 2) {
    cerr << "Usage: testXml [filename]" << endl;
    return (1);
  }
  
  FilePathSearch::addSearchPath ("./");
  FilePathSearch::addSearchPath ("/");
  
  XmlDocument doc;
  cerr << "Reading from file: " << argv[1] << endl;
  doc.parseFile (string (argv[1]), false);
  
  if (doc.isWellFormed()) {
    cerr << "XML is WELL FORMED" << endl;
  }
  else {
    cerr << "XML is NOT WELL FORMED" << endl;
    return (1);
  }
  
  if (doc.isValid()) {
    cerr << "XML is VALID" << endl;
  }
  else {
    cerr << "XML is NOT VALID" << endl;
    return (1);
  }
  
  shared_ptr<XmlElement> rootElement;
  
  cerr << "XML tree:" << endl;
  
  rootElement = doc.getRootElement();
  string rootName = rootElement->getName();
  shared_ptr<XmlCharData> charData = rootElement->getFirstNonBlankCharData();
  string rootCharData;
  if (charData) {
    rootCharData = *charData;
  }
  else {
    rootCharData = "-- NO CHAR DATA --";
  }
  cerr << "\tELEMENT Name: " << rootName;
  cerr << "\tCharData: \"" << rootCharData << "\"";
  cerr << endl;
  
  shared_ptr<XmlElement> rootPtr =
    shared_ptr<XmlElement> (new XmlElement ( (*rootElement)));
  printChildren (rootPtr, 2);
  
  cerr << "Parsed XML:" << endl;
  string rootString = *rootElement;
  cerr << rootString << endl;
  
  XmlElement* copy = new XmlElement (*rootElement);
  string copyString = *copy;
  
  if (rootString.compare (copyString) != 0) {
    cerr << "XmlElement copy doesn't produce the same output string" << endl;
    cerr << "Original was:" << endl;
    cerr << "\t\"" << rootString << "\"" << endl;
    cerr << "Copy was:" << endl;
    cerr << "\t\"" << copyString << "\"" << endl;
    return (1);
  }
  
  delete copy;
  
  // Test for correctly reading CDATA sections
  XmlElementVector children = rootElement->getChildrenElements();
  shared_ptr<XmlElement> d = children.getFirstElementWithName ("d");
  
  if (d == false) {
    cerr << "Unable to read element d" << endl;
    return (1);
  }
  
  shared_ptr<XmlCharData> data = d->getFirstNonBlankCharData();
  
  if ( (data == false)
       || (static_cast<string> (*data).compare ("CDATA") != 0)) {
    cerr << "Unable to read CDATA blocks" << endl;
    return (1);
  }
  
  
  string xml = "<test><a a1=\"123\" a2=\"456\">outer a</a><b><a a1=\"123\" >"
               "</a></b><c>jkl</c><d>mno</d></test>";
               
  cerr << "Reading from string: " << xml << endl;
  doc.parseString (xml);
  
  if (doc.isWellFormed()) {
    cerr << "XML is WELL FORMED" << endl;
  }
  else {
    cerr << "XML is NOT WELL FORMED" << endl;
    return (1);
  }
  
  if (doc.isValid()) {
    cerr << "XML is VALID" << endl;
  }
  else {
    cerr << "XML is NOT VALID" << endl;
    return (1);
  }
  
  cerr << "XML tree:" << endl;
  
  shared_ptr<XmlElement> stringElement = doc.getRootElement();
  string stringElementName = stringElement->getName();
  shared_ptr<XmlCharData> stringElementCharData = stringElement->getFirstNonBlankCharData();
  string stringElementCharDataString;
  if (stringElementCharData) {
    stringElementCharDataString = *stringElementCharData;
  }
  else {
    stringElementCharDataString = "-- NO CHAR DATA --";
  }
  
  cerr << "\tELEMENT Name: " << stringElementName;
  cerr << "\tCharData: \"" << stringElementCharDataString << "\"";
  cerr << endl;
  
  shared_ptr<XmlElement> stringElementPtr =
    shared_ptr<XmlElement> (new XmlElement ( (*stringElement)));
  printChildren (stringElementPtr, 2);
  
  string stringString = *stringElement;
  cerr << stringString << endl;
  
  XmlElement* stringCopy = new XmlElement (*stringElement);
  string stringCopyString = *stringCopy;
  
  if (stringString.compare (stringCopyString) != 0) {
    cerr << "XmlElement copy doesn't produce the same output string" << endl;
    cerr << "Original was:" << endl;
    cerr << stringString << endl;
    cerr << "Copy was:" << endl;
    cerr << stringCopyString << endl;
    return (1);
  }
  
  delete stringCopy;
  
  //****************************************************
  //* XmlCharData tests
  //****************************************************
  
  {
    XmlCharData c = XmlCharData();
    if (c.isBlank() == false) {
      cerr << "XmlCharData::isBlank() should return true "
           "after using default constructor" << endl;
      return (1);
    }
    
    string s = c;
    if (s.compare ("") != 0) {
      cerr << "XmlCharData::operator (string) should return empty "
           "string after using default constructor" << endl;
    }
    
    c.removeEndBlanks();
    s = c;
    if (s.compare ("") != 0) {
      cerr << "XmlCharData::operator (string) should return empty "
           "string after using removeEndBlanks after default constructor"
           << endl;
    }
  }
  
  {
    string init = string ("\t\n\r1 2\t3\n ");
    string noBlank = string ("1 2\t3");
    
    XmlCharData c = XmlCharData (init.c_str());
    
    if (c.isBlank() == true) {
      cerr << "XmlCharData::isBlank() should return false "
           "after using parameterized constructor" << endl;
      return (1);
    }
    
    string s = c;
#if 0
    if (s.compare (init) == 0) {
      cerr << "XmlCharData::operator (string) should not return a string "
           "equal to the one with which it was initialized: blanks should "
           "be removed" << endl;
      return (1);
    }
#endif
    
    c.removeEndBlanks();
    s = c;
    if (s.compare (noBlank) != 0) {
      cerr << "XmlCharData::operator (string) returned an unexpected string "
           "after call to XmlCharData::removeEndBlanks()" << endl;
      return (1);
    }
    
  }
  
  //****************************************************
  //* XmlDocument tests
  //****************************************************
  
  {
    XmlDocument doc;
    doc.parseFile (string (argv[1]));
    
    shared_ptr<XmlElement> n;
    n = doc.getRootElement();
    
  }
  
  //****************************************************
  //* XmlAttribute tests
  //****************************************************
  
  return 0;
}