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_*/