Attachment #1270 for bug #1289

View | Details | Raw Unified | Return to bug 1289
Collapse All | Expand All




#include "assert.h"
#include "abort.h"
#include "system-path.h"
#include "log.h"
#include <math.h>
#include <string.h>
#include <vector>
#include <list>

NS_LOG_COMPONENT_DEFINE ("Test");

namespace ns3 {


    m_result (0),
    m_name (name)
{
  NS_LOG_FUNCTION (this << name);
}

TestCase::~TestCase ()
{
  NS_LOG_FUNCTION (this);
  NS_ASSERT (m_runner == 0);
  m_parent = 0;
  delete m_result;

void
TestCase::AddTestCase (TestCase *testCase)
{
  NS_LOG_FUNCTION (this);
  m_children.push_back (testCase);
  testCase->m_parent = this;


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);
  m_result = new Result ();
  m_runner = runner;
  DoSetup ();

std::string 
TestCase::GetName (void) const
{
  NS_LOG_FUNCTION (this);
  return m_name;
}
void

                             std::string limit, std::string message, 
                             std::string file, int32_t line)
{
  NS_LOG_FUNCTION (this);
  m_result->failure.push_back (TestCaseFailure (cond, actual, limit,
                                                message, file, line));
  // set childrenFailed flag on parents.

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);
  const TestCase *current = this;
  while (current->m_dataDir == "" && current != 0)
    {

std::string 
TestCase::CreateTempDirFilename (std::string filename)
{
  NS_LOG_FUNCTION (this);
  if (m_runner->MustUpdateData ())
    {
      return CreateDataDirFilename (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);
  m_dataDir = directory;
}


  : TestCase (name), 
    m_type (type)
{
  NS_LOG_FUNCTION (this);
  TestRunnerImpl::Instance ()->AddTestSuite (this);
}

TestSuite::Type 
TestSuite::GetTestType (void)
{
  NS_LOG_FUNCTION (this);
  return m_type;
}


   m_continueOnFailure (true),
   m_updateData (false)
{
  NS_LOG_FUNCTION (this);
}

TestRunnerImpl::~TestRunnerImpl ()
{
  NS_LOG_FUNCTION (this);
}



void
TestRunnerImpl::AddTestSuite (TestSuite *testSuite)
{
  NS_LOG_FUNCTION (this);
  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);
  bool haveVersion = false;
  bool haveLicense = false;
  

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
TestRunnerImpl::ReplaceXmlSpecialCharacters (std::string xml) const
{
  NS_LOG_FUNCTION (this);
  std::string specials = "<>&\"'";
  std::string replacements[] = {"&lt;", "&gt;", "&amp;", "&#39;", "&quot;"};
  std::string result;

void
TestRunnerImpl::PrintReport (TestCase *test, std::ostream *os, bool xml, int level)
{
  NS_LOG_FUNCTION (this);
  if (test->m_result == 0)
    {
      // Do not print reports for tests that were not run.

void
TestRunnerImpl::PrintHelp (const char *program_name) const
{
  NS_LOG_FUNCTION (this);
  std::cout << "Usage: " << program_name << " [OPTIONS]" << std::endl
            << std::endl
            << "Options: "

TestRunnerImpl::PrintTestNameList (std::list<TestCase *>::const_iterator begin, 
                                   std::list<TestCase *>::const_iterator end) const
{
  NS_LOG_FUNCTION (this);
  for (std::list<TestCase *>::const_iterator i = begin; i != end; ++i)
    {
      TestCase *test = *i;

void
TestRunnerImpl::PrintTestTypeList (void) const
{
  NS_LOG_FUNCTION (this);
  std::cout << "  bvt:         Build Verification Tests (to see if build completed successfully)" << std::endl;
  std::cout << "  core:        Run all TestSuite-based tests (exclude examples)" << std::endl;
  std::cout << "  example:     Examples (to see if example programs run successfully)" << std::endl;

std::list<TestCase *>
TestRunnerImpl::FilterTests (std::string testName, enum TestSuite::Type testType) const
{
  NS_LOG_FUNCTION (this);
  std::list<TestCase *> tests;
  NS_LOG_LOGIC ("m_suites.size () : " << m_suites.size ());
  for (uint32_t i = 0; i < m_suites.size (); ++i)
    {
      TestSuite *test = m_suites[i];
      if (testType != TestSuite::ALL && test->GetTestType () != testType)
        {
          NS_LOG_LOGIC ("skipping test " << test->GetName ());
          continue;
        }
      if (testName != "" && test->GetName () != testName)
        {
          NS_LOG_LOGIC ("skipping test " << test->GetName ());
          continue;
        }
      NS_LOG_LOGIC ("considering test " << test->GetName ());
      tests.push_back (test);
    }
  return tests;

int 
TestRunnerImpl::Run (int argc, char *argv[])
{
  NS_LOG_FUNCTION (this);
  std::string testName = "";
  std::string testTypeString = "";
  std::string out = "";

int 
TestRunner::Run (int argc, char *argv[])
{
  NS_LOG_FUNCTION_NOARGS ();
  return TestRunnerImpl::Instance ()->Run (argc, argv);
}


Return to bug 1289