/* -*- 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 "singleton.h"

#include "system-path.h"

#include "log.h"

#include <cmath>

#include <cstring>

#include <vector>

#include <list>

#include <map>

/**

 * \file

 * \ingroup testing

 * Implementation of the testing classes and functions

 */

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;

} 

/**

 * \ingroup testingimpl

 * Container for details of a test failure.

 */

struct TestCaseFailure

{

  /**

   * Constructor.

   *

   * \param [in] _cond    The name of the condition being tested.

   * \param [in] _actual  The actual value returned by the test.

   * \param [in] _limit   The expected value.

   * \param [in] _message The associated message.

   * \param [in] _file    The soure file.

   * \param [in] _line    The source line.

   */

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

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

                   std::string _file, int32_t _line);

  std::string cond;    /**< The name of the condition being tested. */

  std::string actual;  /**< The actual value returned by the test. */

  std::string limit;   /**< The expected value. */

  std::string message; /**< The associated message. */

  std::string file;    /**< The soure file. */

  int32_t line;        /**< The source line. */

};

/**

 * Output streamer for TestCaseFailure.

 *

 * \param [in,out] os The output stream.

 * \param [in] failure The TestCaseFailure to print.

 * \returns The stream.

 */

std::ostream & operator << (std::ostream & os, const TestCaseFailure & failure)

{

  os << "    test=\""  << failure.cond

     << "\" actual=\"" << failure.actual

     << "\" limit=\""  << failure.limit

     << "\" in=\""     << failure.file

     << ":"            << failure.line 

     << "\" "          << failure.message;

  return os;

}

/**

 * \ingroup testingimpl

 * Container for results from a TestCase.

 */

struct TestCase::Result

{

  /** Constructor. */

  Result ();

  /** Test running time. */

  SystemWallClockMs clock;

  /** TestCaseFailure records for each child. */

  std::vector<TestCaseFailure> failure;

  /** \c true if any child TestCases failed. */

  bool childrenFailed;

};

/**

 * \ingroup testingimpl

 * Container for all tests.

 */

class TestRunnerImpl : public Singleton<TestRunnerImpl>

{

public:

  /** Constructor. */

  TestRunnerImpl ();

  /**

   * Add a new top-level TestSuite.

   * \param [in] testSuite The new TestSuite.

   */

  void AddTestSuite (TestSuite *testSuite);

  /** \copydoc TestCase::MustAssertOnFailure() */

  bool MustAssertOnFailure (void) const;

  /** \copydoc TestCase::MustContinueOnFailure() */

  bool MustContinueOnFailure (void) const;

  /**

   * Check if this run should update the reference data.

   * \return \c true if we should update the reference data.

   */

  bool MustUpdateData (void) const;

  /**

   * Get the path to the root of the source tree.

   *

   * The root directory is defined by the presence of two files:

   * "VERSION" and "LICENSE".

   *

   * \returns The path to the root.

   */

  std::string GetTopLevelSourceDir (void) const;

  /**

   * Get the path to temporary directory.

   * \return The temporary directory path.

   */

  std::string GetTempDir (void) const;

  /** \copydoc TestRunner::Run() */

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

private:

  /**

   * Check if this is the root of the source tree.

   * \param [in] path The path to test.

   * \returns \c true if \p path is the root.

   */

  bool IsTopLevelSourceDir (std::string path) const;

  /**

   * Clean up characters not allowed in XML.

   *

   * 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.

   *

   * Specifically, we make these replacements:

   *    Raw Source | Replacement

   *    :--------: | :---------:

   *    '<'        | "&lt;"

   *    '>'        | ">"

   *    '&'        | "&"

   *    '"'        | "&39;"

   *    '\'        | """

   *

   * \param [in] xml The raw string.

   * \returns The sanitized string.

   */

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

  /**

   * Print the test report.

   *

   * \param [in] test The TestCase to print.

   * \param [in,out] os The output stream.

   * \param [in] xml Generate XML output if \c true.

   * \param [in] level Indentation level.

   */

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

  /**

   * Print the list of all requested test suites.

   *

   * \param [in] begin Iterator to the first TestCase to print.

   * \param [in] end Iterator to the end of the list.

   * \param [in] printTestType Preprend the test type label if \c true.

   */

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

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

                          bool printTestType) const;

  /** Print the list of test types. */

  void PrintTestTypeList (void) const;

  /**

   * Print the help text.

   * \param [in] programName The name of the invoking program.

   */

  void PrintHelp (const char *programName) const;

  /**

   * Generate the list of tests matching the constraints.

   *

   * Test name and type contraints are or'ed.  The duration constraint

   * is and'ed.

   *

   * \param [in] testName Include a specific test by name.

   * \param [in] testType Include all tests of give type.

   * \param [in] maximumTestDuration Restrict to tests shorter than this.

   * \returns The list of tests matching the filter constraints.

   */

  std::list<TestCase *> FilterTests (std::string testName,

                                     enum TestSuite::Type testType,

                                     enum TestCase::TestDuration maximumTestDuration);

  /** Container type for the test. */

  typedef std::vector<TestSuite *> TestSuiteVector;

  TestSuiteVector m_suites;  //!< The list of tests.

  std::string m_tempDir;     //!< The temporary directory.

  bool m_verbose;            //!< Produce verbose output.

  bool m_assertOnFailure;    //!< \c true if we should assert on failure.

  bool m_continueOnFailure;  //!< \c true if we should continue on failure.

  bool m_updateData;         //!< \c true if we should update reference data.

};

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),

    m_name (name),

    m_duration (TestCase::QUICK)

{

  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

TestCase::AddTestCase (TestCase *testCase, enum TestCase::TestDuration duration)

{

    {

    }

}

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;

}

TestCase *

TestCase::GetParent () const

{

  return m_parent;

}

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 != 0 && current->m_dataDir == "")

    {

      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::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);