Changes in src/Parser/unittests/ParserMpqcUnitTest.cpp [120a86:3bdb6d]

File:

• src/Parser/unittests/ParserMpqcUnitTest.cpp (modified) (11 diffs)

src/Parser/unittests/ParserMpqcUnitTest.cpp

@@ -28 +28 @@
 #include "World.hpp"
 #include "atom.hpp"
-#include "element.hpp"
-#include "periodentafel.hpp"
+#include "Element/element.hpp"
+#include "Element/periodentafel.hpp"
 #include "Descriptors/AtomTypeDescriptor.hpp"
 #include "CodePatterns/Assert.hpp"
-#include "Parser/ChangeTracker.hpp"
-#include "Parser/MpqcParser.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -158 +156 @@
 )\n"; // basically tested with mpqc 3.0.0-alpha (no parse errors but did not calculate due to missing code)
 
-void ParserMpqcUnitTest::setUp() 
-{
-  // failing asserts should be thrown
-  ASSERT_DO(Assert::Throw);
-
-  parser = new FormatParser<mpqc>();
+void ParserMpqcUnitTest::setUp() {
+  mpqc = new MpqcParser();
 
   World::getInstance();
@@ -174 +168 @@
 }
 
-void ParserMpqcUnitTest::tearDown() 
-{
-  delete parser;
+void ParserMpqcUnitTest::tearDown() {
+  delete mpqc;
   ChangeTracker::purgeInstance();
   World::purgeInstance();
@@ -183 +176 @@
 /************************************ tests ***********************************/
 
+void ParserMpqcUnitTest::ParameterTypeTest() {
+  // check types in boost::any map
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::hessianParam].type() == typeid(bool));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::hessianParam].type() != typeid(int));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::savestateParam].type() == typeid(bool));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::do_gradientParam].type() == typeid(bool));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::maxiterParam].type() == typeid(int));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::memoryParam].type() == typeid(int));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::stdapproxParam].type() == typeid(std::string));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::nfzcParam].type() == typeid(int));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::basisParam].type() == typeid(std::string));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::aux_basisParam].type() == typeid(std::string));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::integrationParam].type() == typeid(MpqcParser_Parameters::IntegralCints));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::theoryParam].type() == typeid(MpqcParser_Parameters::MBPT2));
+}
+
 void ParserMpqcUnitTest::ParameterDefaultTest() {
   // check default values
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::hessianParam) == std::string("no"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::savestateParam) == std::string("no"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::do_gradientParam) == std::string("yes"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::maxiterParam) == std::string("1000"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::memoryParam) == std::string("16000000"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::stdapproxParam) == std::string("A'"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::nfzcParam) == std::string("1"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::basisParam) == std::string("3-21G"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::aux_basisParam) == std::string("aug-cc-pVDZ"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::integrationParam) == std::string("IntegralCints"));
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("MBPT2"));
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) == "no");
+  CPPUNIT_ASSERT(!mpqc->getParams().getBool(MpqcParser_Parameters::hessianParam));
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::savestateParam) == "no");
+  CPPUNIT_ASSERT(!mpqc->getParams().getBool(MpqcParser_Parameters::savestateParam));
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::do_gradientParam) == "yes");
+  CPPUNIT_ASSERT(mpqc->getParams().getBool(MpqcParser_Parameters::do_gradientParam));
+  CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::maxiterParam) == 1000);
+  CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::memoryParam) == 16000000);
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::stdapproxParam) == "A'");
+  CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::nfzcParam) == 1);
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::basisParam) == "3-21G");
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::aux_basisParam) == "aug-cc-pVDZ");
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::integrationParam) == "IntegralCints");
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
+  CPPUNIT_ASSERT(mpqc->getParams().getTheory() == MpqcParser_Parameters::MBPT2);
+  CPPUNIT_ASSERT(mpqc->getParams().getIntegration() == MpqcParser_Parameters::IntegralCints);
+
+  // check that values are not removed
+  CPPUNIT_ASSERT(!mpqc->getParams().params[MpqcParser_Parameters::theoryParam].empty());
+
+  // check throw, for the moment aren't, are caught in getInt()
+  CPPUNIT_ASSERT_THROW(mpqc->getParams().getInt(MpqcParser_Parameters::integrationParam), boost::bad_any_cast);
+  CPPUNIT_ASSERT_THROW(mpqc->getParams().getInt(MpqcParser_Parameters::theoryParam), boost::bad_any_cast);
+
 }
 
 void ParserMpqcUnitTest::ParameterCloneTest() {
-  FormatParser_Parameters *clone = parser->getParams().clone();
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("MBPT2"));
+  FormatParser_Parameters *clone = mpqc->getParams().clone();
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
   std::stringstream setvalue("theory = CLHF");
-  setvalue >> parser->getParams();
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("CLHF"));
-  parser->getParams().makeClone(*clone);
-  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("MBPT2"));
+  setvalue >> mpqc->getParams();
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "CLHF");
+  mpqc->getParams().makeClone(*clone);
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
 }
 
@@ -212 +234 @@
   {
     std::stringstream setvalue("theory = CLHF");
-    setvalue >> parser->getParams();
+    setvalue >> mpqc->getParams();
 //    std::cout << "integration method is "
-//        << parser->getParams().getString(MpqcParser_Parameters::theoryParam) << std::endl;
-    CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("CLHF"));
+//        << mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) << std::endl;
+    CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "CLHF");
   }
   // test a bool
   {
     std::stringstream setvalue("Hessian = yes");
-    setvalue >> parser->getParams();
+    setvalue >> mpqc->getParams();
 //    std::cout << "Hessian is "
-//        << parser->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
-    CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::hessianParam) == std::string("yes"));
+//        << mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
+    CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) == "yes");
   }
   // test int
   {
     std::stringstream setvalue("maxiter = 500");
-    setvalue >> parser->getParams();
+    setvalue >> mpqc->getParams();
 //    std::cout << "maxiter is "
-//        << parser->getParams().getString(MpqcParser_Parameters::maxiterParam) << std::endl;
-    CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::maxiterParam) == std::string("500"));
+//        << mpqc->getParams().getString(MpqcParser_Parameters::maxiterParam) << std::endl;
+    CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::maxiterParam) == 500);
   }
   // test whether unknown key fails
@@ -239 +261 @@
 #ifndef NDEBUG
     ASSERT_DO(Assert::Throw);
-    CPPUNIT_ASSERT_THROW(setvalue >> parser->getParams(), Assert::AssertionFailure);
+    CPPUNIT_ASSERT_THROW(setvalue >> mpqc->getParams(), Assert::AssertionFailure);
 #else
-    setvalue >> parser->getParams();
+    setvalue >> mpqc->getParams();
 #endif
 //    std::cout << "Hessian is still "
-//        << parser->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
-    CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::hessianParam) == std::string("yes"));
+//        << mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
+    CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) == "yes");
   }
 }
@@ -251 +273 @@
 void ParserMpqcUnitTest::readMpqcTest() {
   stringstream input(waterMpqc_CLHF);
-  parser->getParams().setParameter(
-      MpqcParser_Parameters::theoryParam,
-      parser->getParams().getTheoryName(MpqcParser_Parameters::CLHF)
-          );
-  parser->load(&input);
+  mpqc->getParams().setTheory(MpqcParser_Parameters::CLHF);
+  mpqc->load(&input);
 
   CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
@@ -282 +301 @@
     // compare both configs for CLHF
     stringstream output;
-    parser->getParams().setParameter(
-        MpqcParser_Parameters::theoryParam,
-        parser->getParams().getTheoryName(MpqcParser_Parameters::CLHF)
-            );
-    parser->save(&output, atoms);
+    mpqc->getParams().setTheory(MpqcParser_Parameters::CLHF);
+    mpqc->save(&output, atoms);
     stringstream input(waterMpqc_CLHF);
-    // check for non-empty streams
-    input.peek();
-    output.peek();
-    CPPUNIT_ASSERT(input.good() && output.good());
-    // check equality of streams per line (for debugging)
     for (; std::getline(input, first) && std::getline(output, second); ) {
       //std::cout << "Comparing '" << first << "' to '" << second << "'" << std::endl;
@@ -301 +312 @@
     // compare both configs for CLKS
     stringstream output;
-    parser->getParams().setParameter(
-        MpqcParser_Parameters::theoryParam,
-        parser->getParams().getTheoryName(MpqcParser_Parameters::CLKS)
-            );
-    parser->save(&output, atoms);
+    mpqc->getParams().setTheory(MpqcParser_Parameters::CLKS);
+    mpqc->save(&output, atoms);
     stringstream input(waterMpqc_CLKS);
-    // check for non-empty streams
-    input.peek();
-    output.peek();
-    CPPUNIT_ASSERT(input.good() && output.good());
-    // check equality of streams per line (for debugging)
     for (; std::getline(input, first) && std::getline(output, second); ) {
       //std::cout << "Comparing '" << first << "' to '" << second << "'" << std::endl;
@@ -320 +323 @@
     // compare both configs for MBPT2
     stringstream output;
-    parser->getParams().setParameter(
-        MpqcParser_Parameters::theoryParam,
-        parser->getParams().getTheoryName(MpqcParser_Parameters::MBPT2)
-            );
-    parser->save(&output, atoms);
+    mpqc->getParams().setTheory(MpqcParser_Parameters::MBPT2);
+    mpqc->save(&output, atoms);
     stringstream input(waterMpqc_MBPT2);
-    // check for non-empty streams
-    input.peek();
-    output.peek();
-    CPPUNIT_ASSERT(input.good() && output.good());
-    // check equality of streams per line (for debugging)
     for (; std::getline(input, first) && std::getline(output, second); ) {
       //std::cout << "Comparing '" << first << "' to '" << second << "'" << std::endl;
@@ -339 +334 @@
     // compare both configs for MBPT2_R12
     stringstream output;
-    parser->getParams().setParameter(
-        MpqcParser_Parameters::theoryParam,
-        parser->getParams().getTheoryName(MpqcParser_Parameters::MBPT2_R12)
-            );
-    parser->save(&output, atoms);
+    mpqc->getParams().setTheory(MpqcParser_Parameters::MBPT2_R12);
+    mpqc->save(&output, atoms);
     stringstream input(waterMpqc_MBPT2_R12);
-    // check for non-empty streams
-    input.peek();
-    output.peek();
-    CPPUNIT_ASSERT(input.good() && output.good());
-    // check equality of streams per line (for debugging)
     for (; std::getline(input, first) && std::getline(output, second); ) {
       //std::cout << "Comparing '" << first << "' to '" << second << "'" << std::endl;