OsiUnitTests.hpp

Go to the documentation of this file.

// Copyright (C) 2010
// All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef OSISOLVERINTERFACETEST_HPP_
#define OSISOLVERINTERFACETEST_HPP_
 
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <list>
#include <map>
 
class OsiSolverInterface;
class CoinPackedVectorBase;
 
void OsiSolverInterfaceMpsUnitTest(const std::vector< OsiSolverInterface * > &vecEmptySiP,
  const std::string &mpsDir);
 
void OsiSolverInterfaceCommonUnitTest(const OsiSolverInterface *emptySi,
  const std::string &mpsDir,
  const std::string &netlibDir);
 
void OsiColCutUnitTest(const OsiSolverInterface *baseSiP,
  const std::string &mpsDir);
 
void OsiRowCutUnitTest(const OsiSolverInterface *baseSiP,
  const std::string &mpsDir);
 
void OsiRowCutDebuggerUnitTest(const OsiSolverInterface *siP,
  const std::string &mpsDir);
 
void OsiCutsUnitTest();
 
namespace OsiUnitTest {
 
class TestOutcomes;
 
extern unsigned int verbosity;
 
extern unsigned int haltonerror;
 
extern TestOutcomes outcomes;
 
void failureMessage(const std::string &solverName,
  const std::string &message);
void failureMessage(const OsiSolverInterface &si,
  const std::string &message);
 
void failureMessage(const std::string &solverName,
  const std::string &testname, const std::string &testcond);
 
void failureMessage(const OsiSolverInterface &si,
  const std::string &testname, const std::string &testcond);
 
void testingMessage(const char *const msg);
 
bool equivalentVectors(const OsiSolverInterface *si1,
  const OsiSolverInterface *si2,
  double tol, const double *v1, const double *v2, int size);
 
bool compareProblems(OsiSolverInterface *osi1, OsiSolverInterface *osi2);
 
bool isEquivalent(const CoinPackedVectorBase &pv, int n, const double *fv);
 
bool processParameters(int argc, const char **argv,
  std::map< std::string, std::string > &parms,
  const std::map< std::string, int > &ignorekeywords = std::map< std::string, int >());
 
class TestOutcome {
public:
  typedef enum {
    NOTE = 0,
    PASSED = 1,
    WARNING = 2,
    ERROR = 3,
    LAST = 4
  } SeverityLevel;
  static std::string SeverityLevelName[LAST];
  std::string component;
  std::string testname;
  std::string testcond;
  SeverityLevel severity;
  bool expected;
  std::string filename;
  int linenumber;
  TestOutcome(const std::string &comp, const std::string &tst,
    const char *cond, SeverityLevel sev,
    const char *file, int line, bool exp = false)
    : component(comp)
    , testname(tst)
    , testcond(cond)
    , severity(sev)
    , expected(exp)
    , filename(file)
    , linenumber(line)
  {
  }
  void print() const;
};
 
class TestOutcomes : public std::list< TestOutcome > {
public:
  void add(std::string comp, std::string tst, const char *cond,
    TestOutcome::SeverityLevel sev, const char *file, int line,
    bool exp = false)
  {
    push_back(TestOutcome(comp, tst, cond, sev, file, line, exp));
  }
 
  void add(const OsiSolverInterface &si, std::string tst, const char *cond,
    TestOutcome::SeverityLevel sev, const char *file, int line,
    bool exp = false);
  void print() const;
  void getCountBySeverity(TestOutcome::SeverityLevel sev,
    int &total, int &expected) const;
};
 
#define OSIUNITTEST_QUOTEME_(x) #x
#define OSIUNITTEST_QUOTEME(x) OSIUNITTEST_QUOTEME_(x)
 
template < typename Component >
bool OsiUnitTestAssertSeverityExpected(
  bool condition, const char *condition_str, const char *filename,
  int line, const Component &component, const std::string &testname,
  TestOutcome::SeverityLevel severity, bool expected)
{
  if (condition) {
    OsiUnitTest::outcomes.add(component, testname, condition_str,
      OsiUnitTest::TestOutcome::PASSED, filename, line, false);
    if (OsiUnitTest::verbosity >= 2) {
      std::ostringstream successmsg;
      successmsg << __FILE__ << ":" << __LINE__ << ": " << testname
                 << " (condition \'" << condition_str << "\') passed.\n";
      OsiUnitTest::testingMessage(successmsg.str().c_str());
    }
    return true;
  }
  OsiUnitTest::outcomes.add(component, testname, condition_str,
    severity, filename, line, expected);
  OsiUnitTest::failureMessage(component, testname, condition_str);
  switch (OsiUnitTest::haltonerror) {
  case 2: {
    if (severity >= OsiUnitTest::TestOutcome::ERROR)
      std::abort();
    break;
  }
  case 1: {
    std::cout << std::endl
              << "press any key to continue..." << std::endl;
    std::getchar();
    break;
  }
  default:;
  }
  return false;
}
 
#define OSIUNITTEST_ADD_OUTCOME(component, testname, testcondition, severity, expected) \
  OsiUnitTest::outcomes.add(component, testname, testcondition, severity,               \
    __FILE__, __LINE__, expected)
 
#define OSIUNITTEST_ASSERT_SEVERITY_EXPECTED(condition, failurecode, component, \
  testname, severity, expected)                                                 \
  {                                                                             \
    if (!OsiUnitTestAssertSeverityExpected(condition, #condition,               \
          __FILE__, __LINE__, component, testname, severity, expected)) {       \
      failurecode;                                                              \
    }                                                                           \
  }
 
#define OSIUNITTEST_ASSERT_ERROR(condition, failurecode, component, testname)       \
  OSIUNITTEST_ASSERT_SEVERITY_EXPECTED(condition, failurecode, component, testname, \
    OsiUnitTest::TestOutcome::ERROR, false)
 
#define OSIUNITTEST_ASSERT_WARNING(condition, failurecode, component, testname)     \
  OSIUNITTEST_ASSERT_SEVERITY_EXPECTED(condition, failurecode, component, testname, \
    OsiUnitTest::TestOutcome::WARNING, false)
 
#define OSIUNITTEST_CATCH_SEVERITY_EXPECTED(trycode, catchcode, component, testname,    \
  severity, expected)                                                                   \
  {                                                                                     \
    try {                                                                               \
      trycode;                                                                          \
      OSIUNITTEST_ADD_OUTCOME(component, testname, #trycode " did not throw exception", \
        OsiUnitTest::TestOutcome::PASSED, false);                                       \
      if (OsiUnitTest::verbosity >= 2) {                                                \
        std::string successmsg(__FILE__ ":" OSIUNITTEST_QUOTEME(__LINE__) ": ");        \
        successmsg = successmsg + testname;                                             \
        successmsg = successmsg + " (code \'" #trycode "\') did not throw exception";   \
        successmsg = successmsg + ".\n";                                                \
        OsiUnitTest::testingMessage(successmsg.c_str());                                \
      }                                                                                 \
    } catch (CoinError & e) {                                                           \
      std::stringstream errmsg;                                                         \
      errmsg << #trycode " threw CoinError: " << e.message();                           \
      if (e.className().length() > 0)                                                   \
        errmsg << " in " << e.className();                                              \
      if (e.methodName().length() > 0)                                                  \
        errmsg << " in " << e.methodName();                                             \
      if (e.lineNumber() >= 0)                                                          \
        errmsg << " at " << e.fileName() << ":" << e.lineNumber();                      \
      OSIUNITTEST_ADD_OUTCOME(component, testname, errmsg.str().c_str(),                \
        severity, expected);                                                            \
      OsiUnitTest::failureMessage(component, testname, errmsg.str().c_str());           \
      switch (OsiUnitTest::haltonerror) {                                               \
      case 2: {                                                                         \
        if (severity >= OsiUnitTest::TestOutcome::ERROR)                                \
          abort();                                                                      \
        break;                                                                          \
      }                                                                                 \
      case 1: {                                                                         \
        std::cout << std::endl                                                          \
                  << "press any key to continue..." << std::endl;                       \
        getchar();                                                                      \
        break;                                                                          \
      }                                                                                 \
      default:;                                                                         \
      }                                                                                 \
      catchcode;                                                                        \
    } catch (...) {                                                                     \
      std::string errmsg;                                                               \
      errmsg = #trycode;                                                                \
      errmsg = errmsg + " threw unknown exception";                                     \
      OSIUNITTEST_ADD_OUTCOME(component, testname, errmsg.c_str(), severity, false);    \
      OsiUnitTest::failureMessage(component, testname, errmsg.c_str());                 \
      catchcode;                                                                        \
    }                                                                                   \
  }
 
#define OSIUNITTEST_CATCH_ERROR(trycode, catchcode, component, testname) \
  OSIUNITTEST_CATCH_SEVERITY_EXPECTED(trycode, catchcode, component, testname, OsiUnitTest::TestOutcome::ERROR, false)
 
#define OSIUNITTEST_CATCH_WARNING(trycode, catchcode, component, testname) \
  OSIUNITTEST_CATCH_SEVERITY_EXPECTED(trycode, catchcode, component, testname, OsiUnitTest::TestOutcome::WARNING, false)
 
} // end namespace OsiUnitTest
 
#endif /*OSISOLVERINTERFACETEST_HPP_*/
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/