testAugerUnitParser.cc

Go to the documentation of this file.

#include <cppunit/extensions/HelperMacros.h>

#include <boost/assign/std/vector.hpp>
#include <boost/assign/list_of.hpp>

#include <tst/Verify.h>
#include <utl/UnitGrammar.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <utl/SymbolTable.h>

#include <map>
#include <string>
#include <iostream>

using std::map;
using std::vector;
using std::string;
using namespace utl;
using namespace tst;
using namespace boost::assign;


#define ASSERT_CLOSE(x, y) CPPUNIT_ASSERT(Verify<CloseTo>(x, y))
#define ASSERT_NOTCLOSE(x, y) CPPUNIT_ASSERT(Verify<Not<CloseTo> >(x, y))





class AugerUnitParserTest : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(AugerUnitParserTest);
  CPPUNIT_TEST(testParsing);
  CPPUNIT_TEST(testFailure);
  CPPUNIT_TEST_SUITE_END();

public:
  void
  setUp()
  {
    ErrorLogger::GetInstance().SetVerbosity(Verbosity::eAnnoying);
  }

  void
  tearDown() { }


  void
  testParsing()
  {
    const map<string, double> expressionValue =
      map_list_of
      ("1000*pascal", 1000*pascal)
      ("100*pascal", 100*pascal)
      ("1.5*meter", 1.5*meter)
      ("1/(cm2*s*sr*GeV)", 1/(cm2*s*sr*GeV))
      ("1/(cm^2*s*sr*MeV)", 1/(pow(cm,2)*s*sr*MeV))
      ("1/(cm2*s*steradian)", 1/(cm2*s*steradian))
      ("1e-6*sr", 1e-6*sr)
      ("1/m", 1/m)
      ("1/(m2*s*sr*GeV)", 1/(m2*s*sr*GeV))
      ("1/meter", 1/meter)
      ("1/MeV", 1/MeV)
      ("1/m/m/deg/deg/microsecond", 1/m/m/deg/deg/microsecond)
      ("(2.0^2.0)^(2.0^2.0)", pow(pow(2.0,2.0),pow(2.0,2.0)))
      ("ampere", ampere)
      ("candela", candela)
      ("cm", cm)
      ("deg", deg)
      ("degree", degree)
      ("EeV", EeV)
      ("eV", eV)
      ("g/cm/cm", g/cm/cm)
      ("g/cm/cm/cm", g/cm/cm/cm)
      ("GeV", GeV)
      ("GeV/m", GeV/m)
      ("hertz", hertz)
      ("Hz", Hz)
      ("joule", joule)
      ("kelvin", kelvin)
      ("kg", kg)
      ("kHz", kHz)
      ("kilometer", kilometer)
      ("kilometer/hour", kilometer/hour)
      ("km", km)
      ("m", m)
      ("m2/kg", m2/kg)
      ("m3/(kg*kelvin^0.5)", m3/(kg*sqrt(kelvin)))
      ("megahertz", megahertz)
      ("meter", meter)
      ("meter*(3^0.5)/2", meter*(sqrt(3))/2)
      ("meter/second", meter/second)
      ("MeV", MeV)
      ("MHz", MHz)
      ("microsecond", microsecond)
      ("mm", mm)
      ("m*m*deg*deg", m*m*deg*deg)
      ("ms", ms)
      ("nanometer", nanometer)
      ("nanosecond", nanosecond)
      ("ns", ns)
      ("perCent", perCent)
      ("radian", radian)
      ("s", s)
      ("sr*km2", sr*km2)
      ("V", V)
      ("volt", volt)
      ("s*GeV", s*GeV)
      ("s*TeV", s*TeV)
      ("km * m * m", km * m * m)
      ("(km) * m * m", (km) * m * m)
      ("(km * m) * m", (km * m) * m)
      ("(km * m * m)", (km * m * m))
      ("km/kg", km/kg)
      ("km / kg", km/kg)
      ("km / kg", km/kg)
      ("g/(cm*cm*cm)", g/(cm*cm*cm))
      ("g/(cm2*cm)", g/(cm2*cm))
      ("g/cm3", g/cm3)
      ("kilo", kilo)
      ("nano*meter", nanometer)
      ("milli*meter", milli*meter)
      ("kilo*meter", kilometer)
      ;

    //utl::AugerUnitParser& up = utl::AugerUnitParser::GetInstance();
    utl::AugerUnitParser up;

    for (map<string, double>::const_iterator it = expressionValue.begin(), end = expressionValue.end();
         it != end; ++it)
      ASSERT_CLOSE(up.Evaluate(it->first), it->second);
  }

  void
  testFailure()
  {
    vector<string> expressions;
    expressions +=
      "1/cm2*s*sr*MeV)",
      "1/(cm2*s*sr*OMG)",
      "1-(cm2*s*sr*MeV)",
      "R",
      "d",
      "z",
      "q",
      "Q",
      "megadong",
      "OMG/m",
      "cm2/OMG/WTF/m/m";

    //utl::AugerUnitParser& up = utl::AugerUnitParser::GetInstance();
    utl::AugerUnitParser up;

    for (vector<string>::const_iterator it = expressions.begin(), end = expressions.end();
         it != end; ++it) {
      bool throws = false;
      try {
        up.Evaluate(*it);
      } catch (XMLParseException& ex) {
        throws = true;
      }
      Expected();
      CPPUNIT_ASSERT(throws);
    }
  }

};


CPPUNIT_TEST_SUITE_REGISTRATION(AugerUnitParserTest);