TestTools.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//----- Included files ---------------------------------------------------------

// 1. Precompiled header

// 2. My own header
#include <xmscore/testing/TestTools.h>

// 3. Standard library headers
#include <fstream>
#include <sstream>

// 4. External library headers
#pragma warning(push)
#pragma warning(disable : 4103) // boost code: alignment change
#include <boost/filesystem.hpp>
#pragma warning(pop)
#include <boost/predef.h>
#include <cxxtest/GlobalFixture.h>
#include <cxxtest/TestSuite.h>

#if BOOST_OS_WINDOWS
#include <Windows.h>
#elif BOOST_OS_LINUX
#include <sys/stat.h>
#include <unistd.h>
#elif BOOST_OS_MACOS
#include <mach-o/dyld.h>
#endif

// 5. Shared code headers
#include <xmscore/misc/XmLog.h>
#include <xmscore/misc/environment.h>
#include <xmscore/points/pt.h>

// 6. Non-shared code headers

namespace xms
{
//----- Constants / Enumerations -----------------------------------------------

//----- Classes / Structs ------------------------------------------------------
namespace
{
class CheckXmLogFixture : public CxxTest::GlobalFixture
{
public:
  bool setUp() override;
  bool tearDown() override;
};

static CheckXmLogFixture fg_checkXmLogFixture;
static bool fg_checkLogForEachTest = false;

//----- Internal functions -----------------------------------------------------

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool CheckXmLogFixture::setUp()
{
  if (fg_checkLogForEachTest)
  {
    xms::ttByPassMessages(1);
    std::string errors = XmLog::Instance().GetAndClearStackStr();
    TS_ASSERT_EQUALS(std::string(), errors);
    return errors == "";
  }
  else
  {
    XmLog::Instance().GetAndClearStackStr();
    return true;
  }
} // CheckXmLogFixture::setUp
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool CheckXmLogFixture::tearDown()
{
  if (fg_checkLogForEachTest)
  {
    xms::ttClearSkippingMessages();
    std::string errors = XmLog::Instance().GetAndClearStackStr();
    TS_ASSERT_EQUALS(std::string(), errors);
    // if expected use TS_ASSERT_STACKED_ERRORS
    return errors == "";
  }
  else
  {
    XmLog::Instance().GetAndClearStackStr();
    return true;
  }
} // CheckXmLogFixture::tearDown

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool iFindTestFile(const std::string& a_filePath)
{
  FILE* fp;
  bool found;
#if BOOST_OS_WINDOWS
  if (fopen_s(&fp, a_filePath.c_str(), "r") || fp == nullptr)
    found = false;
  else
    found = true;
#else
  fp = fopen(a_filePath.c_str(), "r");
  found = fp != NULL;
#endif
  if (fp)
    fclose(fp);
  return found;
} // iFindTestFile

} // namespace

//----- Class / Function definitions -------------------------------------------

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
ETestMessagingState::ETestMessagingState()
: m_skippingMessages(false)
, m_defaultSet(false)
, m_defaultRetValue(0)
{
} // ETestMessagingState::ETestMessagingState
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ETestMessagingState::SetDefault(int a_)
{
  m_defaultSet = true;
  m_defaultRetValue = a_;
} // ETestMessagingState::SetDefault
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ETestMessagingState::ClearDefault()
{
  m_defaultSet = false;
} // ETestMessagingState::ClearDefault
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int ETestMessagingState::GetDefault()
{
  return m_defaultRetValue;
} // ETestMessagingState::GetDefault
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ETestMessagingState::SetSkipping(bool a_)
{
  m_skippingMessages = a_;
} // ETestMessagingState::SetSkipping
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ETestMessagingState::GetSkipping()
{
  return m_skippingMessages;
} // ETestMessagingState::GetSkippin
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ETestMessagingState::DefaultValWasSet()
{
  return m_defaultSet;
} // ETestMessagingState::DefaultValWasSet
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ttByPassMessages(int a_defaultChoice)
{
  ttTestMessagingState().SetDefault(a_defaultChoice);
  ttTestMessagingState().SetSkipping(true);
} // ttByPassMessages
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ttSkippingMessages()
{
  return ttTestMessagingState().GetSkipping();
} // ttSkippingMessages
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int ttByPassDefault()
{
  return ttTestMessagingState().GetDefault();
} // ttByPassDefault
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ttClearSkippingMessages()
{
  ttTestMessagingState().SetSkipping(false);
  ttTestMessagingState().ClearDefault();
} // ttClearSkippingMessages
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
ETestMessagingState& ttTestMessagingState()
{
  static ETestMessagingState m_;
  return m_;
} // ttTestMessagingState
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ttCheckXmLogForEachTest(bool a_setting)
{
  fg_checkLogForEachTest = a_setting;
} // ttSetCheckXmLogForEachTest
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ttCheckXmLogForEachTest()
{
  return fg_checkLogForEachTest;
} // ttCheckXmLogForEachTest
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ttAssertStackedErrors(const char* a_file, int a_line, const std::string& a_expected)
{
  if (ttCheckXmLogForEachTest())
  {
    std::string errors = XmLog::Instance().GetAndClearStackStr();
    _TS_ASSERT_EQUALS(a_file, a_line, a_expected, errors);
  }
} // ttAssertStackedErrors
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ttGetTestFilePaths(const std::string& a_path,
                        const std::string& a_fileBase,
                        const std::string& a_extension,
                        std::string& a_baseFilePath,
                        std::string& a_outFilePath)
{
  bool foundBase = false;
#if BOOST_OS_MACOS
  // see if there is a different base file for mac os x
  if (!foundBase)
  {
    a_baseFilePath = a_path + a_fileBase + "_baseMacOsX" + a_extension;
    foundBase = iFindTestFile(a_baseFilePath);
  }
#elif BOOST_OS_LINUX
  // see if there is a different base file for linux
  if (!foundBase)
  {
    a_baseFilePath = a_path + a_fileBase + "_baseLinux" + a_extension;
    foundBase = iFindTestFile(a_baseFilePath);
  }
#endif

#if defined(ENV64BIT)
  // see if there is a different base file for 64 bit
  if (!foundBase)
  {
    a_baseFilePath = a_path + a_fileBase + "_base64" + a_extension;
    foundBase = iFindTestFile(a_baseFilePath);
  }
#elif defined(ENV32BIT)
    // ensure either ENV32BIT or ENV64BIT is defined
#else
#error "Must define either ENV32BIT or ENV64BIT"
#endif
  if (!foundBase)
    a_baseFilePath = a_path + a_fileBase + "_base" + a_extension;

  a_outFilePath = a_path + a_fileBase + "_out" + a_extension;
} // ttGetTestFilePaths
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ttTextFilesEqual(const std::string& a_file1,
                      const std::string& a_file2,
                      std::string& a_message)
{
  std::ifstream iOut(a_file1), iBase(a_file2);
  std::string lineOut, lineBase;
  int lineCnt(1);
  if (!iOut.is_open() || !iBase.is_open())
  {
    std::stringstream msg;
    msg << "Unable to open file: "
        << "\n";
    if (!iOut.is_open())
    {
      msg << a_file1;
    }
    else
    {
      msg << a_file2;
    }
    a_message = msg.str();
    return false;
  }
  while (!iOut.eof() && !iBase.eof())
  {
    std::getline(iOut, lineOut);
    std::getline(iBase, lineBase);
    // remove trailing \r character on unix os
    lineOut.erase(lineOut.find_last_not_of("\n\r") + 1);
    lineBase.erase(lineBase.find_last_not_of("\n\r") + 1);
    if (lineOut != lineBase)
    {
      std::stringstream msg;
      msg << "Files different on line " << lineCnt << "."
          << "\n"
          << "File: " << a_file1 << "."
          << "\n"
          << lineOut << "\n"
          << "File: " << a_file2 << "."
          << "\n"
          << lineBase << "\n";
      a_message = msg.str();
      return false;
    }
    lineCnt++;
  }
  return true;
} // ttTextFilesEqual
//----- OVERLOAD ---------------------------------------------------------------
//----- OVERLOAD ---------------------------------------------------------------
void ttTextFilesEqual(const std::string& a_srcFile,
                      unsigned a_line,
                      const std::string& a_file1,
                      const std::string& a_file2)
{
  std::string msg;
  if (!ttTextFilesEqual(a_file1, a_file2, msg))
    _TS_FAIL(a_srcFile.c_str(), a_line, msg.c_str());
} // ttTextFilesEqual
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void ttStreamsEqual(const std::string& a_src,
                    unsigned int a_line,
                    std::istream& a_strm1,
                    std::istream& a_strm2)
{
  std::string line1, line2;
  unsigned int line_count(1);

  // clear the flags and rewind the streams
  a_strm1.clear();
  a_strm2.clear();

  a_strm1.seekg(0);
  a_strm2.seekg(0);

  while (!a_strm1.eof() && !a_strm2.eof())
  {
    std::getline(a_strm1, line1);
    std::getline(a_strm2, line2);

    if (line1 != line2)
    {
      std::stringstream msg;

      msg << "Streams different on line " << line_count << ".\n";
      msg << "Stream1:  \"" << line1 << "\"\n";
      msg << "Stream2:  \"" << line2 << "\"\n";

      _TS_FAIL(a_src.c_str(), a_line, msg.str().c_str());
    }

    ++line_count;
  }

  if ((a_strm1.eof() && !a_strm2.eof()) || (!a_strm1.eof() && a_strm2.eof()))
  {
    _TS_FAIL(a_src.c_str(), a_line, "Streams of different lengths");
  }
} // ttStreamsEqual
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ttEqualPointsXYZ(const Pt3d& a_pt1, const Pt3d& a_pt2, double a_tolerance)
{
  return ttEqualPointsXYZ(a_pt1.x, a_pt1.y, a_pt1.z, a_pt2.x, a_pt2.y, a_pt2.z, a_tolerance);
} // ttEqualPointsXYZ
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ttEqualPointsXYZ(double a_x1,
                      double a_y1,
                      double a_z1,
                      double a_x2,
                      double a_y2,
                      double a_z2,
                      double a_tolerance)
{
  if ((fabs(a_x1 - a_x2) <= a_tolerance) && (fabs(a_y1 - a_y2) <= a_tolerance) &&
      (fabs(a_z1 - a_z2) <= a_tolerance))
    return true;
  return false;
} // ttEqualPointsXYZ
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ttEqualPointsXY(double a_x1, double a_y1, double a_x2, double a_y2, double a_tolerance)
{
  double dx = fabs(a_x1 - a_x2);
  double dy = fabs(a_y1 - a_y2);
  if (dx > a_tolerance || dy > a_tolerance)
    return false;
  else if (sqrt(dx * dx + dy * dy) <= a_tolerance)
    return true;
  else
    return false;
} // ttEqualPointsXY
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ttEqualPointsXY(const Pt2d& a_pt1, const Pt2d& a_pt2, double a_tolerance)
{
  return ttEqualPointsXY(a_pt1.x, a_pt1.y, a_pt2.x, a_pt2.y, a_tolerance);
} // ttEqualPointsXY
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool ttEqualPointsXY(const Pt3d& a_pt1, const Pt3d& a_pt2, double a_tolerance)
{
  return ttEqualPointsXY(a_pt1.x, a_pt1.y, a_pt2.x, a_pt2.y, a_tolerance);
} // ttEqualPointsXY

} // namespace xms