/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2009 University of Washington

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include "test.h"

#include "assert.h"

#include "abort.h"

#include "system-path.h"

#include "log.h"

#include <cmath>

#include <cstring>

#include <vector>

#include <list>

#include <map>

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("Test");

bool

TestDoubleIsEqual (const double x1, const double x2, const double epsilon)

{

  NS_LOG_FUNCTION (x1 << x2 << epsilon);

  int exponent;

  double delta, difference;

  //

  // Find exponent of largest absolute value

  //

  {

    double max = (std::fabs (x1) > std::fabs (x2)) ? x1 : x2;

    (void)std::frexp (max, &exponent);

  }

  //

  // Form a neighborhood of size  2 * delta

  //

  delta = std::ldexp (epsilon, exponent);

  difference = x1 - x2;

  if (difference > delta || difference < -delta)

    {

      return false;

    }

  return true;

} 

struct TestCaseFailure

{

  TestCaseFailure (std::string _cond, std::string _actual, 

                   std::string _limit, std::string _message, 

                   std::string _file, int32_t _line);

  std::string cond;

  std::string actual;

  std::string limit;

  std::string message; 

  std::string file;

  int32_t line;

};

struct TestCase::Result

{

  Result ();

  SystemWallClockMs clock;

  std::vector<TestCaseFailure> failure;

  bool childrenFailed;

};

class TestRunnerImpl

{

public:

  void AddTestSuite (TestSuite *testSuite);

  void StartTestCase (std::string name);

  void EndTestCase (void);

  void ReportTestFailure (std::string cond, std::string actual, 

                      std::string limit, std::string message, 

                      std::string file, int32_t line);

  bool MustAssertOnFailure (void) const;

  bool MustContinueOnFailure (void) const;

  bool MustUpdateData (void) const;

  std::string GetTopLevelSourceDir (void) const;

  std::string GetTempDir (void) const;

  int Run (int argc, char *argv[]);

  static TestRunnerImpl *Instance (void);

private:

  TestRunnerImpl ();

  ~TestRunnerImpl ();

  bool IsTopLevelSourceDir (std::string path) const;

  std::string ReplaceXmlSpecialCharacters (std::string xml) const;

  void PrintReport (TestCase *test, std::ostream *os, bool xml, int level);

  void PrintTestNameList (std::list<TestCase *>::const_iterator begin, 

                          std::list<TestCase *>::const_iterator end,

                          bool printTestType) const;

  void PrintTestTypeList (void) const;

  void PrintHelp (const char *programName) const;

  typedef std::vector<TestSuite *> TestSuiteVector;

  TestSuiteVector m_suites;

  std::string m_tempDir;

  bool m_verbose;

  bool m_assertOnFailure;

  bool m_continueOnFailure;

  bool m_updateData;

};

TestCaseFailure::TestCaseFailure (std::string _cond, std::string _actual, 

                                  std::string _limit, std::string _message, 

                                  std::string _file, int32_t _line)

  : cond (_cond), actual (_actual), limit (_limit),

    message (_message), file (_file), line (_line)

{

  NS_LOG_FUNCTION (this << _cond << _actual << _limit << _message << _file << _line);

}

TestCase::Result::Result ()

  : childrenFailed (false)

{

  NS_LOG_FUNCTION (this);

}

TestCase::TestCase (std::string name)

  : m_parent (0),

    m_dataDir (""),

    m_runner (0),

    m_result (0),

{

  NS_LOG_FUNCTION (this << name);

}

TestCase::~TestCase ()

{

  NS_LOG_FUNCTION (this);

  NS_ASSERT (m_runner == 0);

  m_parent = 0;

  delete m_result;

  for (std::vector<TestCase *>::const_iterator i = m_children.begin (); i != m_children.end (); ++i)

    {

      delete *i;

    }

  m_children.clear ();

}

void

{

  NS_LOG_FUNCTION (&testCase);

  m_children.push_back (testCase);

  testCase->m_parent = this;

  std::string::size_type slash, antislash;

  slash = testCase->m_name.find ("/");

  antislash = testCase->m_name.find ("\\");

  if (slash != std::string::npos || antislash != std::string::npos)

    {

      std::string fullname = testCase->m_name;

      TestCase *current = testCase->m_parent;

      while (current != 0)

        {

          fullname = current->m_name + "/" + fullname;

          current = current->m_parent;

        }

      if (slash != std::string::npos)

        {

          NS_FATAL_ERROR ("Invalid test name: cannot contain slashes: \"" << fullname << "\"");

        }

      if (antislash != std::string::npos)

        {

          NS_FATAL_ERROR ("Invalid test name: cannot contain antislashes: \"" << fullname << "\"");

        }

    }

}

bool

TestCase::IsFailed (void) const

{

  NS_LOG_FUNCTION (this);

  return m_result->childrenFailed || !m_result->failure.empty ();

}

void 

TestCase::Run (TestRunnerImpl *runner)

{

  NS_LOG_FUNCTION (this << runner);

  m_result = new Result ();

  m_runner = runner;

  DoSetup ();

  m_result->clock.Start ();

  for (std::vector<TestCase *>::const_iterator i = m_children.begin (); i != m_children.end (); ++i)

    {

      TestCase *test = *i;

      test->Run (runner);

      if (IsFailed ())

        {

          goto out;

        }

    }

  DoRun ();

 out:

  m_result->clock.End ();

  DoTeardown ();

  m_runner = 0;

}

std::string 

TestCase::GetName (void) const

{

  NS_LOG_FUNCTION (this);

  return m_name;

}

void

TestCase::ReportTestFailure (std::string cond, std::string actual, 

                             std::string limit, std::string message, 

                             std::string file, int32_t line)

{

  NS_LOG_FUNCTION (this << cond << actual << limit << message << file << line);

  m_result->failure.push_back (TestCaseFailure (cond, actual, limit,

                                                message, file, line));

  // set childrenFailed flag on parents.

  TestCase *current = m_parent;

  while (current != 0)

    {

      current->m_result->childrenFailed = true;

      current = current->m_parent;

    }

}

bool 

TestCase::MustAssertOnFailure (void) const

{

  NS_LOG_FUNCTION (this);

  return m_runner->MustAssertOnFailure ();

}

bool 

TestCase::MustContinueOnFailure (void) const

{

  NS_LOG_FUNCTION (this);

  return m_runner->MustContinueOnFailure ();

}

std::string 

TestCase::CreateDataDirFilename (std::string filename)

{

  NS_LOG_FUNCTION (this << filename);

  const TestCase *current = this;

  while (current->m_dataDir == "" && current != 0)

    {

      current = current->m_parent;

    }

  if (current == 0)

    {

      NS_FATAL_ERROR ("No one called SetDataDir prior to calling this function");

    }

  std::string a = SystemPath::Append (m_runner->GetTopLevelSourceDir (), current->m_dataDir);

  std::string b = SystemPath::Append (a, filename);

  return b;

}

std::string 

TestCase::CreateTempDirFilename (std::string filename)

{

  NS_LOG_FUNCTION (this << filename);

  if (m_runner->MustUpdateData ())

    {

      return CreateDataDirFilename (filename);

    }

  else

    {

      std::list<std::string> names;

      const TestCase *current = this;

      while (current != 0)

        {

          names.push_front (current->m_name);

          current = current->m_parent;

        }

      std::string tempDir = SystemPath::Append (m_runner->GetTempDir (), SystemPath::Join (names.begin (), names.end ()));

      SystemPath::MakeDirectories (tempDir);

      return SystemPath::Append (tempDir, filename);

    }

}

bool 

TestCase::GetErrorStatus (void) const

{

  NS_LOG_FUNCTION (this);

  return IsStatusFailure ();

}

bool 

TestCase::IsStatusFailure (void) const

{

  NS_LOG_FUNCTION (this);

  return !IsStatusSuccess ();

}

bool 

TestCase::IsStatusSuccess (void) const

{

  NS_LOG_FUNCTION (this);

  return m_result->failure.empty ();

}

void 

TestCase::SetDataDir (std::string directory)

{

  NS_LOG_FUNCTION (this << directory);

  m_dataDir = directory;

}

void 

TestCase::DoSetup (void)

{

  NS_LOG_FUNCTION (this);

}

void 

TestCase::DoTeardown (void)

{

  NS_LOG_FUNCTION (this);

}

TestSuite::TestSuite (std::string name, TestSuite::Type type)

  : TestCase (name), 

    m_type (type)

{

  NS_LOG_FUNCTION (this << name << type);

  TestRunnerImpl::Instance ()->AddTestSuite (this);

}

TestSuite::Type 

TestSuite::GetTestType (void)

{

  NS_LOG_FUNCTION (this);

  return m_type;

}

void 

TestSuite::DoRun (void)

{

  NS_LOG_FUNCTION (this);

}

TestRunnerImpl::TestRunnerImpl ()

 : m_tempDir (""),

   m_assertOnFailure (false),

   m_continueOnFailure (true),

   m_updateData (false)

{

  NS_LOG_FUNCTION (this);

}

TestRunnerImpl::~TestRunnerImpl ()

{

  NS_LOG_FUNCTION (this);

}

TestRunnerImpl *

TestRunnerImpl::Instance (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  static TestRunnerImpl runner;

  return &runner;

}

void

TestRunnerImpl::AddTestSuite (TestSuite *testSuite)

{

  NS_LOG_FUNCTION (this << testSuite);

  m_suites.push_back (testSuite);

}

bool 

TestRunnerImpl::MustAssertOnFailure (void) const

{

  NS_LOG_FUNCTION (this);

  return m_assertOnFailure;

}

bool 

TestRunnerImpl::MustContinueOnFailure (void) const

{

  NS_LOG_FUNCTION (this);

  return m_continueOnFailure;

}

bool 

TestRunnerImpl::MustUpdateData (void) const

{

  NS_LOG_FUNCTION (this);

  return m_updateData;

}

std::string

TestRunnerImpl::GetTempDir (void) const

{

  NS_LOG_FUNCTION (this);

  return m_tempDir;

}

bool

TestRunnerImpl::IsTopLevelSourceDir (std::string path) const

{

  NS_LOG_FUNCTION (this << path);

  bool haveVersion = false;

  bool haveLicense = false;

  //

  // If there's a file named VERSION and a file named LICENSE in this

  // directory, we assume it's our top level source directory.

  //

  std::list<std::string> files = SystemPath::ReadFiles (path);

  for (std::list<std::string>::const_iterator i = files.begin (); i != files.end (); ++i)

    {

      if (*i == "VERSION")

        {

          haveVersion = true;

        }

      else if (*i == "LICENSE")

        {

          haveLicense = true;

        }

    }

  return haveVersion && haveLicense;

}

std::string 

TestRunnerImpl::GetTopLevelSourceDir (void) const

{

  NS_LOG_FUNCTION (this);

  std::string self = SystemPath::FindSelfDirectory ();

  std::list<std::string> elements = SystemPath::Split (self);

  while (!elements.empty ())

    {

      std::string path = SystemPath::Join (elements.begin (), elements.end ());

      if (IsTopLevelSourceDir (path))

        {

          return path;

        }

      elements.pop_back ();

    }

  NS_FATAL_ERROR ("Could not find source directory from self=" << self);

}

//

// XML files have restrictions on certain characters that may be present in

// data.  We need to replace these characters with their alternate 

// representation on the way into the XML file.

//

std::string

TestRunnerImpl::ReplaceXmlSpecialCharacters (std::string xml) const

{

  NS_LOG_FUNCTION (this << xml);

  std::string specials = "<>&\"'";

  std::string replacements[] = {"<", ">", "&", "'", """};

  std::string result;

  std::size_t index, length = xml.length ();

  for (size_t i = 0; i < length; ++i)