testReader.cc

Go to the documentation of this file.

#include <cppunit/extensions/HelperMacros.h>

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <cmath>
#include <boost/lexical_cast.hpp>
#include <utl/Reader.h>
#include <utl/ReaderErrorReporter.h>
#include <utl/AugerUnits.h>
#include <utl/TimeStamp.h>
#include <utl/TabulatedFunction.h>
#include <utl/Function.h>
#include <utl/UTCDateTime.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <tst/Verify.h>

using namespace std;
using namespace utl;
using namespace tst;
using namespace xercesc;


#define ASSERT_EQUAL(x, y) CPPUNIT_ASSERT(Verify<Equal>(x, y))
#define ASSERT_NOTEQUAL(x, y) CPPUNIT_ASSERT(Verify<Not<Equal> >(x, y))
#define ASSERT_CLOSE(x, y) CPPUNIT_ASSERT(Verify<CloseTo>(x, y))
#define ASSERT_CLOSEEPS(x, y, eps) CPPUNIT_ASSERT(Verify<CloseTo>(x, y, eps))


class ReaderTest : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(ReaderTest);
  CPPUNIT_TEST(testHierarchy);
  CPPUNIT_TEST(testAttributes);
  CPPUNIT_TEST(testCastings);
  CPPUNIT_TEST(testStringParse);
  CPPUNIT_TEST(testXMLTime);
  CPPUNIT_TEST(testEmpties);
  CPPUNIT_TEST(testOperators);
  CPPUNIT_TEST(testEmptyReader);
  CPPUNIT_TEST(testWarning);
  CPPUNIT_TEST(testEvaluatorUnits);
  //CPPUNIT_TEST(testXMLEntityResolver);
  CPPUNIT_TEST(testTabulatedFunction);
  CPPUNIT_TEST(testFunction);
  CPPUNIT_TEST_SUITE_END();

private:
  utl::Reader* fReader;
  utl::Reader* fSchemaReader;

public:
  void
  setUp()
  {
    ErrorLogger::GetInstance().SetVerbosity(Verbosity::eAnnoying);
    fReader = new Reader(XMLFILE, Reader::eDTD);
    fSchemaReader = new Reader(XMLSCHEMAFILE, Reader::eSCHEMA);
  }

  void
  tearDown()
  {
    delete fReader;
    delete fSchemaReader;
  }

  void
  testAttributes()
  {
    //Attributes
    Branch attB = fReader->GetTopBranch().GetChild("attributeTest");

    // Find the Branch with a certain set of attributes
    AttributeMap attMap;
    attMap["firstName"] = "Jim";
    attMap["lastName"]  = "Cronin";
    string responsibility;
    attB.GetChild("collaborator", attMap).GetChild("responsibility").GetData(responsibility);
    ASSERT_EQUAL(responsibility, string("Spokesperson Emeritus"));
    // alternatively
    attB.GetChild("collaborator",
                  "firstName=Jim lastName=Cronin").GetChild("responsibility").GetData(responsibility);
    ASSERT_EQUAL(responsibility, string("Spokesperson Emeritus"));

    // Get the attributes belonging to a Branch
    AttributeMap theAttributes = attB.GetFirstChild().GetAttributes();

    ASSERT_EQUAL(theAttributes.size(), size_t(2));
    ASSERT_EQUAL(theAttributes["firstName"], string("Alan"));
    ASSERT_EQUAL(theAttributes["lastName"], string("Watson"));

    // Note that the "unit" and "variables" attributes are treated as a special case.
    // Unit and variable attributes
    // which appear either in the attribute map you pass to the GetChild method, or
    // in the XML file, will be ignored for purposes of finding the requested Branch.
    // The unit attribute will, however, still be used by the GetData method to
    // convert the requested quantity into the base units.  Here is an example:
    //
    AttributeMap apertureAttributes;
    apertureAttributes["site"] = "Malargue";
    double aperture;
    attB.GetChild("aperture", apertureAttributes).GetData(aperture);
    ASSERT_EQUAL(aperture, 7000*sr*km2);
    // alternatively
    attB.GetChild("aperture", "site=Malargue").GetData(aperture);
    ASSERT_EQUAL(aperture, 7000*sr*km2);

    double flux;
    Branch fluxBranch = attB.GetChild("flux");
    fluxBranch.GetData(flux);
    ASSERT_CLOSEEPS(flux, 1e-3/(cm2*s*sr*GeV), 1e-8/(cm2*s*sr*GeV));

    fluxBranch = fluxBranch.GetNextSibling();
    fluxBranch.GetData(flux);
    ASSERT_CLOSEEPS(flux, 1e-3/(m2*s*sr*GeV), 1e-8/(m2*s*sr*GeV));

    fluxBranch = fluxBranch.GetNextSibling();
    fluxBranch.GetData(flux);
    ASSERT_CLOSEEPS(flux, 1e-3/(cm2*s*sr*MeV), 1e-8/(cm2*s*sr*MeV));

    fluxBranch = fluxBranch.GetNextSibling();
    bool caught = false;
    try {
      fluxBranch.GetData(flux);
    } catch (XMLParseException& e) {
      //Minus error here!
      const std::string s = e.GetMessage();;
      caught = true;
    }
    CPPUNIT_ASSERT(caught);

    fluxBranch = fluxBranch.GetNextSibling();
    caught = false;
    try {
      fluxBranch.GetData(flux);
    } catch (XMLParseException& e) {
      //Unknown symbol here!
      const std::string s = e.GetMessage();;
      caught = true;
    }
    CPPUNIT_ASSERT(caught);


    fluxBranch = fluxBranch.GetNextSibling();
    caught = false;
    try {
      fluxBranch.GetData(flux);
    } catch (XMLParseException& e) {
      //Bracket problem here!
      const std::string s = e.GetMessage();;
      caught = true;
    }
    CPPUNIT_ASSERT(caught);

    fluxBranch = fluxBranch.GetNextSibling();
    fluxBranch.GetData(flux);
    ASSERT_CLOSE(flux, 256.0); //(2.0^2.0)^(2^2) = 256.0

  }

  void
  testStringParse()
  {
    // Parsing a string in memory

    ostringstream trimStream;
    trimStream << "first line        \t     \n"
                  "      1 2 3 foo bar";
    ostringstream inpStream;
    inpStream << "<AtmosphereFuncList>\n"
                 "   <!-- some stupid comment --> \n"
                 "   <attenuationFunc> <!-- comment --> myAttenFunc </attenuationFunc> \n"
                 "   <scatteringFunc>  DefaultScattering </scatteringFunc>  "
                 "   <trimming>   \t                                        "
                 "   \t   " << trimStream.str() << "   \t  \n  \r           "
                 "   </trimming>                                            "
                 "   <qualityFunc>     DefaultQuality    </qualityFunc>     "
                 "</AtmosphereFuncList>";

    ReaderStringInput readerInput(inpStream);
    Reader theReaderFromMem(readerInput);  // construct from ReaderStringInput

    Branch memTopB = theReaderFromMem.GetTopBranch();

    ASSERT_EQUAL(memTopB.GetName(), string("AtmosphereFuncList"));
    ASSERT_EQUAL(memTopB.GetFirstChild().GetName(), string("attenuationFunc"));
    ASSERT_EQUAL(memTopB.GetFirstChild().GetNextSibling().GetName(), string("scatteringFunc"));

    string data;
    memTopB.GetFirstChild().GetData(data);
    ASSERT_EQUAL(data, string("myAttenFunc"));
    memTopB.GetFirstChild().GetNextSibling().GetData(data);
    ASSERT_EQUAL(data, string("DefaultScattering"));
    memTopB.GetChild("qualityFunc").GetData(data);
    ASSERT_EQUAL(data, string("DefaultQuality"));

    // new way
    CPPUNIT_ASSERT(!memTopB.GetChild("qualityFunc").GetNextSibling());

    memTopB.GetChild("trimming").GetData(data);
    ASSERT_EQUAL(data, trimStream.str());
  }

  void
  testHierarchy()
  {
    CPPUNIT_ASSERT(fReader->GetTopBranch());
    CPPUNIT_ASSERT(!fReader->GetTopBranch().GetParent());
    CPPUNIT_ASSERT(fReader->GetTopBranch().GetFirstChild().GetParent() == fReader->GetTopBranch());
    ASSERT_EQUAL(fReader->GetTopBranch().GetName(), string("document"));

    Branch hierarchyB = fReader->GetTopBranch().GetChild("hierarchyTest");

    int i = 0;
    for (Branch child = hierarchyB.GetChild("parent1").GetFirstChild();
         child; child = child.GetNextSibling()) {
      ++i;
      ASSERT_EQUAL(child.GetName(), string("child"));
      ASSERT_EQUAL(boost::lexical_cast<int>(child.GetAttributes()["id"]), i);
    }
    ASSERT_EQUAL(i, 3);

    // sugar coated version down and up the tree
    i = 0;
    Branch last;
    for (Branch sib = hierarchyB.GetChild("parent1").GetFirstChild();
         sib; ++sib) {
      ++i;
      ASSERT_EQUAL(sib.GetName(), string("child"));
      ASSERT_EQUAL(boost::lexical_cast<int>(sib.GetAttributes()["id"]), i);
      last = sib;
    }
    ASSERT_EQUAL(i, 3);

    for (Branch sib = last ; sib ; --sib) {
      ASSERT_EQUAL(sib.GetName(), string("child"));
      ASSERT_EQUAL(boost::lexical_cast<int>(sib.GetAttributes()["id"]), i);
      --i;
    }
    ASSERT_EQUAL(i, 0);

    ASSERT_EQUAL(
      hierarchyB.GetChild("parent1").GetChild("child", "id=3").
      GetFirstChild().GetName(), string("grandChild")
    );

    CPPUNIT_ASSERT(!hierarchyB.GetChild("parent2").GetFirstChild());
  }

  void
  testCastings()
  {
    string dataString;
    fReader->GetTopBranch().GetChild("castingTest").GetChild("list").GetData(dataString);
    ASSERT_EQUAL(dataString, string("2.14  2.16  2.19  2.23  2.27  2.32"));

    list<double> myList;
    myList.push_back(2.14*mm);
    myList.push_back(2.16*mm);
    myList.push_back(2.19*mm);
    myList.push_back(2.23*mm);
    myList.push_back(2.27*mm);
    myList.push_back(2.32*mm);

    list<double> dataList;
    fReader->GetTopBranch().GetChild("castingTest").GetChild("list").GetData(dataList);

    CPPUNIT_ASSERT(dataList == myList);
  }

  void
  testXMLTime()
  {
    string time = "1982-05-12T01:23:43.56789Z";
    UTCDateTime utc = boost::lexical_cast<UTCDateTime>(time);
    ASSERT_EQUAL(utc.GetYear(), 1982);
    ASSERT_EQUAL(utc.GetMonth(), 5);
    ASSERT_EQUAL(utc.GetDay(), 12);
    ASSERT_EQUAL(utc.GetHour(), 1);
    ASSERT_EQUAL(utc.GetMinute(), 23);
    ASSERT_EQUAL(utc.GetSecond(), 43);
    ASSERT_EQUAL(utc.GetNanosecond(), 1000000000*0.56789);

    vector<TimeStamp> tv;
    fReader->GetTopBranch().GetChild("timeTest").GetData(tv);
    ASSERT_EQUAL(tv.size(), size_t(5));

    cout << endl;
    const double ns[] = { 0, 1, 1500, 94, 1370000 };
    for (int i = 0; i < 5; ++i) {
      const UTCDateTime utc(tv[i]);
      cout << tv[i] << "   " << utc << endl;
      ASSERT_EQUAL(utc.GetYear(), 2002);
      ASSERT_EQUAL(utc.GetMonth(), 5);
      ASSERT_EQUAL(utc.GetDay(), 12);
      ASSERT_EQUAL(utc.GetHour(), i);
      ASSERT_EQUAL(utc.GetMinute(), 23);
      ASSERT_EQUAL(utc.GetSecond(), 45);
      ASSERT_EQUAL(tv[i].GetGPSNanoSecond(), ns[i]);
      ASSERT_EQUAL(utc.GetNanosecond(), ns[i]);
    }
  }

  void
  testEmpties()
  {
    Branch empty1 = fReader->GetTopBranch().GetChild("emptyTests").GetChild("emptyElement1");
    string emptyString1;
    empty1.GetData(emptyString1);
    ASSERT_EQUAL(emptyString1, string(""));

    Branch empty2 = fReader->GetTopBranch().GetChild("emptyTests").GetChild("emptyElement2");
    string emptyString2;
    empty2.GetData(emptyString2);
    ASSERT_EQUAL(emptyString2, string(""));
  }

  void
  testOperators()
  {
    Branch b1 = fReader->GetTopBranch().GetChild("hierarchyTest");
    Branch b2 = fReader->GetTopBranch().GetChild("hierarchyTest");
    Branch b3 = fReader->GetTopBranch().GetChild("castingTest");

    CPPUNIT_ASSERT(b1 == b2);
    CPPUNIT_ASSERT(b2 != b3);
  }

  void
  testEmptyReader()
  {
    Branch branch;
    Reader r(branch);
  }

  void
  testWarning()
  {
    Branch b = fReader->GetTopBranch();
    Branch nobody = b.GetChild("nobody");
    Branch noone = b.GetChild("noone");
    // The error given when it crashes should be the one that actually made it crash!
    bool caught = false;
    try {
      Branch crash_1 = nobody.GetFirstChild();
    } catch (XMLParseException& e) {
      const std::string s = e.GetMessage();
      CPPUNIT_ASSERT(s.find("noone") == std::string::npos);
      CPPUNIT_ASSERT(s.find("nobody") != std::string::npos);
      caught = true;
    }
    CPPUNIT_ASSERT(caught);
    //TODO, tests: GetFirstChild().GetFirstChild() GetChild().GetFirstChild()
    //             GetSibling().GetFirstChild() Clone().GetFirstChild()
  }

  void
  testEvaluatorUnits()
  {
    // Test that units are set up correctly in the AugerUnitParser

    Branch evalB = fReader->GetTopBranch().GetChild("evaluatorUnitsTest");

    double length;
    evalB.GetChild("length").GetData(length);
    ASSERT_CLOSE(length, 1.0*meter);

    double mass;
    evalB.GetChild("mass").GetData(mass);
    ASSERT_CLOSE(mass, 1.0*kilogram);

    double time;
    evalB.GetChild("time").GetData(time);
    ASSERT_CLOSE(time, 1.0*second);

    double current;
    evalB.GetChild("current").GetData(current);
    ASSERT_CLOSE(current, 1.0*ampere);

    double temperature;
    evalB.GetChild("temperature").GetData(temperature);
    ASSERT_CLOSE(temperature, 1.0*kelvin);

    double lumi;
    evalB.GetChild("lumi").GetData(lumi);
    ASSERT_CLOSE(lumi, 1.0*candela);
  }

  void
  testTabulatedFunction()
  {
    Branch b = fReader->GetTopBranch().GetChild("tabulatedFunctionTest");
    const TabulatedFunction tf = b.GetChild("foo").Get<TabulatedFunction>();
    for (unsigned int i = 0, n = tf.GetNPoints(); i < n; ++i) {
      const Pair p = tf[i];
      ASSERT_CLOSE(p.X(), p.Y());
    }
  }

  void
  testFunction()
  {
    std::cout << "testFunction" << std::endl;
    const utl::Function func1 = fReader->GetTopBranch().GetChild("functionTest1").Get<Function>();
    const utl::Function func2 = fReader->GetTopBranch().GetChild("functionTest2").Get<Function>();    
    
    double E = 1e18;
    ASSERT_CLOSE(func1(E), 15 + log10(E/PeV)*10);

    
    std::cout << func2.GetFunction() << std::endl;
    utl::SymbolTable st = func2.GetVariables() ;
    for (const auto& v : st) {
      std::cout << v.first << " " << v.second << std::endl;      
    }
    
    E = 1e17;
    double slope = 1.5;
    
    bool caught = false;
    try {
      func2(E);
    } catch (XMLParseException& e) {
      // wrong number of arguments here!
      const std::string s = e.GetMessage();;
      caught = true;
    }
    CPPUNIT_ASSERT(caught);

    ASSERT_CLOSE(func2({E, slope}), log10(pow((E/eV),(-slope))) + log10(E/PeV)*10);
  }
  
};


CPPUNIT_TEST_SUITE_REGISTRATION(ReaderTest);