From 11fb80ceaf6ba4fc75add4322cda65cf342066fc Mon Sep 17 00:00:00 2001 From: Thomas Fussell Date: Sat, 11 Mar 2017 14:13:23 -0500 Subject: [PATCH] recommit the cxxtest headers --- third-party/cxxtest/cxxtest/Descriptions.cpp | 83 ++ third-party/cxxtest/cxxtest/Descriptions.h | 91 +++ .../cxxtest/cxxtest/DummyDescriptions.cpp | 60 ++ .../cxxtest/cxxtest/DummyDescriptions.h | 87 +++ third-party/cxxtest/cxxtest/ErrorFormatter.h | 347 +++++++++ third-party/cxxtest/cxxtest/ErrorPrinter.h | 68 ++ third-party/cxxtest/cxxtest/Flags.h | 154 ++++ third-party/cxxtest/cxxtest/GlobalFixture.cpp | 34 + third-party/cxxtest/cxxtest/GlobalFixture.h | 41 + third-party/cxxtest/cxxtest/Gui.h | 199 +++++ third-party/cxxtest/cxxtest/LinkedList.cpp | 221 ++++++ third-party/cxxtest/cxxtest/LinkedList.h | 73 ++ .../cxxtest/cxxtest/MSVCErrorPrinter.h | 40 + third-party/cxxtest/cxxtest/Mock.h | 380 +++++++++ third-party/cxxtest/cxxtest/ParenPrinter.h | 32 + third-party/cxxtest/cxxtest/QtGui.h | 306 ++++++++ .../cxxtest/cxxtest/RealDescriptions.cpp | 361 +++++++++ .../cxxtest/cxxtest/RealDescriptions.h | 243 ++++++ third-party/cxxtest/cxxtest/Root.cpp | 29 + third-party/cxxtest/cxxtest/SelfTest.h | 18 + third-party/cxxtest/cxxtest/StdHeaders.h | 36 + third-party/cxxtest/cxxtest/StdTestSuite.h | 70 ++ third-party/cxxtest/cxxtest/StdValueTraits.h | 303 ++++++++ .../cxxtest/cxxtest/StdioFilePrinter.h | 52 ++ third-party/cxxtest/cxxtest/StdioPrinter.h | 33 + third-party/cxxtest/cxxtest/TeeListener.h | 205 +++++ third-party/cxxtest/cxxtest/TestListener.h | 87 +++ third-party/cxxtest/cxxtest/TestMain.h | 133 ++++ third-party/cxxtest/cxxtest/TestRunner.h | 154 ++++ third-party/cxxtest/cxxtest/TestSuite.cpp | 317 ++++++++ third-party/cxxtest/cxxtest/TestSuite.h | 732 ++++++++++++++++++ third-party/cxxtest/cxxtest/TestTracker.cpp | 288 +++++++ third-party/cxxtest/cxxtest/TestTracker.h | 134 ++++ third-party/cxxtest/cxxtest/ValueTraits.cpp | 195 +++++ third-party/cxxtest/cxxtest/ValueTraits.h | 435 +++++++++++ third-party/cxxtest/cxxtest/Win32Gui.h | 572 ++++++++++++++ third-party/cxxtest/cxxtest/X11Gui.h | 367 +++++++++ third-party/cxxtest/cxxtest/XUnitPrinter.h | 48 ++ third-party/cxxtest/cxxtest/XmlFormatter.h | 664 ++++++++++++++++ third-party/cxxtest/cxxtest/XmlPrinter.h | 75 ++ third-party/cxxtest/cxxtest/YesNoRunner.h | 40 + third-party/cxxtest/cxxtest/unix.h | 311 ++++++++ 42 files changed, 8118 insertions(+) create mode 100644 third-party/cxxtest/cxxtest/Descriptions.cpp create mode 100644 third-party/cxxtest/cxxtest/Descriptions.h create mode 100644 third-party/cxxtest/cxxtest/DummyDescriptions.cpp create mode 100644 third-party/cxxtest/cxxtest/DummyDescriptions.h create mode 100644 third-party/cxxtest/cxxtest/ErrorFormatter.h create mode 100644 third-party/cxxtest/cxxtest/ErrorPrinter.h create mode 100644 third-party/cxxtest/cxxtest/Flags.h create mode 100644 third-party/cxxtest/cxxtest/GlobalFixture.cpp create mode 100644 third-party/cxxtest/cxxtest/GlobalFixture.h create mode 100644 third-party/cxxtest/cxxtest/Gui.h create mode 100644 third-party/cxxtest/cxxtest/LinkedList.cpp create mode 100644 third-party/cxxtest/cxxtest/LinkedList.h create mode 100644 third-party/cxxtest/cxxtest/MSVCErrorPrinter.h create mode 100644 third-party/cxxtest/cxxtest/Mock.h create mode 100644 third-party/cxxtest/cxxtest/ParenPrinter.h create mode 100644 third-party/cxxtest/cxxtest/QtGui.h create mode 100644 third-party/cxxtest/cxxtest/RealDescriptions.cpp create mode 100644 third-party/cxxtest/cxxtest/RealDescriptions.h create mode 100644 third-party/cxxtest/cxxtest/Root.cpp create mode 100644 third-party/cxxtest/cxxtest/SelfTest.h create mode 100644 third-party/cxxtest/cxxtest/StdHeaders.h create mode 100644 third-party/cxxtest/cxxtest/StdTestSuite.h create mode 100644 third-party/cxxtest/cxxtest/StdValueTraits.h create mode 100644 third-party/cxxtest/cxxtest/StdioFilePrinter.h create mode 100644 third-party/cxxtest/cxxtest/StdioPrinter.h create mode 100644 third-party/cxxtest/cxxtest/TeeListener.h create mode 100644 third-party/cxxtest/cxxtest/TestListener.h create mode 100644 third-party/cxxtest/cxxtest/TestMain.h create mode 100644 third-party/cxxtest/cxxtest/TestRunner.h create mode 100644 third-party/cxxtest/cxxtest/TestSuite.cpp create mode 100644 third-party/cxxtest/cxxtest/TestSuite.h create mode 100644 third-party/cxxtest/cxxtest/TestTracker.cpp create mode 100644 third-party/cxxtest/cxxtest/TestTracker.h create mode 100644 third-party/cxxtest/cxxtest/ValueTraits.cpp create mode 100644 third-party/cxxtest/cxxtest/ValueTraits.h create mode 100644 third-party/cxxtest/cxxtest/Win32Gui.h create mode 100644 third-party/cxxtest/cxxtest/X11Gui.h create mode 100644 third-party/cxxtest/cxxtest/XUnitPrinter.h create mode 100644 third-party/cxxtest/cxxtest/XmlFormatter.h create mode 100644 third-party/cxxtest/cxxtest/XmlPrinter.h create mode 100644 third-party/cxxtest/cxxtest/YesNoRunner.h create mode 100644 third-party/cxxtest/cxxtest/unix.h diff --git a/third-party/cxxtest/cxxtest/Descriptions.cpp b/third-party/cxxtest/cxxtest/Descriptions.cpp new file mode 100644 index 00000000..17e9de35 --- /dev/null +++ b/third-party/cxxtest/cxxtest/Descriptions.cpp @@ -0,0 +1,83 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__Descriptions_cpp__ +#define __cxxtest__Descriptions_cpp__ + +#include + +namespace CxxTest +{ +TestDescription::~TestDescription() {} +SuiteDescription::~SuiteDescription() {} +WorldDescription::~WorldDescription() {} + +// +// Convert total tests to string +// +#ifndef _CXXTEST_FACTOR +char *WorldDescription::strTotalTests(char *s) const +{ + numberToString(numTotalTests(), s); + return s; +} +#else // _CXXTEST_FACTOR +char *WorldDescription::strTotalTests(char *s) const +{ + char *p = numberToString(numTotalTests(), s); + + if (numTotalTests() <= 1) + { + return s; + } + + unsigned n = numTotalTests(); + unsigned numFactors = 0; + + for (unsigned factor = 2; (factor * factor) <= n; factor += (factor == 2) ? 1 : 2) + { + unsigned power; + + for (power = 0; (n % factor) == 0; n /= factor) + { + ++ power; + } + + if (!power) + { + continue; + } + + p = numberToString(factor, copyString(p, (numFactors == 0) ? " = " : " * ")); + if (power > 1) + { + p = numberToString(power, copyString(p, "^")); + } + ++ numFactors; + } + + if (n > 1) + { + if (!numFactors) + { + copyString(p, tracker().failedTests() ? " :(" : tracker().warnings() ? " :|" : " :)"); + } + else + { + numberToString(n, copyString(p, " * ")); + } + } + return s; +} +#endif // _CXXTEST_FACTOR +} + +#endif // __cxxtest__Descriptions_cpp__ diff --git a/third-party/cxxtest/cxxtest/Descriptions.h b/third-party/cxxtest/cxxtest/Descriptions.h new file mode 100644 index 00000000..f579d5ad --- /dev/null +++ b/third-party/cxxtest/cxxtest/Descriptions.h @@ -0,0 +1,91 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__Descriptions_h__ +#define __cxxtest__Descriptions_h__ + +// +// TestDescription, SuiteDescription and WorldDescription +// hold information about tests so they can be run and reported. +// + +#include + +namespace CxxTest +{ +class TestSuite; + +class TestDescription : public Link +{ +public: + virtual ~TestDescription(); + + virtual const char *file() const = 0; + virtual int line() const = 0; + virtual const char *testName() const = 0; + virtual const char *suiteName() const = 0; + + virtual void run() = 0; + virtual bool setUp() = 0; + virtual bool tearDown() = 0; + + virtual const TestDescription *next() const = 0; + virtual TestDescription *next() = 0; +}; + +class SuiteDescription : public Link +{ +public: + virtual ~SuiteDescription(); + + virtual const char *file() const = 0; + virtual int line() const = 0; + virtual const char *suiteName() const = 0; + virtual TestSuite *suite() const = 0; + + virtual unsigned numTests() const = 0; + virtual const TestDescription &testDescription(unsigned /*i*/) const = 0; + + virtual TestDescription *firstTest() = 0; + virtual const TestDescription *firstTest() const = 0; + virtual SuiteDescription *next() = 0; + virtual const SuiteDescription *next() const = 0; + + virtual void activateAllTests() = 0; + virtual bool leaveOnly(const char * /*testName*/) = 0; + + virtual bool setUp() = 0; + virtual bool tearDown() = 0; +}; + +class WorldDescription : public Link +{ +public: + virtual ~WorldDescription(); + + virtual const char *worldName() const { return "cxxtest"; } + virtual unsigned numSuites(void) const = 0; + virtual unsigned numTotalTests(void) const = 0; + virtual const SuiteDescription &suiteDescription(unsigned /*i*/) const = 0; + + enum { MAX_STRLEN_TOTAL_TESTS = 32 }; + char *strTotalTests(char * /*buffer*/) const; + + virtual SuiteDescription *firstSuite() = 0; + virtual const SuiteDescription *firstSuite() const = 0; + + virtual void activateAllTests() = 0; + virtual bool leaveOnly(const char * /*suiteName*/, const char * /*testName*/ = 0) = 0; +}; +} + +#endif // __cxxtest__Descriptions_h__ + diff --git a/third-party/cxxtest/cxxtest/DummyDescriptions.cpp b/third-party/cxxtest/cxxtest/DummyDescriptions.cpp new file mode 100644 index 00000000..1cc81054 --- /dev/null +++ b/third-party/cxxtest/cxxtest/DummyDescriptions.cpp @@ -0,0 +1,60 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#include + +namespace CxxTest +{ +DummyTestDescription::DummyTestDescription() {} + +const char *DummyTestDescription::file() const { return ""; } +int DummyTestDescription::line() const { return 0; } +const char *DummyTestDescription::testName() const { return ""; } +const char *DummyTestDescription::suiteName() const { return ""; } +bool DummyTestDescription::setUp() { return true;} +void DummyTestDescription::run() {} +bool DummyTestDescription::tearDown() { return true;} + +TestDescription *DummyTestDescription::next() { return 0; } +const TestDescription *DummyTestDescription::next() const { return 0; } + +DummySuiteDescription::DummySuiteDescription() : _test() {} + +const char *DummySuiteDescription::file() const { return ""; } +int DummySuiteDescription::line() const { return 0; } +const char *DummySuiteDescription::suiteName() const { return ""; } +TestSuite *DummySuiteDescription::suite() const { return 0; } +unsigned DummySuiteDescription::numTests() const { return 0; } +const TestDescription &DummySuiteDescription::testDescription(unsigned) const { return _test; } +SuiteDescription *DummySuiteDescription::next() { return 0; } +TestDescription *DummySuiteDescription::firstTest() { return 0; } +const SuiteDescription *DummySuiteDescription::next() const { return 0; } +const TestDescription *DummySuiteDescription::firstTest() const { return 0; } +void DummySuiteDescription::activateAllTests() {} +bool DummySuiteDescription::leaveOnly(const char * /*testName*/) { return false; } + +bool DummySuiteDescription::setUp() { return true;} +bool DummySuiteDescription::tearDown() { return true;} + +DummyWorldDescription::DummyWorldDescription() : _suite() {} + +unsigned DummyWorldDescription::numSuites(void) const { return 0; } +unsigned DummyWorldDescription::numTotalTests(void) const { return 0; } +const SuiteDescription &DummyWorldDescription::suiteDescription(unsigned) const { return _suite; } +SuiteDescription *DummyWorldDescription::firstSuite() { return 0; } +const SuiteDescription *DummyWorldDescription::firstSuite() const { return 0; } +void DummyWorldDescription::activateAllTests() {} +bool DummyWorldDescription::leaveOnly(const char * /*suiteName*/, const char * /*testName*/) { return false; } + +bool DummyWorldDescription::setUp() { return true;} +bool DummyWorldDescription::tearDown() { return true;} +} + diff --git a/third-party/cxxtest/cxxtest/DummyDescriptions.h b/third-party/cxxtest/cxxtest/DummyDescriptions.h new file mode 100644 index 00000000..8964bb5f --- /dev/null +++ b/third-party/cxxtest/cxxtest/DummyDescriptions.h @@ -0,0 +1,87 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__DummyDescriptions_h__ +#define __cxxtest__DummyDescriptions_h__ + +// +// DummyTestDescription, DummySuiteDescription and DummyWorldDescription +// + +#include + +namespace CxxTest +{ +class DummyTestDescription : public TestDescription +{ +public: + DummyTestDescription(); + + const char *file() const; + int line() const; + const char *testName() const; + const char *suiteName() const; + bool setUp(); + void run(); + bool tearDown(); + + TestDescription *next(); + const TestDescription *next() const; +}; + +class DummySuiteDescription : public SuiteDescription +{ +public: + DummySuiteDescription(); + + const char *file() const; + int line() const; + const char *suiteName() const; + TestSuite *suite() const; + unsigned numTests() const; + const TestDescription &testDescription(unsigned) const; + SuiteDescription *next(); + TestDescription *firstTest(); + const SuiteDescription *next() const; + const TestDescription *firstTest() const; + void activateAllTests(); + bool leaveOnly(const char * /*testName*/); + + bool setUp(); + bool tearDown(); + +private: + DummyTestDescription _test; +}; + +class DummyWorldDescription : public WorldDescription +{ +public: + DummyWorldDescription(); + + unsigned numSuites(void) const; + unsigned numTotalTests(void) const; + const SuiteDescription &suiteDescription(unsigned) const; + SuiteDescription *firstSuite(); + const SuiteDescription *firstSuite() const; + void activateAllTests(); + bool leaveOnly(const char * /*suiteName*/, const char * /*testName*/ = 0); + + bool setUp(); + bool tearDown(); + +private: + DummySuiteDescription _suite; +}; +} + +#endif // __cxxtest__DummyDescriptions_h__ + diff --git a/third-party/cxxtest/cxxtest/ErrorFormatter.h b/third-party/cxxtest/cxxtest/ErrorFormatter.h new file mode 100644 index 00000000..81582a3a --- /dev/null +++ b/third-party/cxxtest/cxxtest/ErrorFormatter.h @@ -0,0 +1,347 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__ErrorFormatter_h__ +#define __cxxtest__ErrorFormatter_h__ + +// +// The ErrorFormatter is a TestListener that +// prints reports of the errors to an output +// stream. Since we cannot rely on the standard +// iostreams, this header defines a base class +// analogout to std::ostream. +// + +#include +#include +#include +#include +#include + +namespace CxxTest +{ +class OutputStream +{ +public: + virtual ~OutputStream() {} + virtual void flush() {}; + virtual OutputStream &operator<<(unsigned /*number*/) { return *this; } + virtual OutputStream &operator<<(const char * /*string*/) { return *this; } + + typedef void (*Manipulator)(OutputStream &); + + virtual OutputStream &operator<<(Manipulator m) { m(*this); return *this; } + static void endl(OutputStream &o) { (o << "\n").flush(); } +}; + +class ErrorFormatter : public TestListener +{ +public: + ErrorFormatter(OutputStream *o, const char *preLine = ":", const char *postLine = "", + const char *errorString = "Error", + const char *warningString = "Warning") : + _dotting(true), + _reported(false), + _o(o), + _preLine(preLine), + _postLine(postLine), + _errorString(errorString), + _warningString(warningString) + { + } + + int run() + { + TestRunner::runAllTests(*this); + return tracker().failedTests(); + } + + void enterWorld(const WorldDescription& desc) + { + (*_o) << "Running " << desc.worldName() << " tests (" << totalTests << ")"; + _o->flush(); + _dotting = true; + _reported = false; + } + + static void totalTests(OutputStream &o) + { + char s[WorldDescription::MAX_STRLEN_TOTAL_TESTS]; + const WorldDescription &wd = tracker().world(); + o << wd.strTotalTests(s) << (wd.numTotalTests() == 1 ? " test" : " tests"); + } + + void enterSuite(const SuiteDescription &) + { + _reported = false; + } + + void enterTest(const TestDescription &) + { + _reported = false; + } + + void leaveTest(const TestDescription &) + { + if (tracker().testSkipped()) + { + (*_o) << "s"; + _o->flush(); + fflush(stdout); + _dotting = true; + } + else if (!tracker().testFailed()) + { + (*_o) << "."; + _o->flush(); + fflush(stdout); + _dotting = true; + } + } + + void leaveWorld(const WorldDescription &desc) + { + if (!tracker().failedTests()) + { + (*_o) << "OK!" << endl; + return; + } + newLine(); + (*_o) << "Failed " << tracker().failedTests() << " and Skipped " << tracker().skippedTests() << " of " << totalTests << endl; + unsigned numPassed = desc.numTotalTests() - tracker().failedTests() - tracker().skippedTests(); + unsigned numTotal = desc.numTotalTests() - tracker().skippedTests(); + if (numTotal == 0) + { + (*_o) << "Success rate: 100%" << endl; + } + else + { + (*_o) << "Success rate: " << (unsigned)(numPassed * 100.0 / numTotal) << "%" << endl; + } + } + + void trace(const char *file, int line, const char *expression) + { + stop(file, line) << "Trace: " << + expression << endl; + } + + void warning(const char *file, int line, const char *expression) + { + stop(file, line) << _warningString << ": " << + expression << endl; + } + + void skippedTest(const char *file, int line, const char *expression) + { + if(expression && strlen(expression) > 0) + stop(file, line) << _warningString << ": Test skipped: " << + expression << endl; + } + + void failedTest(const char *file, int line, const char *expression) + { + stop(file, line) << _errorString << ": Test failed: " << + expression << endl; + } + + void failedAssert(const char *file, int line, const char *expression) + { + stop(file, line) << _errorString << ": Assertion failed: " << + expression << endl; + } + + void failedAssertEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + stop(file, line) << _errorString << ": Expected (" << + xStr << " == " << yStr << "), found (" << + x << " != " << y << ")" << endl; + } + + void failedAssertSameData(const char *file, int line, + const char *xStr, const char *yStr, + const char *sizeStr, const void *x, + const void *y, unsigned size) + { + stop(file, line) << _errorString << ": Expected " << sizeStr << " (" << size << ") bytes to be equal at (" << + xStr << ") and (" << yStr << "), found:" << endl; + dump(x, size); + (*_o) << " differs from" << endl; + dump(y, size); + } + + void failedAssertSameFiles(const char* file, int line, + const char*, const char*, + const char* explanation + ) + { + stop(file, line) << _errorString << ": " << explanation << endl; + } + + void failedAssertDelta(const char *file, int line, + const char *xStr, const char *yStr, const char *dStr, + const char *x, const char *y, const char *d) + { + stop(file, line) << _errorString << ": Expected (" << + xStr << " == " << yStr << ") up to " << dStr << " (" << d << "), found (" << + x << " != " << y << ")" << endl; + } + + void failedAssertDiffers(const char *file, int line, + const char *xStr, const char *yStr, + const char *value) + { + stop(file, line) << _errorString << ": Expected (" << + xStr << " != " << yStr << "), found (" << + value << ")" << endl; + } + + void failedAssertLessThan(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + stop(file, line) << _errorString << ": Expected (" << + xStr << " < " << yStr << "), found (" << + x << " >= " << y << ")" << endl; + } + + void failedAssertLessThanEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + stop(file, line) << _errorString << ": Expected (" << + xStr << " <= " << yStr << "), found (" << + x << " > " << y << ")" << endl; + } + + void failedAssertRelation(const char *file, int line, + const char *relation, const char *xStr, const char *yStr, + const char *x, const char *y) + { + stop(file, line) << _errorString << ": Expected " << relation << "( " << + xStr << ", " << yStr << " ), found !" << relation << "( " << x << ", " << y << " )" << endl; + } + + void failedAssertPredicate(const char *file, int line, + const char *predicate, const char *xStr, const char *x) + { + stop(file, line) << _errorString << ": Expected " << predicate << "( " << + xStr << " ), found !" << predicate << "( " << x << " )" << endl; + } + + void failedAssertThrows(const char *file, int line, + const char *expression, const char *type, + bool otherThrown) + { + stop(file, line) << _errorString << ": Expected (" << expression << ") to throw (" << + type << ") but it " << (otherThrown ? "threw something else" : "didn't throw") << + endl; + } + + void failedAssertThrowsNot(const char *file, int line, const char *expression) + { + stop(file, line) << _errorString << ": Expected (" << expression << ") not to throw, but it did" << + endl; + } + +protected: + OutputStream *outputStream() const + { + return _o; + } + +private: + ErrorFormatter(const ErrorFormatter &); + ErrorFormatter &operator=(const ErrorFormatter &); + + OutputStream &stop(const char *file, int line) + { + newLine(); + reportTest(); + return (*_o) << file << _preLine << line << _postLine << ": "; + } + + void newLine(void) + { + if (_dotting) + { + (*_o) << endl; + _dotting = false; + } + } + + void reportTest(void) + { + if (_reported) + { + return; + } + (*_o) << "In " << tracker().suite().suiteName() << "::" << tracker().test().testName() << ":" << endl; + _reported = true; + } + + void dump(const void *buffer, unsigned size) + { + if (!buffer) + { + dumpNull(); + } + else + { + dumpBuffer(buffer, size); + } + } + + void dumpNull() + { + (*_o) << " (null)" << endl; + } + + void dumpBuffer(const void *buffer, unsigned size) + { + unsigned dumpSize = size; + if (maxDumpSize() && dumpSize > maxDumpSize()) + { + dumpSize = maxDumpSize(); + } + + const unsigned char *p = (const unsigned char *)buffer; + (*_o) << " { "; + for (unsigned i = 0; i < dumpSize; ++ i) + { + (*_o) << byteToHex(*p++) << " "; + } + if (dumpSize < size) + { + (*_o) << "... "; + } + (*_o) << "}" << endl; + } + + static void endl(OutputStream &o) + { + OutputStream::endl(o); + } + + bool _dotting; + bool _reported; + OutputStream *_o; + const char *_preLine; + const char *_postLine; + const char *_errorString; + const char *_warningString; +}; +} + +#endif // __cxxtest__ErrorFormatter_h__ + diff --git a/third-party/cxxtest/cxxtest/ErrorPrinter.h b/third-party/cxxtest/cxxtest/ErrorPrinter.h new file mode 100644 index 00000000..8d5b1725 --- /dev/null +++ b/third-party/cxxtest/cxxtest/ErrorPrinter.h @@ -0,0 +1,68 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__ErrorPrinter_h__ +#define __cxxtest__ErrorPrinter_h__ + +// +// The ErrorPrinter is a simple TestListener that +// just prints "OK" if everything goes well, otherwise +// reports the error in the format of compiler messages. +// The ErrorPrinter uses std::cout +// + +#include + +#ifndef _CXXTEST_HAVE_STD +# define _CXXTEST_HAVE_STD +#endif // _CXXTEST_HAVE_STD + +#include +#include + +#ifdef _CXXTEST_OLD_STD +# include +#else // !_CXXTEST_OLD_STD +# include +#endif // _CXXTEST_OLD_STD + +namespace CxxTest +{ +class ErrorPrinter : public ErrorFormatter +{ +public: + ErrorPrinter(CXXTEST_STD(ostream) &o = CXXTEST_STD(cout), const char *preLine = ":", const char *postLine = "", + const char *errorString = "Error", + const char *warningString = "Warning") : + ErrorFormatter(new Adapter(o), preLine, postLine, errorString, warningString) {} + virtual ~ErrorPrinter() { delete outputStream(); } + +private: + class Adapter : public OutputStream + { + CXXTEST_STD(ostream) &_o; + public: + Adapter(CXXTEST_STD(ostream) &o) : _o(o) {} + void flush() { _o.flush(); } + OutputStream &operator<<(const char *s) { _o << s; return *this; } + OutputStream &operator<<(Manipulator m) { return OutputStream::operator<<(m); } + OutputStream &operator<<(unsigned i) + { + char s[1 + 3 * sizeof(unsigned)]; + numberToString(i, s); + _o << s; + return *this; + } + }; +}; +} + +#endif // __cxxtest__ErrorPrinter_h__ diff --git a/third-party/cxxtest/cxxtest/Flags.h b/third-party/cxxtest/cxxtest/Flags.h new file mode 100644 index 00000000..54e9858d --- /dev/null +++ b/third-party/cxxtest/cxxtest/Flags.h @@ -0,0 +1,154 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__Flags_h__ +#define __cxxtest__Flags_h__ + +// +// These are the flags that control CxxTest +// + +#if !defined(CXXTEST_FLAGS) +# define CXXTEST_FLAGS +#endif // !CXXTEST_FLAGS + +#if defined(CXXTEST_HAVE_EH) && !defined(_CXXTEST_HAVE_EH) +# define _CXXTEST_HAVE_EH +#endif // CXXTEST_HAVE_EH + +#if defined(CXXTEST_HAVE_STD) && !defined(_CXXTEST_HAVE_STD) +# define _CXXTEST_HAVE_STD +#endif // CXXTEST_HAVE_STD + +#if defined(CXXTEST_OLD_TEMPLATE_SYNTAX) && !defined(_CXXTEST_OLD_TEMPLATE_SYNTAX) +# define _CXXTEST_OLD_TEMPLATE_SYNTAX +#endif // CXXTEST_OLD_TEMPLATE_SYNTAX + +#if defined(CXXTEST_OLD_STD) && !defined(_CXXTEST_OLD_STD) +# define _CXXTEST_OLD_STD +#endif // CXXTEST_OLD_STD + +#if defined(CXXTEST_ABORT_TEST_ON_FAIL) && !defined(_CXXTEST_ABORT_TEST_ON_FAIL) +# define _CXXTEST_ABORT_TEST_ON_FAIL +#endif // CXXTEST_ABORT_TEST_ON_FAIL + +#if defined(CXXTEST_NO_COPY_CONST) && !defined(_CXXTEST_NO_COPY_CONST) +# define _CXXTEST_NO_COPY_CONST +#endif // CXXTEST_NO_COPY_CONST + +#if defined(CXXTEST_FACTOR) && !defined(_CXXTEST_FACTOR) +# define _CXXTEST_FACTOR +#endif // CXXTEST_FACTOR + +#if defined(CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION) && !defined(_CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION) +# define _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +#endif // CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION + +#if defined(CXXTEST_LONGLONG) +# if defined(_CXXTEST_LONGLONG) +# undef _CXXTEST_LONGLONG +# endif +# define _CXXTEST_LONGLONG CXXTEST_LONGLONG +#endif // CXXTEST_LONGLONG + +#ifndef CXXTEST_MAX_DUMP_SIZE +# define CXXTEST_MAX_DUMP_SIZE 0 +#endif // CXXTEST_MAX_DUMP_SIZE + +#if defined(_CXXTEST_ABORT_TEST_ON_FAIL) && !defined(CXXTEST_DEFAULT_ABORT) +# define CXXTEST_DEFAULT_ABORT true +#endif // _CXXTEST_ABORT_TEST_ON_FAIL && !CXXTEST_DEFAULT_ABORT + +#if !defined(CXXTEST_DEFAULT_ABORT) +# define CXXTEST_DEFAULT_ABORT false +#endif // !CXXTEST_DEFAULT_ABORT + +#if defined(_CXXTEST_ABORT_TEST_ON_FAIL) && !defined(_CXXTEST_HAVE_EH) +# warning "CXXTEST_ABORT_TEST_ON_FAIL is meaningless without CXXTEST_HAVE_EH" +# undef _CXXTEST_ABORT_TEST_ON_FAIL +#endif // _CXXTEST_ABORT_TEST_ON_FAIL && !_CXXTEST_HAVE_EH + +// +// Some minimal per-compiler configuration to allow us to compile +// + +#ifdef __BORLANDC__ +# if __BORLANDC__ <= 0x520 // Borland C++ 5.2 or earlier +# ifndef _CXXTEST_OLD_STD +# define _CXXTEST_OLD_STD +# endif +# ifndef _CXXTEST_OLD_TEMPLATE_SYNTAX +# define _CXXTEST_OLD_TEMPLATE_SYNTAX +# endif +# endif +# if __BORLANDC__ >= 0x540 // C++ Builder 4.0 or later +# ifndef _CXXTEST_NO_COPY_CONST +# define _CXXTEST_NO_COPY_CONST +# endif +# ifndef _CXXTEST_LONGLONG +# define _CXXTEST_LONGLONG __int64 +# endif +# endif +#endif // __BORLANDC__ + +#ifdef _MSC_VER // Visual C++ +# ifndef _CXXTEST_LONGLONG +# define _CXXTEST_LONGLONG __int64 +# endif +# if (_MSC_VER >= 0x51E) +# ifndef _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +# define _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +# endif +# endif +# pragma warning( disable : 4127 ) +# pragma warning( disable : 4290 ) +# pragma warning( disable : 4511 ) +# pragma warning( disable : 4512 ) +# pragma warning( disable : 4514 ) +#endif // _MSC_VER + +#ifdef __GNUC__ +# if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 9) +# ifndef _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +# define _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +# endif +# endif +# if defined(__LONG_LONG_MAX__) && !defined(__cplusplus) +# define _CXXTEST_LONGLONG long long +# endif +#endif // __GNUC__ + +#ifdef __DMC__ // Digital Mars +# ifndef _CXXTEST_OLD_STD +# define _CXXTEST_OLD_STD +# endif +#endif + +#ifdef __SUNPRO_CC // Sun Studio C++ +# if __SUNPRO_CC >= 0x510 +# ifndef _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +# define _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +# endif +# endif +#endif + +#ifdef __xlC__ // IBM XL C/C++ +// Partial specialization may be supported before 7.0.0.3, but it is +// definitely supported after. +# if __xlC__ >= 0x0700 +# ifndef _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +# define _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +# endif +# endif +#endif + +#endif // __cxxtest__Flags_h__ + diff --git a/third-party/cxxtest/cxxtest/GlobalFixture.cpp b/third-party/cxxtest/cxxtest/GlobalFixture.cpp new file mode 100644 index 00000000..c3bea78f --- /dev/null +++ b/third-party/cxxtest/cxxtest/GlobalFixture.cpp @@ -0,0 +1,34 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__GlobalFixture_cpp__ +#define __cxxtest__GlobalFixture_cpp__ + +#include + +namespace CxxTest +{ +bool GlobalFixture::setUpWorld() { return true; } +bool GlobalFixture::tearDownWorld() { return true; } +bool GlobalFixture::setUp() { return true; } +bool GlobalFixture::tearDown() { return true; } + +GlobalFixture::GlobalFixture() { attach(_list); } +GlobalFixture::~GlobalFixture() { detach(_list); } + +GlobalFixture *GlobalFixture::firstGlobalFixture() { return (GlobalFixture *)_list.head(); } +GlobalFixture *GlobalFixture::lastGlobalFixture() { return (GlobalFixture *)_list.tail(); } +GlobalFixture *GlobalFixture::nextGlobalFixture() { return (GlobalFixture *)next(); } +GlobalFixture *GlobalFixture::prevGlobalFixture() { return (GlobalFixture *)prev(); } +} + +#endif // __cxxtest__GlobalFixture_cpp__ + diff --git a/third-party/cxxtest/cxxtest/GlobalFixture.h b/third-party/cxxtest/cxxtest/GlobalFixture.h new file mode 100644 index 00000000..c969fd93 --- /dev/null +++ b/third-party/cxxtest/cxxtest/GlobalFixture.h @@ -0,0 +1,41 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__GlobalFixture_h__ +#define __cxxtest__GlobalFixture_h__ + +#include + +namespace CxxTest +{ +class GlobalFixture : public Link +{ +public: + virtual bool setUpWorld(); + virtual bool tearDownWorld(); + virtual bool setUp(); + virtual bool tearDown(); + + GlobalFixture(); + virtual ~GlobalFixture(); + + static GlobalFixture *firstGlobalFixture(); + static GlobalFixture *lastGlobalFixture(); + GlobalFixture *nextGlobalFixture(); + GlobalFixture *prevGlobalFixture(); + +private: + static List _list; +}; +} + +#endif // __cxxtest__GlobalFixture_h__ + diff --git a/third-party/cxxtest/cxxtest/Gui.h b/third-party/cxxtest/cxxtest/Gui.h new file mode 100644 index 00000000..253ed627 --- /dev/null +++ b/third-party/cxxtest/cxxtest/Gui.h @@ -0,0 +1,199 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __CXXTEST__GUI_H +#define __CXXTEST__GUI_H + +// +// GuiListener is a simple base class for the differes GUIs +// GuiTuiRunner combines a GUI with a text-mode error formatter +// + +#include + +namespace CxxTest +{ +class GuiListener : public TestListener +{ +public: + GuiListener() : _state(GREEN_BAR) {} + virtual ~GuiListener() {} + + virtual void runGui(int &argc, char **argv, TestListener &listener) + { + enterGui(argc, argv); + TestRunner::runAllTests(listener); + leaveGui(); + } + + virtual void enterGui(int & /*argc*/, char ** /*argv*/) {} + virtual void leaveGui() {} + + // + // The easy way is to implement these functions: + // + virtual void guiEnterWorld(unsigned /*numTotalTests*/) {} + virtual void guiEnterSuite(const char * /*suiteName*/) {} + virtual void guiEnterTest(const char * /*suiteName*/, const char * /*testName*/) {} + virtual void yellowBar() {} + virtual void redBar() {} + + // + // The hard way is this: + // + void enterWorld(const WorldDescription &d) { guiEnterWorld(d.numTotalTests()); } + void enterSuite(const SuiteDescription &d) { guiEnterSuite(d.suiteName()); } + void enterTest(const TestDescription &d) { guiEnterTest(d.suiteName(), d.testName()); } + void leaveTest(const TestDescription &) {} + void leaveSuite(const SuiteDescription &) {} + void leaveWorld(const WorldDescription &) {} + + void warning(const char * /*file*/, int /*line*/, const char * /*expression*/) + { + yellowBarSafe(); + } + + void skippedTest(const char * /*file*/, int /*line*/, const char * /*expression*/) + { + yellowBarSafe(); + } + + void failedTest(const char * /*file*/, int /*line*/, const char * /*expression*/) + { + redBarSafe(); + } + + void failedAssert(const char * /*file*/, int /*line*/, const char * /*expression*/) + { + redBarSafe(); + } + + void failedAssertEquals(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*x*/, const char * /*y*/) + { + redBarSafe(); + } + + void failedAssertSameData(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*sizeStr*/, const void * /*x*/, + const void * /*y*/, unsigned /*size*/) + { + redBarSafe(); + } + + void failedAssertDelta(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, const char * /*dStr*/, + const char * /*x*/, const char * /*y*/, const char * /*d*/) + { + redBarSafe(); + } + + void failedAssertDiffers(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*value*/) + { + redBarSafe(); + } + + void failedAssertLessThan(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*x*/, const char * /*y*/) + { + redBarSafe(); + } + + void failedAssertLessThanEquals(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*x*/, const char * /*y*/) + { + redBarSafe(); + } + + void failedAssertPredicate(const char * /*file*/, int /*line*/, + const char * /*predicate*/, const char * /*xStr*/, const char * /*x*/) + { + redBarSafe(); + } + + void failedAssertRelation(const char * /*file*/, int /*line*/, + const char * /*relation*/, const char * /*xStr*/, const char * /*yStr*/, + const char * /*x*/, const char * /*y*/) + { + redBarSafe(); + } + + void failedAssertThrows(const char * /*file*/, int /*line*/, + const char * /*expression*/, const char * /*type*/, + bool /*otherThrown*/) + { + redBarSafe(); + } + + void failedAssertThrowsNot(const char * /*file*/, int /*line*/, + const char * /*expression*/) + { + redBarSafe(); + } + +protected: + void yellowBarSafe() + { + if (_state < YELLOW_BAR) + { + yellowBar(); + _state = YELLOW_BAR; + } + } + + void redBarSafe() + { + if (_state < RED_BAR) + { + redBar(); + _state = RED_BAR; + } + } + +private: + enum { GREEN_BAR, YELLOW_BAR, RED_BAR } _state; +}; + +template +class GuiTuiRunner : public TeeListener +{ + int* _argc; + char **_argv; + GuiT _gui; + TuiT _tui; + +public: + GuiTuiRunner() : _argc(0), _argv(0) {} + + void process_commandline(int& argc, char** argv) + { + _argc = &argc; + _argv = argv; + setFirst(_gui); + setSecond(_tui); + } + + int run() + { + _gui.runGui(*_argc, _argv, *this); + return tracker().failedTests(); + } +}; +} + +#endif //__CXXTEST__GUI_H + diff --git a/third-party/cxxtest/cxxtest/LinkedList.cpp b/third-party/cxxtest/cxxtest/LinkedList.cpp new file mode 100644 index 00000000..223e4d9b --- /dev/null +++ b/third-party/cxxtest/cxxtest/LinkedList.cpp @@ -0,0 +1,221 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__LinkedList_cpp__ +#define __cxxtest__LinkedList_cpp__ + +#include + +namespace CxxTest +{ +List GlobalFixture::_list = { 0, 0 }; +List RealSuiteDescription::_suites = { 0, 0 }; + +void List::initialize() +{ + _head = _tail = 0; +} + +Link *List::head() +{ + Link *l = _head; + while (l && !l->active()) + { + l = l->next(); + } + return l; +} + +const Link *List::head() const +{ + Link *l = _head; + while (l && !l->active()) + { + l = l->next(); + } + return l; +} + +Link *List::tail() +{ + Link *l = _tail; + while (l && !l->active()) + { + l = l->prev(); + } + return l; +} + +const Link *List::tail() const +{ + Link *l = _tail; + while (l && !l->active()) + { + l = l->prev(); + } + return l; +} + +bool List::empty() const +{ + return (_head == 0); +} + +unsigned List::size() const +{ + unsigned count = 0; + for (const Link *l = head(); l != 0; l = l->next()) + { + ++ count; + } + return count; +} + +Link *List::nth(unsigned n) +{ + Link *l = head(); + while (n --) + { + l = l->next(); + } + return l; +} + +void List::activateAll() +{ + for (Link *l = _head; l != 0; l = l->justNext()) + { + l->setActive(true); + } +} + +void List::leaveOnly(const Link &link) +{ + for (Link *l = head(); l != 0; l = l->next()) + { + if (l != &link) + { + l->setActive(false); + } + } +} + +Link::Link() : + _next(0), + _prev(0), + _active(true) +{ +} + +Link::~Link() +{ +} + +bool Link::active() const +{ + return _active; +} + +void Link::setActive(bool value) +{ + _active = value; +} + +Link * Link::justNext() +{ + return _next; +} + +Link * Link::justPrev() +{ + return _prev; +} + +Link * Link::next() +{ + Link *l = _next; + while (l && !l->_active) + { + l = l->_next; + } + return l; +} + +Link * Link::prev() +{ + Link *l = _prev; + while (l && !l->_active) + { + l = l->_prev; + } + return l; +} + +const Link * Link::next() const +{ + Link *l = _next; + while (l && !l->_active) + { + l = l->_next; + } + return l; +} + +const Link * Link::prev() const +{ + Link *l = _prev; + while (l && !l->_active) + { + l = l->_prev; + } + return l; +} + +void Link::attach(List &l) +{ + if (l._tail) + { + l._tail->_next = this; + } + + _prev = l._tail; + _next = 0; + + if (l._head == 0) + { + l._head = this; + } + l._tail = this; +} + +void Link::detach(List &l) +{ + if (_prev) + { + _prev->_next = _next; + } + else + { + l._head = _next; + } + + if (_next) + { + _next->_prev = _prev; + } + else + { + l._tail = _prev; + } +} +} + +#endif // __cxxtest__LinkedList_cpp__ diff --git a/third-party/cxxtest/cxxtest/LinkedList.h b/third-party/cxxtest/cxxtest/LinkedList.h new file mode 100644 index 00000000..d2fced11 --- /dev/null +++ b/third-party/cxxtest/cxxtest/LinkedList.h @@ -0,0 +1,73 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__LinkedList_h__ +#define __cxxtest__LinkedList_h__ + +#include + +namespace CxxTest +{ +struct List; +class Link; + +struct List +{ + Link *_head; + Link *_tail; + + void initialize(); + + Link *head(); + const Link *head() const; + Link *tail(); + const Link *tail() const; + + bool empty() const; + unsigned size() const; + Link *nth(unsigned n); + + void activateAll(); + void leaveOnly(const Link &link); +}; + +class Link +{ +public: + Link(); + virtual ~Link(); + + bool active() const; + void setActive(bool value = true); + + Link *justNext(); + Link *justPrev(); + + Link *next(); + Link *prev(); + const Link *next() const; + const Link *prev() const; + + void attach(List &l); + void detach(List &l); + +private: + Link *_next; + Link *_prev; + bool _active; + + Link(const Link &); + Link &operator=(const Link &); +}; +} + +#endif // __cxxtest__LinkedList_h__ + diff --git a/third-party/cxxtest/cxxtest/MSVCErrorPrinter.h b/third-party/cxxtest/cxxtest/MSVCErrorPrinter.h new file mode 100644 index 00000000..845d7041 --- /dev/null +++ b/third-party/cxxtest/cxxtest/MSVCErrorPrinter.h @@ -0,0 +1,40 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__MSVCErrorPrinter_h__ +#define __cxxtest__MSVCErrorPrinter_h__ + +// +// The MSVCErrorPrinter is identical to the ErrorPrinter, except it +// prints the line number and error/warning strings in a format +// consistent with that generated by Microsoft's compiler. +// +// Strict error parsers (e.g. QtCreator's) expect each error to be +// followed by a proper-looking error code, so give them one to make +// them work. Same for warnings. +// +// C2999 : "Unknown error" from Visual Studio 6, no longer used. +// C4999 : "Unknown warning" from Visual Studio 6, no longer used. +// + +#include + +namespace CxxTest +{ +class MSVCErrorPrinter : public ErrorPrinter +{ +public: + MSVCErrorPrinter(CXXTEST_STD(ostream) &o = CXXTEST_STD(cout)) + : ErrorPrinter(o, "(", ") ", "error C2999", "warning C4999") {} +}; +} + +#endif // __cxxtest__MSVCErrorPrinter_h__ diff --git a/third-party/cxxtest/cxxtest/Mock.h b/third-party/cxxtest/cxxtest/Mock.h new file mode 100644 index 00000000..2ba2a436 --- /dev/null +++ b/third-party/cxxtest/cxxtest/Mock.h @@ -0,0 +1,380 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__Mock_h__ +#define __cxxtest__Mock_h__ + +namespace dummy_mock_ns {} + +// +// The default namespace is T:: +// +#ifndef CXXTEST_MOCK_NAMESPACE +# define CXXTEST_MOCK_NAMESPACE T +#endif // CXXTEST_MOCK_NAMESPACE + +// +// MockTraits: What to return when no mock object has been created +// +#define __CXXTEST_MOCK__TRAITS \ + namespace CXXTEST_MOCK_NAMESPACE \ + { \ + template \ + class MockTraits \ + { \ + public: \ + static T defaultValue() { return 0; } \ + }; \ + } + +// +// extern "C" when needed +// +#ifdef __cplusplus +# define CXXTEST_EXTERN_C extern "C" +#else +# define CXXTEST_EXTERN_C +#endif // __cplusplus + +// +// Prototypes: For "normal" headers +// +#define __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + namespace CXXTEST_MOCK_NAMESPACE { TYPE NAME ARGS; } + +#define __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__PROTOTYPE( MOCK, void, NAME, ARGS, REAL, CALL ) + +#define __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + TYPE REAL ARGS; + +#define __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY__PROTOTYPE( MOCK, void, NAME, ARGS, REAL, CALL ) + +// +// Class declarations: For test files +// +#define __CXXTEST_MOCK__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + namespace CXXTEST_MOCK_NAMESPACE { \ + class Base_##MOCK : public CxxTest::Link \ + { \ + public: \ + Base_##MOCK(); \ + ~Base_##MOCK(); \ + bool setUp(); \ + bool tearDown(); \ + \ + static Base_##MOCK ¤t(); \ + \ + virtual TYPE NAME ARGS = 0; \ + \ + private: \ + static CxxTest::List _list; \ + }; \ + \ + class Real_##MOCK : public Base_##MOCK \ + { \ + public: \ + TYPE NAME ARGS; \ + }; \ + \ + class _Unimplemented_##MOCK : public Base_##MOCK \ + { \ + public: \ + TYPE NAME ARGS; \ + }; \ + } + +#define __CXXTEST_MOCK_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__CLASS_DECLARATION( MOCK, void, NAME, ARGS, REAL, CALL ) + +#define __CXXTEST_SUPPLY__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + namespace CXXTEST_MOCK_NAMESPACE { \ + class Base_##MOCK : public CxxTest::Link \ + { \ + public: \ + Base_##MOCK(); \ + ~Base_##MOCK(); \ + bool setUp(); \ + bool tearDown(); \ + \ + static Base_##MOCK ¤t(); \ + \ + virtual TYPE NAME ARGS = 0; \ + \ + private: \ + static CxxTest::List _list; \ + }; \ + \ + class _Unimplemented_##MOCK : public Base_##MOCK \ + { \ + public: \ + TYPE NAME ARGS; \ + }; \ + } + +#define __CXXTEST_SUPPLY_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY__CLASS_DECLARATION( MOCK, void, NAME, ARGS, REAL, CALL ) + +// +// Class implementation: For test source files +// +#define __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \ + namespace CXXTEST_MOCK_NAMESPACE { \ + \ + CxxTest::List Base_##MOCK::_list = { 0, 0 }; \ + \ + Base_##MOCK::Base_##MOCK() { attach( _list ); } \ + Base_##MOCK::~Base_##MOCK() { detach( _list ); } \ + bool Base_##MOCK::setUp() { return true; } \ + bool Base_##MOCK::tearDown() { return true; } \ + \ + Base_##MOCK &Base_##MOCK::current() \ + { \ + if ( _list.empty() ) { \ + static _Unimplemented_##MOCK unimplemented; \ + } \ + return *(Base_##MOCK *)_list.tail(); \ + } \ + } + +#define __CXXTEST_MOCK__CLASS_IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \ + namespace CXXTEST_MOCK_NAMESPACE { \ + TYPE Real_##MOCK::NAME ARGS \ + { \ + return REAL CALL; \ + } \ + \ + TYPE _Unimplemented_##MOCK::NAME ARGS \ + { \ + while ( false ) {\ + return NAME CALL; \ + } \ + __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ); \ + return MockTraits::defaultValue(); \ + } \ + \ + TYPE NAME ARGS \ + { \ + return Base_##MOCK::current().NAME CALL; \ + } \ + } + +#define __CXXTEST_MOCK_VOID__CLASS_IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \ + namespace CXXTEST_MOCK_NAMESPACE { \ + void Real_##MOCK::NAME ARGS \ + { \ + REAL CALL; \ + } \ + \ + void _Unimplemented_##MOCK::NAME ARGS \ + { \ + while ( false ) { \ + NAME CALL; \ + } \ + __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ); \ + } \ + \ + void NAME ARGS \ + { \ + Base_##MOCK::current().NAME CALL; \ + } \ + } + +#define __CXXTEST_SUPPLY__CLASS_IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \ + namespace CXXTEST_MOCK_NAMESPACE { \ + TYPE _Unimplemented_##MOCK::NAME ARGS \ + { \ + while ( false ) { \ + return NAME CALL; \ + } \ + __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ); \ + return MockTraits::defaultValue(); \ + } \ + } \ + \ + TYPE REAL ARGS \ + { \ + return CXXTEST_MOCK_NAMESPACE::Base_##MOCK::current().NAME CALL; \ + } + +#define __CXXTEST_SUPPLY_VOID__CLASS_IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \ + namespace CXXTEST_MOCK_NAMESPACE { \ + void _Unimplemented_##MOCK::NAME ARGS \ + { \ + while ( false ) { \ + NAME CALL; \ + } \ + __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ); \ + } \ + } \ + \ + void REAL ARGS \ + { \ + CXXTEST_MOCK_NAMESPACE::Base_##MOCK::current().NAME CALL; \ + } \ + +// +// Error for calling mock function w/o object +// +#define __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ) \ + TS_FAIL( CXXTEST_MOCK_NAMESPACE_STR #NAME #ARGS " called with no " \ + CXXTEST_MOCK_NAMESPACE_STR "Base_" #NAME " object" ); \ + +#define CXXTEST_MOCK_NAMESPACE_STR __CXXTEST_STR(CXXTEST_MOCK_NAMESPACE) "::" +#define __CXXTEST_STR(X) __CXXTEST_XSTR(X) +#define __CXXTEST_XSTR(X) #X + +#if defined(CXXTEST_MOCK_TEST_SOURCE_FILE) +// +// Test source file: Prototypes, class declarations and implementation +// +#include + +__CXXTEST_MOCK__TRAITS + +#define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__CLASS_IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK_VOID__CLASS_IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#define CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY__CLASS_IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#define CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY_VOID__CLASS_IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#elif defined(CXXTEST_FLAGS) || defined(CXXTEST_RUNNING) +// +// Test file other than source: Prototypes and class declarations +// +#include + +__CXXTEST_MOCK__TRAITS; + +#define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#define CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#define CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#elif defined(CXXTEST_MOCK_REAL_SOURCE_FILE) +// +// Real source file: "Real" implementations +// +#define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + namespace CXXTEST_MOCK_NAMESPACE { TYPE NAME ARGS { return REAL CALL; } } using namespace dummy_mock_ns + +#define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \ + namespace CXXTEST_MOCK_NAMESPACE { void NAME ARGS { REAL CALL; } } using namespace dummy_mock_ns + +#else +// +// Ordinary header file: Just prototypes +// + +#define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#define CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#define CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL ) \ + __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \ + using namespace dummy_mock_ns + +#endif // Ordinary header file + +// +// How to supply extern "C" functions +// +#define CXXTEST_SUPPLY_C( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + CXXTEST_EXTERN_C __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \ + CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL ) + +#define CXXTEST_SUPPLY_VOID_C( MOCK, NAME, ARGS, REAL, CALL ) \ + CXXTEST_EXTERN_C __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \ + CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL ) + +// +// Usually we mean the global namespace +// +#define CXXTEST_MOCK_GLOBAL( TYPE, NAME, ARGS, CALL ) \ + CXXTEST_MOCK( NAME, TYPE, NAME, ARGS, ::NAME, CALL ) + +#define CXXTEST_MOCK_VOID_GLOBAL( NAME, ARGS, CALL ) \ + CXXTEST_MOCK_VOID( NAME, NAME, ARGS, ::NAME, CALL ) + +#define CXXTEST_SUPPLY_GLOBAL( TYPE, NAME, ARGS, CALL ) \ + CXXTEST_SUPPLY( NAME, TYPE, NAME, ARGS, NAME, CALL ) + +#define CXXTEST_SUPPLY_VOID_GLOBAL( NAME, ARGS, CALL ) \ + CXXTEST_SUPPLY_VOID( NAME, NAME, ARGS, NAME, CALL ) + +#define CXXTEST_SUPPLY_GLOBAL_C( TYPE, NAME, ARGS, CALL ) \ + CXXTEST_SUPPLY_C( NAME, TYPE, NAME, ARGS, NAME, CALL ) + +#define CXXTEST_SUPPLY_VOID_GLOBAL_C( NAME, ARGS, CALL ) \ + CXXTEST_SUPPLY_VOID_C( NAME, NAME, ARGS, NAME, CALL ) + +// +// What to return when no mock object has been created. +// The default value of 0 usually works, but some cases may need this. +// +#define CXXTEST_MOCK_DEFAULT_VALUE( TYPE, VALUE ) \ + namespace CXXTEST_MOCK_NAMESPACE \ + { \ + template<> \ + class MockTraits \ + { \ + public: \ + static TYPE defaultValue() { return VALUE; } \ + }; \ + } using namespace dummy_mock_ns + +#endif // __cxxtest__Mock_h__ diff --git a/third-party/cxxtest/cxxtest/ParenPrinter.h b/third-party/cxxtest/cxxtest/ParenPrinter.h new file mode 100644 index 00000000..3a114af6 --- /dev/null +++ b/third-party/cxxtest/cxxtest/ParenPrinter.h @@ -0,0 +1,32 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__ParenPrinter_h__ +#define __cxxtest__ParenPrinter_h__ + +// +// The ParenPrinter is identical to the ErrorPrinter, except it +// prints the line number in a format expected by some compilers +// (notably, MSVC). +// + +#include + +namespace CxxTest +{ +class ParenPrinter : public ErrorPrinter +{ +public: + ParenPrinter(CXXTEST_STD(ostream) &o = CXXTEST_STD(cout)) : ErrorPrinter(o, "(", ")") {} +}; +} + +#endif // __cxxtest__ParenPrinter_h__ diff --git a/third-party/cxxtest/cxxtest/QtGui.h b/third-party/cxxtest/cxxtest/QtGui.h new file mode 100644 index 00000000..589c2327 --- /dev/null +++ b/third-party/cxxtest/cxxtest/QtGui.h @@ -0,0 +1,306 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__QtGui_h__ +#define __cxxtest__QtGui_h__ + +// +// The QtGui displays a simple progress bar using the Qt Toolkit. It +// has been tested with versions 2.x and 3.x. +// +// Apart from normal Qt command-line arguments, it accepts the following options: +// -minimized Start minimized, pop up on error +// -keep Don't close the window at the end +// -title TITLE Set the window caption +// +// If both are -minimized and -keep specified, GUI will only keep the +// window if it's in focus. +// + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace CxxTest +{ +class QtGui : public GuiListener +{ +public: + void enterGui(int &argc, char **argv) + { + parseCommandLine(argc, argv); + createApplication(argc, argv); + } + + void enterWorld(const WorldDescription &wd) + { + createWindow(wd); + processEvents(); + } + + void guiEnterSuite(const char *suiteName) + { + showSuiteName(suiteName); + } + + void guiEnterTest(const char *suiteName, const char *testName) + { + setCaption(suiteName, testName); + advanceProgressBar(); + showTestName(testName); + showTestsDone(_progressBar->progress()); + processEvents(); + } + + void yellowBar() + { + setColor(255, 255, 0); + setIcon(QMessageBox::Warning); + getTotalTests(); + processEvents(); + } + + void redBar() + { + if (_startMinimized && _mainWindow->isMinimized()) + { + showNormal(); + } + setColor(255, 0, 0); + setIcon(QMessageBox::Critical); + getTotalTests(); + processEvents(); + } + + void leaveGui() + { + if (keep()) + { + showSummary(); + _application->exec(); + } + else + { + _mainWindow->close(true); + } + } + +private: + QString _title; + bool _startMinimized, _keep; + unsigned _numTotalTests; + QString _strTotalTests; + QApplication *_application; + QWidget *_mainWindow; + QVBoxLayout *_layout; + QProgressBar *_progressBar; + QStatusBar *_statusBar; + QLabel *_suiteName, *_testName, *_testsDone; + + void parseCommandLine(int argc, char **argv) + { + _startMinimized = _keep = false; + _title = argv[0]; + + for (int i = 1; i < argc; ++ i) + { + QString arg(argv[i]); + if (arg == "-minimized") + { + _startMinimized = true; + } + else if (arg == "-keep") + { + _keep = true; + } + else if (arg == "-title" && (i + 1 < argc)) + { + _title = argv[++i]; + } + } + } + + void createApplication(int &argc, char **argv) + { + _application = new QApplication(argc, argv); + } + + void createWindow(const WorldDescription &wd) + { + getTotalTests(wd); + createMainWindow(); + createProgressBar(); + createStatusBar(); + setMainWidget(); + if (_startMinimized) + { + showMinimized(); + } + else + { + showNormal(); + } + } + + void getTotalTests() + { + getTotalTests(tracker().world()); + } + + void getTotalTests(const WorldDescription &wd) + { + _numTotalTests = wd.numTotalTests(); + char s[WorldDescription::MAX_STRLEN_TOTAL_TESTS]; + _strTotalTests = wd.strTotalTests(s); + } + + void createMainWindow() + { + _mainWindow = new QWidget(); + _layout = new QVBoxLayout(_mainWindow); + } + + void createProgressBar() + { + _layout->addWidget(_progressBar = new QProgressBar(_numTotalTests, _mainWindow)); + _progressBar->setProgress(0); + setColor(0, 255, 0); + setIcon(QMessageBox::Information); + } + + void createStatusBar() + { + _layout->addWidget(_statusBar = new QStatusBar(_mainWindow)); + _statusBar->addWidget(_suiteName = new QLabel(_statusBar), 2); + _statusBar->addWidget(_testName = new QLabel(_statusBar), 4); + _statusBar->addWidget(_testsDone = new QLabel(_statusBar), 1); + } + + void setMainWidget() + { + _application->setMainWidget(_mainWindow); + } + + void showMinimized() + { + _mainWindow->showMinimized(); + } + + void showNormal() + { + _mainWindow->showNormal(); + centerWindow(); + } + + void setCaption(const QString &suiteName, const QString &testName) + { + _mainWindow->setCaption(_title + " - " + suiteName + "::" + testName + "()"); + } + + void showSuiteName(const QString &suiteName) + { + _suiteName->setText("class " + suiteName); + } + + void advanceProgressBar() + { + _progressBar->setProgress(_progressBar->progress() + 1); + } + + void showTestName(const QString &testName) + { + _testName->setText(testName + "()"); + } + + void showTestsDone(unsigned testsDone) + { + _testsDone->setText(asString(testsDone) + " of " + _strTotalTests); + } + + static QString asString(unsigned n) + { + return QString::number(n); + } + + void setColor(int r, int g, int b) + { + QPalette palette = _progressBar->palette(); + palette.setColor(QColorGroup::Highlight, QColor(r, g, b)); + _progressBar->setPalette(palette); + } + + void setIcon(QMessageBox::Icon icon) + { +#if QT_VERSION >= 0x030000 + _mainWindow->setIcon(QMessageBox::standardIcon(icon)); +#else // Qt version < 3.0.0 + _mainWindow->setIcon(QMessageBox::standardIcon(icon, QApplication::style().guiStyle())); +#endif // QT_VERSION + } + + void processEvents() + { + _application->processEvents(); + } + + void centerWindow() + { + QWidget *desktop = QApplication::desktop(); + int xCenter = desktop->x() + (desktop->width() / 2); + int yCenter = desktop->y() + (desktop->height() / 2); + + int windowWidth = (desktop->width() * 4) / 5; + int windowHeight = _mainWindow->height(); + _mainWindow->setGeometry(xCenter - (windowWidth / 2), yCenter - (windowHeight / 2), windowWidth, windowHeight); + } + + bool keep() + { + if (!_keep) + { + return false; + } + if (!_startMinimized) + { + return true; + } + return (_mainWindow == _application->activeWindow()); + } + + void showSummary() + { + QString summary = _strTotalTests + (_numTotalTests == 1 ? " test" : " tests"); + if (tracker().failedTests()) + { + summary = "Failed " + asString(tracker().failedTests()) + " of " + summary; + } + else + { + summary = summary + " passed"; + } + + _mainWindow->setCaption(_title + " - " + summary); + + _statusBar->removeWidget(_suiteName); + _statusBar->removeWidget(_testName); + _testsDone->setText(summary); + } +}; +} + +#endif // __cxxtest__QtGui_h__ diff --git a/third-party/cxxtest/cxxtest/RealDescriptions.cpp b/third-party/cxxtest/cxxtest/RealDescriptions.cpp new file mode 100644 index 00000000..60b4f205 --- /dev/null +++ b/third-party/cxxtest/cxxtest/RealDescriptions.cpp @@ -0,0 +1,361 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__RealDescriptions_cpp__ +#define __cxxtest__RealDescriptions_cpp__ + +// +// NOTE: If an error occur during world construction/deletion, CxxTest cannot +// know where the error originated. +// + +#include + +namespace CxxTest +{ +RealTestDescription::RealTestDescription() +{ +} + +RealTestDescription::RealTestDescription(List &argList, + SuiteDescription &argSuite, + unsigned argLine, + const char *argTestName) +{ + initialize(argList, argSuite, argLine, argTestName); +} + +void RealTestDescription::initialize(List &argList, + SuiteDescription &argSuite, + unsigned argLine, + const char *argTestName) +{ + _suite = &argSuite; + _line = argLine; + _testName = argTestName; + attach(argList); +} + +bool RealTestDescription::setUp() +{ + if (!suite()) + { + return false; + } + + for (GlobalFixture *gf = GlobalFixture::firstGlobalFixture(); gf != 0; gf = gf->nextGlobalFixture()) + { + bool ok; + _TS_TRY { ok = gf->setUp(); } + _TS_LAST_CATCH( { ok = false; }); + + if (!ok) + { + doFailTest(file(), line(), "Error in GlobalFixture::setUp()"); + return false; + } + } + + _TS_TRY + { + bool ok = false; + _TSM_ASSERT_THROWS_NOTHING(file(), line(), "Exception thrown from setUp()", suite()->setUp(); ok = true); + if (ok == false) { return ok; } + } + _TS_CATCH_ABORT( { return false; }) + _TS_CATCH_SKIPPED( { return false; }); + + return true; +} + +bool RealTestDescription::tearDown() +{ + if (!suite()) + { + return false; + } + + _TS_TRY + { + _TSM_ASSERT_THROWS_NOTHING(file(), line(), "Exception thrown from tearDown()", suite()->tearDown()); + } + _TS_CATCH_ABORT( { return false; }) + _TS_CATCH_SKIPPED( { return false; }); + + for (GlobalFixture *gf = GlobalFixture::lastGlobalFixture(); gf != 0; gf = gf->prevGlobalFixture()) + { + bool ok; + _TS_TRY { ok = gf->tearDown(); } + _TS_LAST_CATCH( { ok = false; }); + + if (!ok) + { + doFailTest(file(), line(), "Error in GlobalFixture::tearDown()"); + return false; + } + } + + return true; +} + +const char *RealTestDescription::file() const { return _suite->file(); } +int RealTestDescription::line() const { return _line; } +const char *RealTestDescription::testName() const { return _testName; } +const char *RealTestDescription::suiteName() const { return _suite->suiteName(); } + +TestDescription *RealTestDescription::next() { return (RealTestDescription *)Link::next(); } +const TestDescription *RealTestDescription::next() const { return (const RealTestDescription *)Link::next(); } + +TestSuite *RealTestDescription::suite() const { return _suite->suite(); } + +void RealTestDescription::run() +{ + _TS_TRY { runTest(); } + _TS_CATCH_ABORT( {}) + _TS_CATCH_SKIPPED( {}) + ___TSM_CATCH(file(), line(), "Exception thrown from test"); +} + +RealSuiteDescription::RealSuiteDescription() {} +RealSuiteDescription::RealSuiteDescription(const char *argFile, + unsigned argLine, + const char *argSuiteName, + List &argTests) +{ + initialize(argFile, argLine, argSuiteName, argTests); +} + +void RealSuiteDescription::initialize(const char *argFile, + unsigned argLine, + const char *argSuiteName, + List &argTests) +{ + _file = argFile; + _line = argLine; + _suiteName = argSuiteName; + _tests = &argTests; + + attach(_suites); +} + +const char *RealSuiteDescription::file() const { return _file; } +int RealSuiteDescription::line() const { return _line; } +const char *RealSuiteDescription::suiteName() const { return _suiteName; } + +TestDescription *RealSuiteDescription::firstTest() { return (RealTestDescription *)_tests->head(); } +const TestDescription *RealSuiteDescription::firstTest() const { return (const RealTestDescription *)_tests->head(); } +SuiteDescription *RealSuiteDescription::next() { return (RealSuiteDescription *)Link::next(); } +const SuiteDescription *RealSuiteDescription::next() const { return (const RealSuiteDescription *)Link::next(); } + +unsigned RealSuiteDescription::numTests() const { return _tests->size(); } + +const TestDescription &RealSuiteDescription::testDescription(unsigned i) const +{ + return *(RealTestDescription *)_tests->nth(i); +} + +void RealSuiteDescription::activateAllTests() +{ + _tests->activateAll(); +} + +bool RealSuiteDescription::leaveOnly(const char *testName) +{ + for (TestDescription *td = firstTest(); td != 0; td = td->next()) + { + if (stringsEqual(td->testName(), testName)) + { + _tests->leaveOnly(*td); + return true; + } + } + return false; +} + +StaticSuiteDescription::StaticSuiteDescription() {} +StaticSuiteDescription::StaticSuiteDescription(const char *argFile, unsigned argLine, + const char *argSuiteName, TestSuite &argSuite, + List &argTests) : + RealSuiteDescription(argFile, argLine, argSuiteName, argTests) +{ + doInitialize(argSuite); +} + +void StaticSuiteDescription::initialize(const char *argFile, unsigned argLine, + const char *argSuiteName, TestSuite &argSuite, + List &argTests) +{ + RealSuiteDescription::initialize(argFile, argLine, argSuiteName, argTests); + doInitialize(argSuite); +} + +void StaticSuiteDescription::doInitialize(TestSuite &argSuite) +{ + _suite = &argSuite; +} + +TestSuite *StaticSuiteDescription::suite() const +{ + return _suite; +} + +bool StaticSuiteDescription::setUp() { return true; } +bool StaticSuiteDescription::tearDown() { return true; } + +CommonDynamicSuiteDescription::CommonDynamicSuiteDescription() {} +CommonDynamicSuiteDescription::CommonDynamicSuiteDescription(const char *argFile, unsigned argLine, + const char *argSuiteName, List &argTests, + unsigned argCreateLine, unsigned argDestroyLine) : + RealSuiteDescription(argFile, argLine, argSuiteName, argTests) +{ + doInitialize(argCreateLine, argDestroyLine); +} + +void CommonDynamicSuiteDescription::initialize(const char *argFile, unsigned argLine, + const char *argSuiteName, List &argTests, + unsigned argCreateLine, unsigned argDestroyLine) +{ + RealSuiteDescription::initialize(argFile, argLine, argSuiteName, argTests); + doInitialize(argCreateLine, argDestroyLine); +} + +void CommonDynamicSuiteDescription::doInitialize(unsigned argCreateLine, unsigned argDestroyLine) +{ + _createLine = argCreateLine; + _destroyLine = argDestroyLine; +} + +List &RealWorldDescription::suites() +{ + return RealSuiteDescription::_suites; +} + +unsigned RealWorldDescription::numSuites(void) const +{ + return suites().size(); +} + +unsigned RealWorldDescription::numTotalTests(void) const +{ + unsigned count = 0; + for (const SuiteDescription *sd = firstSuite(); sd != 0; sd = sd->next()) + { + count += sd->numTests(); + } + return count; +} + +SuiteDescription *RealWorldDescription::firstSuite() +{ + return (RealSuiteDescription *)suites().head(); +} + +const SuiteDescription *RealWorldDescription::firstSuite() const +{ + return (const RealSuiteDescription *)suites().head(); +} + +const SuiteDescription &RealWorldDescription::suiteDescription(unsigned i) const +{ + return *(const RealSuiteDescription *)suites().nth(i); +} + +void RealWorldDescription::activateAllTests() +{ + suites().activateAll(); + for (SuiteDescription *sd = firstSuite(); sd != 0; sd = sd->next()) + { + sd->activateAllTests(); + } +} + +bool RealWorldDescription::leaveOnly(const char *suiteName, const char *testName) +{ + for (SuiteDescription *sd = firstSuite(); sd != 0; sd = sd->next()) + { + if (stringsEqual(sd->suiteName(), suiteName)) + { + if (testName) + { + if (!sd->leaveOnly(testName)) + { + return false; + } + } + suites().leaveOnly(*sd); + return true; + } + } + return false; +} + +bool RealWorldDescription::setUp() +{ + for (GlobalFixture *gf = GlobalFixture::firstGlobalFixture(); gf != 0; gf = gf->nextGlobalFixture()) + { + bool ok; + _TS_TRY + { + ok = gf->setUpWorld(); + if (tracker().testFailed()) + { + tracker().initialize(); + ok = false; + } + } + _TS_LAST_CATCH( { ok = false; }); + + if (!ok) + { + reportError("Error setting up world"); + return false; + } + } + + return true; +} + +bool RealWorldDescription::tearDown() +{ + for (GlobalFixture *gf = GlobalFixture::lastGlobalFixture(); gf != 0; gf = gf->prevGlobalFixture()) + { + bool ok; + _TS_TRY { ok = gf->tearDownWorld(); } + _TS_LAST_CATCH( { ok = false; }); + + if (!ok) + { + reportError("Error tearing down world"); + return false; + } + } + + return true; +} + +void RealWorldDescription::reportError(const char *message) +{ + doWarn(__FILE__, 5, message); +} + +void activateAllTests() +{ + RealWorldDescription().activateAllTests(); +} + +bool leaveOnly(const char *suiteName, const char *testName) +{ + return RealWorldDescription().leaveOnly(suiteName, testName); +} +} + +#endif // __cxxtest__RealDescriptions_cpp__ + diff --git a/third-party/cxxtest/cxxtest/RealDescriptions.h b/third-party/cxxtest/cxxtest/RealDescriptions.h new file mode 100644 index 00000000..48b6d9ed --- /dev/null +++ b/third-party/cxxtest/cxxtest/RealDescriptions.h @@ -0,0 +1,243 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__RealDescriptions_h__ +#define __cxxtest__RealDescriptions_h__ + +// +// The "real" description classes +// + +#include +#include +#include + +namespace CxxTest +{ +class RealTestDescription : public TestDescription +{ +public: + RealTestDescription(); + RealTestDescription(List &argList, SuiteDescription &argSuite, unsigned argLine, const char *argTestName); + void initialize(List &argList, SuiteDescription &argSuite, unsigned argLine, const char *argTestName); + + const char *file() const; + int line() const; + const char *testName() const; + const char *suiteName() const; + + TestDescription *next(); + const TestDescription *next() const; + + TestSuite *suite() const; + + bool setUp(); + void run(); + bool tearDown(); + +private: + RealTestDescription(const RealTestDescription &); + RealTestDescription &operator=(const RealTestDescription &); + + virtual void runTest() = 0; + + SuiteDescription *_suite; + int _line; + const char *_testName; +}; + +class RealSuiteDescription : public SuiteDescription +{ +public: + RealSuiteDescription(); + RealSuiteDescription(const char *argFile, unsigned argLine, const char *argSuiteName, List &argTests); + + void initialize(const char *argFile, unsigned argLine, const char *argSuiteName, List &argTests); + + const char *file() const; + int line() const; + const char *suiteName() const; + + TestDescription *firstTest(); + const TestDescription *firstTest() const; + SuiteDescription *next(); + const SuiteDescription *next() const; + + unsigned numTests() const; + const TestDescription &testDescription(unsigned i) const; + + void activateAllTests(); + bool leaveOnly(const char *testName); + +private: + RealSuiteDescription(const RealSuiteDescription &); + RealSuiteDescription &operator=(const RealSuiteDescription &); + + const char *_file; + int _line; + const char *_suiteName; + List *_tests; + + static List _suites; + friend class RealWorldDescription; +}; + +class StaticSuiteDescription : public RealSuiteDescription +{ +public: + StaticSuiteDescription(); + StaticSuiteDescription(const char *argFile, unsigned argLine, + const char *argSuiteName, TestSuite &argSuite, + List &argTests); + + void initialize(const char *argFile, unsigned argLine, + const char *argSuiteName, TestSuite &argSuite, + List &argTests); + TestSuite *suite() const; + + bool setUp(); + bool tearDown(); + +private: + StaticSuiteDescription(const StaticSuiteDescription &); + StaticSuiteDescription &operator=(const StaticSuiteDescription &); + + void doInitialize(TestSuite &argSuite); + + TestSuite *_suite; +}; + +class CommonDynamicSuiteDescription : public RealSuiteDescription +{ +public: + CommonDynamicSuiteDescription(); + CommonDynamicSuiteDescription(const char *argFile, unsigned argLine, + const char *argSuiteName, List &argTests, + unsigned argCreateLine, unsigned argDestroyLine); + + void initialize(const char *argFile, unsigned argLine, + const char *argSuiteName, List &argTests, + unsigned argCreateLine, unsigned argDestroyLine); + +protected: + unsigned _createLine, _destroyLine; + +private: + void doInitialize(unsigned argCreateLine, unsigned argDestroyLine); +}; + +template +class DynamicSuiteDescription : public CommonDynamicSuiteDescription +{ +public: + DynamicSuiteDescription() {} + DynamicSuiteDescription(const char *argFile, unsigned argLine, + const char *argSuiteName, List &argTests, + S *&argSuite, unsigned argCreateLine, + unsigned argDestroyLine) : + CommonDynamicSuiteDescription(argFile, argLine, argSuiteName, argTests, argCreateLine, argDestroyLine) + { + _suite = &argSuite; + } + + void initialize(const char *argFile, unsigned argLine, + const char *argSuiteName, List &argTests, + S *&argSuite, unsigned argCreateLine, + unsigned argDestroyLine) + { + CommonDynamicSuiteDescription::initialize(argFile, argLine, + argSuiteName, argTests, + argCreateLine, argDestroyLine); + _suite = &argSuite; + } + + TestSuite *suite() const { return realSuite(); } + + bool setUp(); + bool tearDown(); + +private: + S *realSuite() const { return *_suite; } + void setSuite(S *s) { *_suite = s; } + + void createSuite() + { + setSuite(S::createSuite()); + } + + void destroySuite() + { + S *s = realSuite(); + setSuite(0); + S::destroySuite(s); + } + + S **_suite; +}; + +template +bool DynamicSuiteDescription::setUp() +{ + _TS_TRY + { + _TSM_ASSERT_THROWS_NOTHING(file(), _createLine, "Exception thrown from createSuite()", createSuite()); + _TSM_ASSERT(file(), _createLine, "createSuite() failed", suite() != 0); + } + _TS_CATCH_ABORT( { return false; }) + _TS_CATCH_SKIPPED( { return false; }); + + return (suite() != 0); +} + +template +bool DynamicSuiteDescription::tearDown() +{ + if (!_suite) + { + return true; + } + + _TS_TRY + { + _TSM_ASSERT_THROWS_NOTHING(file(), _destroyLine, "destroySuite() failed", destroySuite()); + } + _TS_CATCH_ABORT( { return false; }) + _TS_CATCH_SKIPPED( { return false; }); + + return true; +} + +class RealWorldDescription : public WorldDescription +{ +public: + static List &suites(); + const char *worldName() const { return _worldName;} + unsigned numSuites(void) const; + unsigned numTotalTests(void) const; + SuiteDescription *firstSuite(); + const SuiteDescription *firstSuite() const; + const SuiteDescription &suiteDescription(unsigned i) const; + void activateAllTests(); + bool leaveOnly(const char *suiteName, const char *testName = 0); + + bool setUp(); + bool tearDown(); + static void reportError(const char *message); + + static const char *_worldName; +}; + +void activateAllTests(); +bool leaveOnly(const char *suiteName, const char *testName = 0); +} + +#endif // __cxxtest__RealDescriptions_h__ + diff --git a/third-party/cxxtest/cxxtest/Root.cpp b/third-party/cxxtest/cxxtest/Root.cpp new file mode 100644 index 00000000..39aa599a --- /dev/null +++ b/third-party/cxxtest/cxxtest/Root.cpp @@ -0,0 +1,29 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__Root_cpp__ +#define __cxxtest__Root_cpp__ + +// +// This file holds the "root" of CxxTest, i.e. +// the parts that must be in a source file file. +// + +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // __cxxtest__Root_cpp__ diff --git a/third-party/cxxtest/cxxtest/SelfTest.h b/third-party/cxxtest/cxxtest/SelfTest.h new file mode 100644 index 00000000..3951ac2c --- /dev/null +++ b/third-party/cxxtest/cxxtest/SelfTest.h @@ -0,0 +1,18 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest_SelfTest_h__ +#define __cxxtest_SelfTest_h__ + +#define CXXTEST_SUITE(name) +#define CXXTEST_CODE(member) + +#endif // __cxxtest_SelfTest_h__ diff --git a/third-party/cxxtest/cxxtest/StdHeaders.h b/third-party/cxxtest/cxxtest/StdHeaders.h new file mode 100644 index 00000000..7866a752 --- /dev/null +++ b/third-party/cxxtest/cxxtest/StdHeaders.h @@ -0,0 +1,36 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest_StdHeaders_h__ +#define __cxxtest_StdHeaders_h__ + +// +// This file basically #includes the STL headers. +// It exists to support warning level 4 in Visual C++ +// + +#ifdef _MSC_VER +# pragma warning( push, 1 ) +#endif // _MSC_VER + +#include +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +# pragma warning( pop ) +#endif // _MSC_VER + +#endif // __cxxtest_StdHeaders_h__ diff --git a/third-party/cxxtest/cxxtest/StdTestSuite.h b/third-party/cxxtest/cxxtest/StdTestSuite.h new file mode 100644 index 00000000..c9b2bcc3 --- /dev/null +++ b/third-party/cxxtest/cxxtest/StdTestSuite.h @@ -0,0 +1,70 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__StdTestSuite_h__ +#define __cxxtest__StdTestSuite_h__ + +// +// This provides explicit partial specializations for STL-based +// TestSuite comparison functions +// + +namespace CxxTest +{ + +#ifdef _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION + +template +struct delta, std::vector, D> +{ + static bool test(std::vector x, std::vector y, D d) + { + if (x.size() != y.size()) + { + return false; + } + for (size_t i = 0; i < x.size(); ++i) + if (! delta::test(x[i], y[i], d)) + { + return false; + } + return true; + } +}; + +template +struct delta, std::list, D> +{ + static bool test(std::list x, std::list y, D d) + { + typename std::list::const_iterator x_it = x.begin(); + typename std::list::const_iterator y_it = y.begin(); + for (; x_it != x.end(); ++x_it, ++y_it) + { + if (y_it == y.end()) + { + return false; + } + if (! delta::test(*x_it, *y_it, d)) + { + return false; + } + } + return y_it == y.end(); + } +}; + +#endif + +} // namespace CxxTest + +#endif // __cxxtest__StdTestSuite_h__ + diff --git a/third-party/cxxtest/cxxtest/StdValueTraits.h b/third-party/cxxtest/cxxtest/StdValueTraits.h new file mode 100644 index 00000000..552c5081 --- /dev/null +++ b/third-party/cxxtest/cxxtest/StdValueTraits.h @@ -0,0 +1,303 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest_StdValueTraits_h__ +#define __cxxtest_StdValueTraits_h__ + +// +// This file defines ValueTraits for std:: stuff. +// It is #included by if you +// define CXXTEST_HAVE_STD +// + +#include +#include + +#ifdef _CXXTEST_OLD_STD +# define CXXTEST_STD(x) x +#else // !_CXXTEST_OLD_STD +# define CXXTEST_STD(x) std::x +#endif // _CXXTEST_OLD_STD + +#ifndef CXXTEST_USER_VALUE_TRAITS + +namespace CxxTest +{ +// +// NOTE: This should have been +// template +// class ValueTraits< std::basic_string > {}; +// But MSVC doesn't support it (yet). +// + +// +// If we have std::string, we might as well use it +// +class StdTraitsBase +{ +public: + StdTraitsBase &operator<<(const CXXTEST_STD(string) &s) { _s += s; return *this; } + const char *asString() const { return _s.c_str(); } + +private: + CXXTEST_STD(string) _s; +}; + +// +// std::string +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits : public StdTraitsBase +{ + static bool mb_partial(char ch) + { + return !!(ch & 0x80); + } + static bool mb_start(char ch) + { + return (ch & 0xC0) == 0xC0; + } + static size_t mb_length(char ch) + { + size_t numBytes = 1; + while ((ch & (1 << (7 - numBytes))) && numBytes < 6) + { + ++numBytes; + } + return numBytes; + } + static bool is_mb(const CXXTEST_STD(string) &s, unsigned i) + { + if (!mb_start(s[i]) || i + mb_length(s[i]) > s.length()) + { + return false; + } + for (size_t len = mb_length(s[i]); len > 0; -- len, ++ i) + { + if (!mb_partial(s[i])) + { + return false; + } + } + return true; + } + +public: + ValueTraits(const CXXTEST_STD(string) &s) + { + *this << "\""; + for (unsigned i = 0; i < s.length(); ++ i) + { + if (is_mb(s, i)) + { + for (size_t len = mb_length(s[i]); len > 0; -- len, ++ i) + { + char c[2] = { s[i], '\0' }; + *this << c; + } + -- i; + } + else + { + char c[sizeof("\\xXX")]; + charToString(s[i], c); + *this << c; + } + } + *this << "\""; + } +}; + +CXXTEST_COPY_CONST_TRAITS(CXXTEST_STD(string)); + +#ifndef _CXXTEST_OLD_STD +// +// std::wstring +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits)> : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(basic_string) &s) + { + *this << "L\""; + for (unsigned i = 0; i < s.length(); ++ i) + { + char c[sizeof("\\x12345678")]; + charToString((unsigned long)s[i], c); + *this << c; + } + *this << "\""; + } +}; + +CXXTEST_COPY_CONST_TRAITS(CXXTEST_STD(basic_string)); +#endif // _CXXTEST_OLD_STD + +// +// Convert a range defined by iterators to a string +// This is useful for almost all STL containers +// +template +void dumpRange(Stream &s, Iterator first, Iterator last) +{ + if (first == last) + { + s << "{}"; + return; + } + + s << "{ "; + while (first != last) + { + s << TS_AS_STRING(*first); + if (++ first != last) + { + s << ", "; + } + } + s << " }"; +} + +#ifdef _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +// +// std::pair +// +template +class ValueTraits< CXXTEST_STD(pair) > : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(pair) &p) + { + *this << "<" << TS_AS_STRING(p.first) << ", " << TS_AS_STRING(p.second) << ">"; + } +}; + +// +// std::vector +// +template +class ValueTraits< CXXTEST_STD(vector) > : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(vector) &v) + { + dumpRange(*this, v.begin(), v.end()); + } +}; + +// +// std::list +// +template +class ValueTraits< CXXTEST_STD(list) > : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(list) &l) + { + dumpRange(*this, l.begin(), l.end()); + } +}; + +// +// std::set +// +template +class ValueTraits< CXXTEST_STD(set) > : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(set) &s) + { + dumpRange(*this, s.begin(), s.end()); + } +}; + +// +// std::map +// +template +class ValueTraits< CXXTEST_STD(map) > : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(map) &m) + { + dumpRange(*this, m.begin(), m.end()); + } +}; + +// +// std::deque +// +template +class ValueTraits< CXXTEST_STD(deque) > : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(deque) &d) + { + dumpRange(*this, d.begin(), d.end()); + } +}; + +// +// std::multiset +// +template +class ValueTraits< CXXTEST_STD(multiset) > : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(multiset) &ms) + { + dumpRange(*this, ms.begin(), ms.end()); + } +}; + +// +// std::multimap +// +template +class ValueTraits< CXXTEST_STD(multimap) > : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(multimap) &mm) + { + dumpRange(*this, mm.begin(), mm.end()); + } +}; + +// +// std::complex +// +template +class ValueTraits< CXXTEST_STD(complex) > : public StdTraitsBase +{ +public: + ValueTraits(const CXXTEST_STD(complex) &c) + { + if (!c.imag()) + { + *this << TS_AS_STRING(c.real()); + } + else if (!c.real()) + { + *this << "(" << TS_AS_STRING(c.imag()) << " * i)"; + } + else + { + *this << "(" << TS_AS_STRING(c.real()) << " + " << TS_AS_STRING(c.imag()) << " * i)"; + } + } +}; +#endif // _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION +} + +#endif // CXXTEST_USER_VALUE_TRAITS + +#endif // __cxxtest_StdValueTraits_h__ diff --git a/third-party/cxxtest/cxxtest/StdioFilePrinter.h b/third-party/cxxtest/cxxtest/StdioFilePrinter.h new file mode 100644 index 00000000..e293e1cb --- /dev/null +++ b/third-party/cxxtest/cxxtest/StdioFilePrinter.h @@ -0,0 +1,52 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__StdioFilePrinter_h__ +#define __cxxtest__StdioFilePrinter_h__ + +// +// The StdioFilePrinter is a simple TestListener that +// just prints "OK" if everything goes well, otherwise +// reports the error in the format of compiler messages. +// This class uses , i.e. FILE * and fprintf(). +// + +#include +#include + +namespace CxxTest +{ +class StdioFilePrinter : public ErrorFormatter +{ +public: + StdioFilePrinter(FILE *o, const char *preLine = ":", const char *postLine = "") : + ErrorFormatter(new Adapter(o), preLine, postLine) {} + virtual ~StdioFilePrinter() { delete outputStream(); } + +private: + class Adapter : public OutputStream + { + Adapter(const Adapter &); + Adapter &operator=(const Adapter &); + + FILE *_o; + + public: + Adapter(FILE *o) : _o(o) {} + void flush() { fflush(_o); } + OutputStream &operator<<(unsigned i) { fprintf(_o, "%u", i); return *this; } + OutputStream &operator<<(const char *s) { fputs(s, _o); return *this; } + OutputStream &operator<<(Manipulator m) { return OutputStream::operator<<(m); } + }; +}; +} + +#endif // __cxxtest__StdioFilePrinter_h__ diff --git a/third-party/cxxtest/cxxtest/StdioPrinter.h b/third-party/cxxtest/cxxtest/StdioPrinter.h new file mode 100644 index 00000000..55c9fcc3 --- /dev/null +++ b/third-party/cxxtest/cxxtest/StdioPrinter.h @@ -0,0 +1,33 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__StdioPrinter_h__ +#define __cxxtest__StdioPrinter_h__ + +// +// The StdioPrinter is an StdioFilePrinter which defaults to stdout. +// This should have been called StdOutPrinter or something, but the name +// has been historically used. +// + +#include + +namespace CxxTest +{ +class StdioPrinter : public StdioFilePrinter +{ +public: + StdioPrinter(FILE *o = stdout, const char *preLine = ":", const char *postLine = "") : + StdioFilePrinter(o, preLine, postLine) {} +}; +} + +#endif // __cxxtest__StdioPrinter_h__ diff --git a/third-party/cxxtest/cxxtest/TeeListener.h b/third-party/cxxtest/cxxtest/TeeListener.h new file mode 100644 index 00000000..06ca0a7e --- /dev/null +++ b/third-party/cxxtest/cxxtest/TeeListener.h @@ -0,0 +1,205 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__TeeListener_h__ +#define __cxxtest__TeeListener_h__ + +// +// A TeeListener notifies two "regular" TestListeners +// + +#include +#include + +namespace CxxTest +{ +class TeeListener : public TestListener +{ +public: + TeeListener() + { + setFirst(_dummy); + setSecond(_dummy); + } + + virtual ~TeeListener() + { + } + + void setFirst(TestListener &first) + { + _first = &first; + } + + void setSecond(TestListener &second) + { + _second = &second; + } + + void enterWorld(const WorldDescription &d) + { + _first->enterWorld(d); + _second->enterWorld(d); + } + + void enterSuite(const SuiteDescription &d) + { + _first->enterSuite(d); + _second->enterSuite(d); + } + + void enterTest(const TestDescription &d) + { + _first->enterTest(d); + _second->enterTest(d); + } + + void trace(const char *file, int line, const char *expression) + { + _first->trace(file, line, expression); + _second->trace(file, line, expression); + } + + void warning(const char *file, int line, const char *expression) + { + _first->warning(file, line, expression); + _second->warning(file, line, expression); + } + + void skippedTest(const char *file, int line, const char *expression) + { + _first->skippedTest(file, line, expression); + _second->skippedTest(file, line, expression); + } + + void failedTest(const char *file, int line, const char *expression) + { + _first->failedTest(file, line, expression); + _second->failedTest(file, line, expression); + } + + void failedAssert(const char *file, int line, const char *expression) + { + _first->failedAssert(file, line, expression); + _second->failedAssert(file, line, expression); + } + + void failedAssertEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + _first->failedAssertEquals(file, line, xStr, yStr, x, y); + _second->failedAssertEquals(file, line, xStr, yStr, x, y); + } + + void failedAssertSameData(const char *file, int line, + const char *xStr, const char *yStr, + const char *sizeStr, const void *x, + const void *y, unsigned size) + { + _first->failedAssertSameData(file, line, xStr, yStr, sizeStr, x, y, size); + _second->failedAssertSameData(file, line, xStr, yStr, sizeStr, x, y, size); + } + + void failedAssertSameFiles(const char* file, int line, const char* file1, const char* file2, const char* explanation) + { + _first->failedAssertSameFiles(file, line, file1, file2, explanation); + _second->failedAssertSameFiles(file, line, file1, file2, explanation); + } + + void failedAssertDelta(const char *file, int line, + const char *xStr, const char *yStr, const char *dStr, + const char *x, const char *y, const char *d) + { + _first->failedAssertDelta(file, line, xStr, yStr, dStr, x, y, d); + _second->failedAssertDelta(file, line, xStr, yStr, dStr, x, y, d); + } + + void failedAssertDiffers(const char *file, int line, + const char *xStr, const char *yStr, + const char *value) + { + _first->failedAssertDiffers(file, line, xStr, yStr, value); + _second->failedAssertDiffers(file, line, xStr, yStr, value); + } + + void failedAssertLessThan(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + _first->failedAssertLessThan(file, line, xStr, yStr, x, y); + _second->failedAssertLessThan(file, line, xStr, yStr, x, y); + } + + void failedAssertLessThanEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + _first->failedAssertLessThanEquals(file, line, xStr, yStr, x, y); + _second->failedAssertLessThanEquals(file, line, xStr, yStr, x, y); + } + + void failedAssertPredicate(const char *file, int line, + const char *predicate, const char *xStr, const char *x) + { + _first->failedAssertPredicate(file, line, predicate, xStr, x); + _second->failedAssertPredicate(file, line, predicate, xStr, x); + } + + void failedAssertRelation(const char *file, int line, + const char *relation, const char *xStr, const char *yStr, + const char *x, const char *y) + { + _first->failedAssertRelation(file, line, relation, xStr, yStr, x, y); + _second->failedAssertRelation(file, line, relation, xStr, yStr, x, y); + } + + void failedAssertThrows(const char *file, int line, + const char *expression, const char *type, + bool otherThrown) + { + _first->failedAssertThrows(file, line, expression, type, otherThrown); + _second->failedAssertThrows(file, line, expression, type, otherThrown); + } + + void failedAssertThrowsNot(const char *file, int line, + const char *expression) + { + _first->failedAssertThrowsNot(file, line, expression); + _second->failedAssertThrowsNot(file, line, expression); + } + + void leaveTest(const TestDescription &d) + { + _first->leaveTest(d); + _second->leaveTest(d); + } + + void leaveSuite(const SuiteDescription &d) + { + _first->leaveSuite(d); + _second->leaveSuite(d); + } + + void leaveWorld(const WorldDescription &d) + { + _first->leaveWorld(d); + _second->leaveWorld(d); + } + +private: + TestListener *_first, *_second; + TestListener _dummy; +}; +} + + +#endif // __cxxtest__TeeListener_h__ diff --git a/third-party/cxxtest/cxxtest/TestListener.h b/third-party/cxxtest/cxxtest/TestListener.h new file mode 100644 index 00000000..dbc2365e --- /dev/null +++ b/third-party/cxxtest/cxxtest/TestListener.h @@ -0,0 +1,87 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__TestListener_h__ +#define __cxxtest__TestListener_h__ + +// +// TestListener is the base class for all "listeners", +// i.e. classes that receive notifications of the +// testing process. +// +// The names of the parameters are in comments to avoid +// "unused parameter" warnings. +// + +#include + +namespace CxxTest +{ +class TestListener +{ +public: + TestListener() {} + virtual ~TestListener() {} + virtual void process_commandline(int& /*argc*/, char** /*argv*/) {} + + virtual void enterWorld(const WorldDescription & /*desc*/) {} + virtual void enterSuite(const SuiteDescription & /*desc*/) {} + virtual void enterTest(const TestDescription & /*desc*/) {} + virtual void trace(const char * /*file*/, int /*line*/, + const char * /*expression*/) {} + virtual void warning(const char * /*file*/, int /*line*/, + const char * /*expression*/) {} + virtual void skippedTest(const char * /*file*/, int /*line*/, + const char * /*expression*/) {} + virtual void failedTest(const char * /*file*/, int /*line*/, + const char * /*expression*/) {} + virtual void failedAssert(const char * /*file*/, int /*line*/, + const char * /*expression*/) {} + virtual void failedAssertEquals(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*x*/, const char * /*y*/) {} + virtual void failedAssertSameData(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*sizeStr*/, const void * /*x*/, + const void * /*y*/, unsigned /*size*/) {} + virtual void failedAssertDelta(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*dStr*/, const char * /*x*/, + const char * /*y*/, const char * /*d*/) {} + virtual void failedAssertDiffers(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*value*/) {} + virtual void failedAssertLessThan(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*x*/, const char * /*y*/) {} + virtual void failedAssertLessThanEquals(const char * /*file*/, int /*line*/, + const char * /*xStr*/, const char * /*yStr*/, + const char * /*x*/, const char * /*y*/) {} + virtual void failedAssertPredicate(const char * /*file*/, int /*line*/, + const char * /*predicate*/, const char * /*xStr*/, const char * /*x*/) {} + virtual void failedAssertRelation(const char * /*file*/, int /*line*/, + const char * /*relation*/, const char * /*xStr*/, const char * /*yStr*/, + const char * /*x*/, const char * /*y*/) {} + virtual void failedAssertThrows(const char * /*file*/, int /*line*/, + const char * /*expression*/, const char * /*type*/, + bool /*otherThrown*/) {} + virtual void failedAssertThrowsNot(const char * /*file*/, int /*line*/, + const char * /*expression*/) {} + virtual void failedAssertSameFiles(const char* /*file*/, int /*line*/, + const char* , const char*, const char*) {} + virtual void leaveTest(const TestDescription & /*desc*/) {} + virtual void leaveSuite(const SuiteDescription & /*desc*/) {} + virtual void leaveWorld(const WorldDescription & /*desc*/) {} +}; +} + +#endif // __cxxtest__TestListener_h__ + diff --git a/third-party/cxxtest/cxxtest/TestMain.h b/third-party/cxxtest/cxxtest/TestMain.h new file mode 100644 index 00000000..c4d14bb6 --- /dev/null +++ b/third-party/cxxtest/cxxtest/TestMain.h @@ -0,0 +1,133 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __CxxTestMain_h +#define __CxxTestMain_h + +#include +#include + +#ifndef _CXXTEST_HAVE_STD +# define _CXXTEST_HAVE_STD +#endif // _CXXTEST_HAVE_STD + +#include + +#if defined(_CXXTEST_HAVE_STD) +#ifdef _CXXTEST_OLD_STD +# include +# include +#else // !_CXXTEST_OLD_STD +# include +# include +#endif // _CXXTEST_OLD_STD + +namespace CxxTest +{ + +inline void print_help(const char* name) +{ + CXXTEST_STD(cerr) << name << " " << CXXTEST_STD(endl); + CXXTEST_STD(cerr) << name << " " << CXXTEST_STD(endl); + CXXTEST_STD(cerr) << name << " -h" << CXXTEST_STD(endl); + CXXTEST_STD(cerr) << name << " --help" << CXXTEST_STD(endl); + CXXTEST_STD(cerr) << name << " --help-tests" << CXXTEST_STD(endl); + CXXTEST_STD(cerr) << name << " -v Enable tracing output." << CXXTEST_STD(endl); +} +#endif + + +template +int Main(TesterT& tmp, int argc, char* argv[]) +{ +// +// Parse the command-line arguments. The default behavior is to run all tests +// +// This is a primitive parser, but I'm not sure what sort of portable +// parser should be used in cxxtest. +// + +#if defined(_CXXTEST_HAVE_STD) +// +// Print command-line syntax +// + for (int i = 1; i < argc; i++) + { + if ((CXXTEST_STD(strcmp)(argv[i], "-h") == 0) || (CXXTEST_STD(strcmp)(argv[i], "--help") == 0)) + { + print_help(argv[0]); + return 0; + } + else if ((CXXTEST_STD(strcmp)(argv[1], "--help-tests") == 0)) + { + CXXTEST_STD(cout) << "Suite/Test Names" << CXXTEST_STD(endl); + CXXTEST_STD(cout) << "---------------------------------------------------------------------------" << CXXTEST_STD(endl); + for (SuiteDescription *sd = RealWorldDescription().firstSuite(); sd; sd = sd->next()) + for (TestDescription *td = sd->firstTest(); td; td = td->next()) + { + CXXTEST_STD(cout) << td->suiteName() << " " << td->testName() << CXXTEST_STD(endl); + } + return 0; + } + } + +// +// Process command-line options here. +// + while ((argc > 1) && (argv[1][0] == '-')) + { + if (CXXTEST_STD(strcmp)(argv[1], "-v") == 0) + { + tracker().print_tracing = true; + } + else + { + CXXTEST_STD(cerr) << "ERROR: unknown option '" << argv[1] << "'" << CXXTEST_STD(endl); + return -1; + } + for (int i = 1; i < (argc - 1); i++) + { + argv[i] = argv[i + 1]; + } + argc--; + } + +// +// Run experiments +// + bool status = false; + if ((argc == 2) && (argv[1][0] != '-')) + { + status = leaveOnly(argv[1]); + if (!status) + { + CXXTEST_STD(cerr) << "ERROR: unknown suite '" << argv[1] << "'" << CXXTEST_STD(endl); + return -1; + } + } + if ((argc == 3) && (argv[1][0] != '-')) + { + status = leaveOnly(argv[1], argv[2]); + if (!status) + { + CXXTEST_STD(cerr) << "ERROR: unknown test '" << argv[1] << "::" << argv[2] << "'" << CXXTEST_STD(endl); + return -1; + } + } +#endif + + tmp.process_commandline(argc, argv); + return tmp.run(); +} + +} +#endif + diff --git a/third-party/cxxtest/cxxtest/TestRunner.h b/third-party/cxxtest/cxxtest/TestRunner.h new file mode 100644 index 00000000..25ff3f8e --- /dev/null +++ b/third-party/cxxtest/cxxtest/TestRunner.h @@ -0,0 +1,154 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest_TestRunner_h__ +#define __cxxtest_TestRunner_h__ + +// +// TestRunner is the class that runs all the tests. +// To use it, create an object that implements the TestListener +// interface and call TestRunner::runAllTests( myListener ); +// + +#include +#include +#include +#include + +namespace CxxTest +{ +class TestRunner +{ +public: + + static void setListener(TestListener* listener) + { + tracker().setListener(listener); + } + + static void runAllTests(TestListener &listener) + { + tracker().setListener(&listener); + _TS_TRY { TestRunner().runWorld(); } + _TS_LAST_CATCH( { tracker().failedTest(__FILE__, __LINE__, "Exception thrown from world"); }); + tracker().setListener(0); + } + + static void runAllTests(TestListener *listener) + { + if (listener) + { + listener->warning(__FILE__, __LINE__, "Deprecated; Use runAllTests( TestListener & )"); + runAllTests(*listener); + } + } + +private: + void runWorld() + { + RealWorldDescription wd; + WorldGuard sg; + + tracker().enterWorld(wd); + if (wd.setUp()) + { + for (SuiteDescription *sd = wd.firstSuite(); sd; sd = sd->next()) + { + if (sd->active()) + { + runSuite(*sd); + } + } + + wd.tearDown(); + } + tracker().leaveWorld(wd); + } + + void runSuite(SuiteDescription &sd) + { + StateGuard sg; + + tracker().enterSuite(sd); + if (sd.setUp()) + { + for (TestDescription *td = sd.firstTest(); td; td = td->next()) + { + if (td->active()) + { + runTest(*td); + } + } + + sd.tearDown(); + } + tracker().leaveSuite(sd); + } + + void runTest(TestDescription &td) + { + StateGuard sg; + + tracker().enterTest(td); + if (td.setUp()) + { + td.run(); + td.tearDown(); + } + tracker().leaveTest(td); + } + + class StateGuard + { +#ifdef _CXXTEST_HAVE_EH + bool _abortTestOnFail; +#endif // _CXXTEST_HAVE_EH + unsigned _maxDumpSize; + + public: + StateGuard() + { +#ifdef _CXXTEST_HAVE_EH + _abortTestOnFail = abortTestOnFail(); +#endif // _CXXTEST_HAVE_EH + _maxDumpSize = maxDumpSize(); + } + + ~StateGuard() + { +#ifdef _CXXTEST_HAVE_EH + setAbortTestOnFail(_abortTestOnFail); +#endif // _CXXTEST_HAVE_EH + setMaxDumpSize(_maxDumpSize); + } + }; + + class WorldGuard : public StateGuard + { + public: + WorldGuard() : StateGuard() + { +#ifdef _CXXTEST_HAVE_EH + setAbortTestOnFail(CXXTEST_DEFAULT_ABORT); +#endif // _CXXTEST_HAVE_EH + setMaxDumpSize(CXXTEST_MAX_DUMP_SIZE); + } + }; +}; + +// +// For --no-static-init +// +void initialize(); +} + + +#endif // __cxxtest_TestRunner_h__ diff --git a/third-party/cxxtest/cxxtest/TestSuite.cpp b/third-party/cxxtest/cxxtest/TestSuite.cpp new file mode 100644 index 00000000..63dbf1f1 --- /dev/null +++ b/third-party/cxxtest/cxxtest/TestSuite.cpp @@ -0,0 +1,317 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__TestSuite_cpp__ +#define __cxxtest__TestSuite_cpp__ + +#include +#if defined(_CXXTEST_HAVE_STD) +#include +#endif + +namespace CxxTest +{ +// +// TestSuite members +// +TestSuite::~TestSuite() {} +void TestSuite::setUp() {} +void TestSuite::tearDown() {} + +// +// Test-aborting stuff +// +static bool currentAbortTestOnFail = false; + +bool abortTestOnFail() +{ + return currentAbortTestOnFail; +} + +void setAbortTestOnFail(bool value) +{ + currentAbortTestOnFail = value; +} + +void doAbortTest() +{ +# if defined(_CXXTEST_HAVE_EH) + if (currentAbortTestOnFail) + { + throw AbortTest(); + } +# endif // _CXXTEST_HAVE_EH +} + +// +// Max dump size +// +static unsigned currentMaxDumpSize = CXXTEST_MAX_DUMP_SIZE; + +unsigned maxDumpSize() +{ + return currentMaxDumpSize; +} + +void setMaxDumpSize(unsigned value) +{ + currentMaxDumpSize = value; +} + +// +// Some non-template functions +// +void doTrace(const char *file, int line, const char *message) +{ + if (tracker().print_tracing) + { + tracker().trace(file, line, message); + } +} + +void doWarn(const char *file, int line, const char *message) +{ + tracker().warning(file, line, message); +} + +# if defined(_CXXTEST_HAVE_EH) +void doSkipTest(const char* file, int line, const char* message) +{ + tracker().skippedTest(file, line, message); + throw SkipTest(); +# else +void doSkipTest(const char * file, int line, const char*) +{ + doWarn(file, line, "Test skipping is not supported without exception handling."); +# endif +} + +void doFailTest(const char * file, int line, const char * message) +{ + tracker().failedTest(file, line, message); + TS_ABORT(); +} + +void doFailAssert(const char * file, int line, + const char * expression, const char * message) +{ + if (message) + { + tracker().failedTest(file, line, message); + } + tracker().failedAssert(file, line, expression); + TS_ABORT(); +} + +bool sameData(const void * x, const void * y, unsigned size) +{ + if (size == 0) + { + return true; + } + + if (x == y) + { + return true; + } + + if (!x || !y) + { + return false; + } + + const char *cx = (const char *)x; + const char *cy = (const char *)y; + while (size --) + { + if (*cx++ != *cy++) + { + return false; + } + } + + return true; +} + +void doAssertSameData(const char * file, int line, + const char * xExpr, const void * x, + const char * yExpr, const void * y, + const char * sizeExpr, unsigned size, + const char * message) +{ + if (!sameData(x, y, size)) + { + if (message) + { + tracker().failedTest(file, line, message); + } + tracker().failedAssertSameData(file, line, xExpr, yExpr, sizeExpr, x, y, size); + TS_ABORT(); + } +} + +#if defined(_CXXTEST_HAVE_STD) +bool sameFiles(const char * file1, const char * file2, std::ostringstream & explanation) +{ + std::string ppprev_line; + std::string pprev_line; + std::string prev_line; + std::string curr_line; + + std::ifstream is1; + is1.open(file1); + std::ifstream is2; + is2.open(file2); + if (!is1) + { + explanation << "File '" << file1 << "' does not exist!"; + return false; + } + if (!is2) + { + explanation << "File '" << file2 << "' does not exist!"; + return false; + } + + int nline = 1; + char c1, c2; + while (1) + { + is1.get(c1); + is2.get(c2); + if (!is1 && !is2) { return true; } + if (!is1) + { + explanation << "File '" << file1 << "' ended before file '" << file2 << "' (line " << nline << ")"; + explanation << std::endl << "= " << ppprev_line << std::endl << "= " << pprev_line << std::endl << "= " << prev_line << std::endl << "< " << curr_line; + is1.get(c1); + while (is1 && (c1 != '\n')) + { + explanation << c1; + is1.get(c1); + } + explanation << std::endl; + return false; + } + if (!is2) + { + explanation << "File '" << file2 << "' ended before file '" << file1 << "' (line " << nline << ")"; + explanation << std::endl << "= " << ppprev_line << std::endl << "= " << pprev_line << std::endl << "= " << prev_line << std::endl << "> " << curr_line; + is2.get(c2); + while (is2 && (c2 != '\n')) + { + explanation << c2; + is2.get(c2); + } + explanation << std::endl; + return false; + } + if (c1 != c2) + { + explanation << "Files '" << file1 << "' and '" << file2 << "' differ at line " << nline; + explanation << std::endl << "= " << ppprev_line << std::endl << "= " << pprev_line << std::endl << "= " << prev_line; + + explanation << std::endl << "< " << curr_line; + is2.get(c1); + while (is1 && (c1 != '\n')) + { + explanation << c1; + is2.get(c1); + } + explanation << std::endl; + + explanation << std::endl << "> " << curr_line; + is2.get(c2); + while (is2 && (c2 != '\n')) + { + explanation << c2; + is2.get(c2); + } + explanation << std::endl; + + return false; + } + if (c1 == '\n') + { + ppprev_line = pprev_line; + pprev_line = prev_line; + prev_line = curr_line; + curr_line = ""; + nline++; + } + else + { + curr_line += c1; + } + } +} +#endif + +void doAssertSameFiles(const char * file, int line, + const char * file1, const char * file2, + const char * message) +{ +#if defined(_CXXTEST_HAVE_STD) + std::ostringstream explanation; + if (!sameFiles(file1, file2, explanation)) + { + if (message) + { + tracker().failedTest(file, line, message); + } + tracker().failedAssertSameFiles(file, line, file1, file2, explanation.str().c_str()); + TS_ABORT(); + } +#else + tracker().failedAssertSameFiles(file, line, file1, file2, "This test is only supported when --have-std is enabled"); + TS_ABORT(); +#endif +} + +void doFailAssertThrows(const char * file, int line, + const char * expr, const char * type, + bool otherThrown, + const char * message, + const char * exception) +{ + if (exception) + { + tracker().failedTest(file, line, exception); + } + if (message) + { + tracker().failedTest(file, line, message); + } + + tracker().failedAssertThrows(file, line, expr, type, otherThrown); + TS_ABORT(); +} + +void doFailAssertThrowsNot(const char * file, int line, + const char * expression, const char * message, + const char * exception) +{ + if (exception) + { + tracker().failedTest(file, line, exception); + } + if (message) + { + tracker().failedTest(file, line, message); + } + + tracker().failedAssertThrowsNot(file, line, expression); + TS_ABORT(); +} +} + +#endif // __cxxtest__TestSuite_cpp__ + diff --git a/third-party/cxxtest/cxxtest/TestSuite.h b/third-party/cxxtest/cxxtest/TestSuite.h new file mode 100644 index 00000000..b34c45d3 --- /dev/null +++ b/third-party/cxxtest/cxxtest/TestSuite.h @@ -0,0 +1,732 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__TestSuite_h__ +#define __cxxtest__TestSuite_h__ + +// +// class TestSuite is the base class for all test suites. +// To define a test suite, derive from this class and add +// member functions called void test*(); +// + +#include +#include +#include +#include +#include +#include +#include + +#if defined(_CXXTEST_HAVE_STD) +# include +#endif // _CXXTEST_HAVE_STD + +namespace CxxTest +{ +class TestSuite +{ +public: + virtual ~TestSuite(); + virtual void setUp(); + virtual void tearDown(); +}; + +class AbortTest {}; +class SkipTest {}; +void doAbortTest(); +# define TS_ABORT() CxxTest::doAbortTest() + +bool abortTestOnFail(); +void setAbortTestOnFail(bool value = CXXTEST_DEFAULT_ABORT); + +unsigned maxDumpSize(); +void setMaxDumpSize(unsigned value = CXXTEST_MAX_DUMP_SIZE); + +void doTrace(const char *file, int line, const char *message); +void doWarn(const char *file, int line, const char *message); +void doSkipTest(const char *file, int line, const char *message); +void doFailTest(const char *file, int line, const char *message); +void doFailAssert(const char *file, int line, const char *expression, const char *message); + +template +struct equals +{ + static bool test(X x, Y y) + { + return (x == y); + } +}; + +template<> +struct equals +{ + static bool test(const char *x, const char *y) + { + if ((x != 0) && (y != 0)) + { + return (CXXTEST_STD(strcmp(x, y)) == 0); + } + else + { + return (x == y); + } + } +}; + +template<> +struct equals +{ + static bool test(char *x, char *y) + { + if ((x != 0) && (y != 0)) + { + return (CXXTEST_STD(strcmp(x, y)) == 0); + } + else + { + return (x == y); + } + } +}; + +template<> +struct equals +{ + static bool test(const char *x, char *y) + { + if ((x != 0) && (y != 0)) + { + return (CXXTEST_STD(strcmp(x, y)) == 0); + } + else + { + return (x == y); + } + } +}; + +template<> +struct equals +{ + static bool test(char *x, const char *y) + { + if ((x != 0) && (y != 0)) + { + return (CXXTEST_STD(strcmp(x, y)) == 0); + } + else + { + return (x == y); + } + } +}; + +template +void doAssertEquals(const char *file, int line, + const char *xExpr, X x, + const char *yExpr, Y y, + const char *message) +{ + if (!equals::test(x, y)) + { + if (message) + { + tracker().failedTest(file, line, message); + } + tracker().failedAssertEquals(file, line, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y)); + TS_ABORT(); + } +} + +bool sameData(const void *x, const void *y, unsigned size); + +void doAssertSameData(const char *file, int line, + const char *xExpr, const void *x, + const char *yExpr, const void *y, + const char *sizeExpr, unsigned size, + const char *message); + +//#if defined(_CXXTEST_HAVE_STD) +bool sameFiles(const char* file1, const char* file2, std::ostringstream& explanation); +//#endif + +template +struct differs +{ + static bool test(X x, Y y) + { + return !(x == y); + } +}; + +template +void doAssertDiffers(const char *file, int line, + const char *xExpr, X x, + const char *yExpr, Y y, + const char *message) +{ + if (!differs::test(x, y)) + { + if (message) + { + tracker().failedTest(file, line, message); + } + tracker().failedAssertDiffers(file, line, xExpr, yExpr, TS_AS_STRING(x)); + TS_ABORT(); + } +} + +template +struct lessThan +{ + static bool test(X x, Y y) + { + return (x < y); + } +}; + +template +void doAssertLessThan(const char *file, int line, + const char *xExpr, X x, + const char *yExpr, Y y, + const char *message) +{ + if (!lessThan::test(x, y)) + { + if (message) + { + tracker().failedTest(file, line, message); + } + tracker().failedAssertLessThan(file, line, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y)); + TS_ABORT(); + } +} + +template +struct lessThanEquals +{ + static bool test(X x, Y y) + { + return (x <= y); + } +}; + +template +void doAssertLessThanEquals(const char *file, int line, + const char *xExpr, X x, + const char *yExpr, Y y, + const char *message) +{ + if (!lessThanEquals::test(x, y)) + { + if (message) + { + tracker().failedTest(file, line, message); + } + tracker().failedAssertLessThanEquals(file, line, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y)); + TS_ABORT(); + } +} + +template +void doAssertPredicate(const char *file, int line, + const char *pExpr, const P &p, + const char *xExpr, X x, + const char *message) +{ + if (!p(x)) + { + if (message) + { + tracker().failedTest(file, line, message); + } + tracker().failedAssertPredicate(file, line, pExpr, xExpr, TS_AS_STRING(x)); + TS_ABORT(); + } +} + +template +void doAssertRelation(const char *file, int line, + const char *rExpr, const R &r, + const char *xExpr, X x, + const char *yExpr, Y y, + const char *message) +{ + if (!r(x, y)) + { + if (message) + { + tracker().failedTest(file, line, message); + } + tracker().failedAssertRelation(file, line, rExpr, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y)); + TS_ABORT(); + } +} + +// An indirection template so the compiler can determine what type +// "X +/- D" should be +template +bool delta_le_helper(X x, Y y) +{ + return lessThanEquals::test(x, y); +} + +template +struct delta +{ + static bool test(X x, Y y, D d) + { + return delta_le_helper(x, y + d) && delta_le_helper(y, x + d); + //(y >= x - d) && (y <= x + d)); + } +}; + +template +void doAssertDelta(const char *file, int line, + const char *xExpr, X x, + const char *yExpr, Y y, + const char *dExpr, D d, + const char *message) +{ + if (!delta::test(x, y, d)) + { + if (message) + { + tracker().failedTest(file, line, message); + } + + tracker().failedAssertDelta(file, line, xExpr, yExpr, dExpr, + TS_AS_STRING(x), TS_AS_STRING(y), TS_AS_STRING(d)); + TS_ABORT(); + } +} + +void doFailAssertThrows(const char *file, int line, + const char *expr, const char *type, + bool otherThrown, + const char *message, + const char *exception = 0); + +void doFailAssertThrowsNot(const char *file, int line, + const char *expression, const char *message, + const char *exception = 0); + +void doAssertSameFiles(const char* file, int line, + const char* file1, const char* file2, + const char* message); + +# ifdef _CXXTEST_HAVE_EH +# define _TS_TRY try +# define _TS_CATCH_TYPE(t, b) catch t b +# define _TS_CATCH_ABORT(b) _TS_CATCH_TYPE( (const CxxTest::AbortTest &), b ) +# define _TS_CATCH_SKIPPED(b) _TS_CATCH_TYPE( (const CxxTest::SkipTest &), b ) +# define _TS_LAST_CATCH(b) _TS_CATCH_TYPE( (...), b ) +# define _TSM_LAST_CATCH(f,l,m) _TS_LAST_CATCH( { (CxxTest::tracker()).failedTest(f,l,m); } ) +# ifdef _CXXTEST_HAVE_STD +# define _TS_CATCH_STD(e,b) _TS_CATCH_TYPE( (const std::exception& e), b ) +# else // !_CXXTEST_HAVE_STD +# define _TS_CATCH_STD(e,b) +# endif // _CXXTEST_HAVE_STD +# define ___TSM_CATCH(f,l,m) \ + _TS_CATCH_STD(e, { (CxxTest::tracker()).failedTest(f,l,e.what()); }) \ + _TSM_LAST_CATCH(f,l,m) +# define __TSM_CATCH(f,l,m) \ + _TS_CATCH_ABORT( { throw; } ) \ + ___TSM_CATCH(f,l,m) +# define __TS_CATCH(f,l) __TSM_CATCH(f,l,"Unhandled exception") +# define _TS_CATCH __TS_CATCH(__FILE__,__LINE__) +# else // !_CXXTEST_HAVE_EH +# define _TS_TRY +# define ___TSM_CATCH(f,l,m) +# define __TSM_CATCH(f,l,m) +# define __TS_CATCH(f,l) +# define _TS_CATCH +# define _TS_CATCH_TYPE(t, b) +# define _TS_LAST_CATCH(b) +# define _TS_CATCH_STD(e,b) +# define _TS_CATCH_ABORT(b) +# define _TS_CATCH_SKIPPED(b) +# endif // _CXXTEST_HAVE_EH + +// TS_TRACE +# define _TS_TRACE(f,l,e) CxxTest::doTrace( (f), (l), TS_AS_STRING(e) ) +# define TS_TRACE(e) _TS_TRACE( __FILE__, __LINE__, e ) + +// TS_WARN +# define _TS_WARN(f,l,e) CxxTest::doWarn( (f), (l), TS_AS_STRING(e) ) +# define TS_WARN(e) _TS_WARN( __FILE__, __LINE__, e ) + +// TS_SKIP +# define _TS_SKIP(f,l,e) CxxTest::doSkipTest( (f), (l), TS_AS_STRING(e) ) +# define TS_SKIP(e) _TS_SKIP( __FILE__, __LINE__, e ) + +// TS_FAIL +# define _TS_FAIL(f,l,e) CxxTest::doFailTest( (f), (l), TS_AS_STRING(e) ) +# define TS_FAIL(e) _TS_FAIL( __FILE__, __LINE__, e ) + +// TS_ASSERT +# define ___ETS_ASSERT(f,l,e,m) { if ( !(e) ) { CxxTest::doFailAssert( (f), (l), #e, (m) ); } } +# define ___TS_ASSERT(f,l,e,m) { _TS_TRY { ___ETS_ASSERT(f,l,e,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT(f,l,e) ___ETS_ASSERT(f,l,e,0) +# define _TS_ASSERT(f,l,e) ___TS_ASSERT(f,l,e,0) + +# define ETS_ASSERT(e) _ETS_ASSERT(__FILE__,__LINE__,e) +# define TS_ASSERT(e) _TS_ASSERT(__FILE__,__LINE__,e) + +# define _ETSM_ASSERT(f,l,m,e) ___ETS_ASSERT(f,l,e,TS_AS_STRING(m) ) +# define _TSM_ASSERT(f,l,m,e) ___TS_ASSERT(f,l,e,TS_AS_STRING(m) ) + +# define ETSM_ASSERT(m,e) _ETSM_ASSERT(__FILE__,__LINE__,m,e) +# define TSM_ASSERT(m,e) _TSM_ASSERT(__FILE__,__LINE__,m,e) + +// TS_ASSERT_EQUALS +# define ___ETS_ASSERT_EQUALS(f,l,x,y,m) CxxTest::doAssertEquals( (f), (l), #x, (x), #y, (y), (m) ) +# define ___TS_ASSERT_EQUALS(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_EQUALS(f,l,x,y,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT_EQUALS(f,l,x,y) ___ETS_ASSERT_EQUALS(f,l,x,y,0) +# define _TS_ASSERT_EQUALS(f,l,x,y) ___TS_ASSERT_EQUALS(f,l,x,y,0) + +# define ETS_ASSERT_EQUALS(x,y) _ETS_ASSERT_EQUALS(__FILE__,__LINE__,x,y) +# define TS_ASSERT_EQUALS(x,y) _TS_ASSERT_EQUALS(__FILE__,__LINE__,x,y) + +# define _ETSM_ASSERT_EQUALS(f,l,m,x,y) ___ETS_ASSERT_EQUALS(f,l,x,y,TS_AS_STRING(m)) +# define _TSM_ASSERT_EQUALS(f,l,m,x,y) ___TS_ASSERT_EQUALS(f,l,x,y,TS_AS_STRING(m)) + +# define ETSM_ASSERT_EQUALS(m,x,y) _ETSM_ASSERT_EQUALS(__FILE__,__LINE__,m,x,y) +# define TSM_ASSERT_EQUALS(m,x,y) _TSM_ASSERT_EQUALS(__FILE__,__LINE__,m,x,y) + +// Special foating point values support +# define ETS_ASSERT_IS_NAN(x) _ETS_ASSERT(__FILE__,__LINE__,isnan(x)) +# define TS_ASSERT_IS_NAN(x) _TS_ASSERT(__FILE__,__LINE__,isnan(x)) + +# define ETSM_ASSERT_IS_NAN(m,x) _ETSM_ASSERT(__FILE__,__LINE__,m,isnan(x)) +# define TSM_ASSERT_IS_NAN(m,x) _TSM_ASSERT(__FILE__,__LINE__,m,isnan(x)) + +# define ETS_ASSERT_IS_INFINITE(x) _ETS_ASSERT(__FILE__,__LINE__,isinf(x)) +# define TS_ASSERT_IS_INFINITE(x) _TS_ASSERT(__FILE__,__LINE__,isinf(x)) + +# define ETSM_ASSERT_IS_INFINITE(m,x) _ETSM_ASSERT(__FILE__,__LINE__,m,isinf(x)) +# define TSM_ASSERT_IS_INFINITE(m,x) _TSM_ASSERT(__FILE__,__LINE__,m,isinf(x)) + +// TS_ASSERT_SAME_DATA +# define ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,m) CxxTest::doAssertSameData( (f), (l), #x, (x), #y, (y), #s, (s), (m) ) +# define ___TS_ASSERT_SAME_DATA(f,l,x,y,s,m) { _TS_TRY { ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT_SAME_DATA(f,l,x,y,s) ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,0) +# define _TS_ASSERT_SAME_DATA(f,l,x,y,s) ___TS_ASSERT_SAME_DATA(f,l,x,y,s,0) + +# define ETS_ASSERT_SAME_DATA(x,y,s) _ETS_ASSERT_SAME_DATA(__FILE__,__LINE__,x,y,s) +# define TS_ASSERT_SAME_DATA(x,y,s) _TS_ASSERT_SAME_DATA(__FILE__,__LINE__,x,y,s) + +# define _ETSM_ASSERT_SAME_DATA(f,l,m,x,y,s) ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,TS_AS_STRING(m)) +# define _TSM_ASSERT_SAME_DATA(f,l,m,x,y,s) ___TS_ASSERT_SAME_DATA(f,l,x,y,s,TS_AS_STRING(m)) + +# define ETSM_ASSERT_SAME_DATA(m,x,y,s) _ETSM_ASSERT_SAME_DATA(__FILE__,__LINE__,m,x,y,s) +# define TSM_ASSERT_SAME_DATA(m,x,y,s) _TSM_ASSERT_SAME_DATA(__FILE__,__LINE__,m,x,y,s) + +// TS_ASSERT_DIFFERS +# define ___ETS_ASSERT_DIFFERS(f,l,x,y,m) CxxTest::doAssertDiffers( (f), (l), #x, (x), #y, (y), (m) ) +# define ___TS_ASSERT_DIFFERS(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_DIFFERS(f,l,x,y,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT_DIFFERS(f,l,x,y) ___ETS_ASSERT_DIFFERS(f,l,x,y,0) +# define _TS_ASSERT_DIFFERS(f,l,x,y) ___TS_ASSERT_DIFFERS(f,l,x,y,0) + +# define ETS_ASSERT_DIFFERS(x,y) _ETS_ASSERT_DIFFERS(__FILE__,__LINE__,x,y) +# define TS_ASSERT_DIFFERS(x,y) _TS_ASSERT_DIFFERS(__FILE__,__LINE__,x,y) + +# define _ETSM_ASSERT_DIFFERS(f,l,m,x,y) ___ETS_ASSERT_DIFFERS(f,l,x,y,TS_AS_STRING(m)) +# define _TSM_ASSERT_DIFFERS(f,l,m,x,y) ___TS_ASSERT_DIFFERS(f,l,x,y,TS_AS_STRING(m)) + +# define ETSM_ASSERT_DIFFERS(m,x,y) _ETSM_ASSERT_DIFFERS(__FILE__,__LINE__,m,x,y) +# define TSM_ASSERT_DIFFERS(m,x,y) _TSM_ASSERT_DIFFERS(__FILE__,__LINE__,m,x,y) + +// TS_ASSERT_LESS_THAN +# define ___ETS_ASSERT_LESS_THAN(f,l,x,y,m) CxxTest::doAssertLessThan( (f), (l), #x, (x), #y, (y), (m) ) +# define ___TS_ASSERT_LESS_THAN(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_LESS_THAN(f,l,x,y,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT_LESS_THAN(f,l,x,y) ___ETS_ASSERT_LESS_THAN(f,l,x,y,0) +# define _TS_ASSERT_LESS_THAN(f,l,x,y) ___TS_ASSERT_LESS_THAN(f,l,x,y,0) + +# define ETS_ASSERT_LESS_THAN(x,y) _ETS_ASSERT_LESS_THAN(__FILE__,__LINE__,x,y) +# define TS_ASSERT_LESS_THAN(x,y) _TS_ASSERT_LESS_THAN(__FILE__,__LINE__,x,y) + +# define _ETSM_ASSERT_LESS_THAN(f,l,m,x,y) ___ETS_ASSERT_LESS_THAN(f,l,x,y,TS_AS_STRING(m)) +# define _TSM_ASSERT_LESS_THAN(f,l,m,x,y) ___TS_ASSERT_LESS_THAN(f,l,x,y,TS_AS_STRING(m)) + +# define ETSM_ASSERT_LESS_THAN(m,x,y) _ETSM_ASSERT_LESS_THAN(__FILE__,__LINE__,m,x,y) +# define TSM_ASSERT_LESS_THAN(m,x,y) _TSM_ASSERT_LESS_THAN(__FILE__,__LINE__,m,x,y) + +// TS_ASSERT_LESS_THAN_EQUALS +# define ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,m) \ + CxxTest::doAssertLessThanEquals( (f), (l), #x, (x), #y, (y), (m) ) +# define ___TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,m) \ + { _TS_TRY { ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y) ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,0) +# define _TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y) ___TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,0) + +# define ETS_ASSERT_LESS_THAN_EQUALS(x,y) _ETS_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,x,y) +# define TS_ASSERT_LESS_THAN_EQUALS(x,y) _TS_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,x,y) + +# define _ETSM_ASSERT_LESS_THAN_EQUALS(f,l,m,x,y) ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,TS_AS_STRING(m)) +# define _TSM_ASSERT_LESS_THAN_EQUALS(f,l,m,x,y) ___TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,TS_AS_STRING(m)) + +# define ETSM_ASSERT_LESS_THAN_EQUALS(m,x,y) _ETSM_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,m,x,y) +# define TSM_ASSERT_LESS_THAN_EQUALS(m,x,y) _TSM_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,m,x,y) + +// TS_ASSERT_PREDICATE +# define ___ETS_ASSERT_PREDICATE(f,l,p,x,m) \ + CxxTest::doAssertPredicate( (f), (l), #p, p(), #x, (x), (m) ) +# define ___TS_ASSERT_PREDICATE(f,l,p,x,m) \ + { _TS_TRY { ___ETS_ASSERT_PREDICATE(f,l,p,x,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT_PREDICATE(f,l,p,x) ___ETS_ASSERT_PREDICATE(f,l,p,x,0) +# define _TS_ASSERT_PREDICATE(f,l,p,x) ___TS_ASSERT_PREDICATE(f,l,p,x,0) + +# define ETS_ASSERT_PREDICATE(p,x) _ETS_ASSERT_PREDICATE(__FILE__,__LINE__,p,x) +# define TS_ASSERT_PREDICATE(p,x) _TS_ASSERT_PREDICATE(__FILE__,__LINE__,p,x) + +# define _ETSM_ASSERT_PREDICATE(f,l,m,p,x) ___ETS_ASSERT_PREDICATE(f,l,p,x,TS_AS_STRING(m)) +# define _TSM_ASSERT_PREDICATE(f,l,m,p,x) ___TS_ASSERT_PREDICATE(f,l,p,x,TS_AS_STRING(m)) + +# define ETSM_ASSERT_PREDICATE(m,p,x) _ETSM_ASSERT_PREDICATE(__FILE__,__LINE__,m,p,x) +# define TSM_ASSERT_PREDICATE(m,p,x) _TSM_ASSERT_PREDICATE(__FILE__,__LINE__,m,p,x) + +// TS_ASSERT_RELATION +# define ___ETS_ASSERT_RELATION(f,l,r,x,y,m) \ + CxxTest::doAssertRelation( (f), (l), #r, r(), #x, (x), #y, (y), (m) ) +# define ___TS_ASSERT_RELATION(f,l,r,x,y,m) \ + { _TS_TRY { ___ETS_ASSERT_RELATION(f,l,r,x,y,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT_RELATION(f,l,r,x,y) ___ETS_ASSERT_RELATION(f,l,r,x,y,0) +# define _TS_ASSERT_RELATION(f,l,r,x,y) ___TS_ASSERT_RELATION(f,l,r,x,y,0) + +# define ETS_ASSERT_RELATION(r,x,y) _ETS_ASSERT_RELATION(__FILE__,__LINE__,r,x,y) +# define TS_ASSERT_RELATION(r,x,y) _TS_ASSERT_RELATION(__FILE__,__LINE__,r,x,y) + +# define _ETSM_ASSERT_RELATION(f,l,m,r,x,y) ___ETS_ASSERT_RELATION(f,l,r,x,y,TS_AS_STRING(m)) +# define _TSM_ASSERT_RELATION(f,l,m,r,x,y) ___TS_ASSERT_RELATION(f,l,r,x,y,TS_AS_STRING(m)) + +# define ETSM_ASSERT_RELATION(m,r,x,y) _ETSM_ASSERT_RELATION(__FILE__,__LINE__,m,r,x,y) +# define TSM_ASSERT_RELATION(m,r,x,y) _TSM_ASSERT_RELATION(__FILE__,__LINE__,m,r,x,y) + +// TS_ASSERT_DELTA +# define ___ETS_ASSERT_DELTA(f,l,x,y,d,m) CxxTest::doAssertDelta( (f), (l), #x, (x), #y, (y), #d, (d), (m) ) +# define ___TS_ASSERT_DELTA(f,l,x,y,d,m) { _TS_TRY { ___ETS_ASSERT_DELTA(f,l,x,y,d,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT_DELTA(f,l,x,y,d) ___ETS_ASSERT_DELTA(f,l,x,y,d,0) +# define _TS_ASSERT_DELTA(f,l,x,y,d) ___TS_ASSERT_DELTA(f,l,x,y,d,0) + +# define ETS_ASSERT_DELTA(x,y,d) _ETS_ASSERT_DELTA(__FILE__,__LINE__,x,y,d) +# define TS_ASSERT_DELTA(x,y,d) _TS_ASSERT_DELTA(__FILE__,__LINE__,x,y,d) + +# define _ETSM_ASSERT_DELTA(f,l,m,x,y,d) ___ETS_ASSERT_DELTA(f,l,x,y,d,TS_AS_STRING(m)) +# define _TSM_ASSERT_DELTA(f,l,m,x,y,d) ___TS_ASSERT_DELTA(f,l,x,y,d,TS_AS_STRING(m)) + +# define ETSM_ASSERT_DELTA(m,x,y,d) _ETSM_ASSERT_DELTA(__FILE__,__LINE__,m,x,y,d) +# define TSM_ASSERT_DELTA(m,x,y,d) _TSM_ASSERT_DELTA(__FILE__,__LINE__,m,x,y,d) + +// TS_ASSERT_SAME_FILES +# define ___ETS_ASSERT_SAME_FILES(f,l,x,y,m) CxxTest::doAssertSameFiles( (f), (l), (x), (y), (m) ) +# define ___TS_ASSERT_SAME_FILES(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_SAME_FILES(f,l,x,y,m); } __TS_CATCH(f,l) } + +# define _ETS_ASSERT_SAME_FILES(f,l,x,y) ___ETS_ASSERT_SAME_FILES(f,l,x,y,0) +# define _TS_ASSERT_SAME_FILES(f,l,x,y) ___TS_ASSERT_SAME_FILES(f,l,x,y,0) + +# define ETS_ASSERT_SAME_FILES(x,y) _ETS_ASSERT_SAME_FILES(__FILE__,__LINE__,x,y) +# define TS_ASSERT_SAME_FILES(x,y) _TS_ASSERT_SAME_FILES(__FILE__,__LINE__,x,y) + +# define _ETSM_ASSERT_SAME_FILES(f,l,m,x,y) ___ETS_ASSERT_SAME_FILES(f,l,x,y,TS_AS_STRING(m)) +# define _TSM_ASSERT_SAME_FILES(f,l,m,x,y) ___TS_ASSERT_SAME_FILES(f,l,x,y,TS_AS_STRING(m)) + +# define ETSM_ASSERT_SAME_FILES(m,x,y) _ETSM_ASSERT_SAME_FILES(__FILE__,__LINE__,m,x,y) +# define TSM_ASSERT_SAME_FILES(m,x,y) _TSM_ASSERT_SAME_FILES(__FILE__,__LINE__,m,x,y) + + +// TS_ASSERT_THROWS +# define ___TS_ASSERT_THROWS(f,l,e,t,m) ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,(void)0,m) + +# define _TS_ASSERT_THROWS(f,l,e,t) ___TS_ASSERT_THROWS(f,l,e,t,0) +# define TS_ASSERT_THROWS(e,t) _TS_ASSERT_THROWS(__FILE__,__LINE__,e,t) + +# define _TSM_ASSERT_THROWS(f,l,m,e,t) ___TS_ASSERT_THROWS(f,l,e,t,TS_AS_STRING(m)) +# define TSM_ASSERT_THROWS(m,e,t) _TSM_ASSERT_THROWS(__FILE__,__LINE__,m,e,t) + +// TS_ASSERT_THROWS_ASSERT +# define ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,a,m) { \ + bool _ts_threw_expected = false, _ts_threw_else = false; \ + _TS_TRY { try{ e; } _TS_CATCH_TYPE( (t), { a; _ts_threw_expected = true; } ) } \ + _TS_CATCH_ABORT( { throw; } ) \ + _TS_CATCH_STD( ex, { _ts_threw_expected = true; CxxTest::doFailAssertThrows((f), (l), #e, #t, true, (m), ex.what() ); } ) \ + _TS_LAST_CATCH( { _ts_threw_else = true; } ) \ + if ( !_ts_threw_expected ) { CxxTest::doFailAssertThrows( (f), (l), #e, #t, _ts_threw_else, (m), 0 ); } } + +# define _TS_ASSERT_THROWS_ASSERT(f,l,e,t,a) ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,a,0) +# define TS_ASSERT_THROWS_ASSERT(e,t,a) _TS_ASSERT_THROWS_ASSERT(__FILE__,__LINE__,e,t,a) + +# define _TSM_ASSERT_THROWS_ASSERT(f,l,m,e,t,a) ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,a,TS_AS_STRING(m)) +# define TSM_ASSERT_THROWS_ASSERT(m,e,t,a) _TSM_ASSERT_THROWS_ASSERT(__FILE__,__LINE__,m,e,t,a) + +// TS_ASSERT_THROWS_EQUALS +# define TS_ASSERT_THROWS_EQUALS(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_EQUALS(x,y)) +# define TSM_ASSERT_THROWS_EQUALS(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_EQUALS(m,x,y)) + +// Special foating point values support +# define TS_ASSERT_THROWS_IS_NAN(e,t,x) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_IS_NAN(x)) +# define TSM_ASSERT_THROWS_IS_NAN(m,e,t,x) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_IS_NAN(m,x)) + +# define TS_ASSERT_THROWS_IS_INFINITE(e,t,x) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_IS_INFINITE(x)) +# define TSM_ASSERT_THROWS_IS_INFINITE(m,e,t,x) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_IS_INFINITE(m,x)) + +// TS_ASSERT_THROWS_DIFFERS +# define TS_ASSERT_THROWS_DIFFERS(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_DIFFERS(x,y)) +# define TSM_ASSERT_THROWS_DIFFERS(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_DIFFERS(m,x,y)) + +// TS_ASSERT_THROWS_DELTA +# define TS_ASSERT_THROWS_DELTA(e,t,x,y,d) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_DELTA(x,y,d)) +# define TSM_ASSERT_THROWS_DELTA(m,e,t,x,y,d) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_DELTA(m,x,y,d)) + +// TS_ASSERT_THROWS_SAME_DATA +# define TS_ASSERT_THROWS_SAME_DATA(e,t,x,y,s) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_SAME_DATA(x,y,s)) +# define TSM_ASSERT_THROWS_SAME_DATA(m,e,t,x,y,s) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_SAME_DATA(m,x,y,s)) + +// TS_ASSERT_THROWS_LESS_THAN +# define TS_ASSERT_THROWS_LESS_THAN(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_LESS_THAN(x,y)) +# define TSM_ASSERT_THROWS_LESS_THAN(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_LESS_THAN(m,x,y)) + +// TS_ASSERT_THROWS_LESS_THAN_EQUALS +# define TS_ASSERT_THROWS_LESS_THAN_EQUALS(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_LESS_THAN_EQUALS(x,y)) +# define TSM_ASSERT_THROWS_LESS_THAN_EQUALS(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_LESS_THAN_EQUALS(m,x,y)) + +// TS_ASSERT_THROWS_PREDICATE +# define TS_ASSERT_THROWS_PREDICATE(e,t,p,v) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_PREDICATE(p,v)) +# define TSM_ASSERT_THROWS_PREDICATE(m,e,t,p,v) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_PREDICATE(m,p,v)) + +// TS_ASSERT_THROWS_RELATION +# define TS_ASSERT_THROWS_RELATION(e,t,r,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_RELATION(r,x,y)) +# define TSM_ASSERT_THROWS_RELATION(m,e,t,r,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_RELATION(m,r,x,y)) + +// TS_ASSERT_THROWS_ANYTHING +# define ___TS_ASSERT_THROWS_ANYTHING(f,l,e,m) { \ + bool _ts_threw = false; \ + _TS_TRY { e; } \ + _TS_LAST_CATCH( { _ts_threw = true; } ) \ + if ( !_ts_threw ) { CxxTest::doFailAssertThrows( (f), (l), #e, "...", false, (m) ); } } + +# define _TS_ASSERT_THROWS_ANYTHING(f,l,e) ___TS_ASSERT_THROWS_ANYTHING(f,l,e,0) +# define TS_ASSERT_THROWS_ANYTHING(e) _TS_ASSERT_THROWS_ANYTHING(__FILE__, __LINE__, e) + +# define _TSM_ASSERT_THROWS_ANYTHING(f,l,m,e) ___TS_ASSERT_THROWS_ANYTHING(f,l,e,TS_AS_STRING(m)) +# define TSM_ASSERT_THROWS_ANYTHING(m,e) _TSM_ASSERT_THROWS_ANYTHING(__FILE__,__LINE__,m,e) + +// TS_ASSERT_THROWS_NOTHING +# define ___TS_ASSERT_THROWS_NOTHING(f,l,e,m) { \ + _TS_TRY { e; } \ + _TS_CATCH_ABORT( { throw; } ) \ + _TS_CATCH_STD(ex, { CxxTest::doFailAssertThrowsNot( (f), (l), #e, (m), ex.what() ); } ) \ + _TS_LAST_CATCH( { CxxTest::doFailAssertThrowsNot( (f), (l), #e, (m), 0 ); } ) } + +# define _TS_ASSERT_THROWS_NOTHING(f,l,e) ___TS_ASSERT_THROWS_NOTHING(f,l,e,0) +# define TS_ASSERT_THROWS_NOTHING(e) _TS_ASSERT_THROWS_NOTHING(__FILE__,__LINE__,e) + +# define _TSM_ASSERT_THROWS_NOTHING(f,l,m,e) ___TS_ASSERT_THROWS_NOTHING(f,l,e,TS_AS_STRING(m)) +# define TSM_ASSERT_THROWS_NOTHING(m,e) _TSM_ASSERT_THROWS_NOTHING(__FILE__,__LINE__,m,e) + + +// +// This takes care of "signed <-> unsigned" warnings +// +# define CXXTEST_COMPARISONS(CXXTEST_X, CXXTEST_Y, CXXTEST_T) \ + template<> struct equals { \ + static bool test(CXXTEST_X x,CXXTEST_Y y) { \ + return equals::test((CXXTEST_T)x,(CXXTEST_T)y); } }; \ + template<> struct equals { \ + static bool test(CXXTEST_Y x,CXXTEST_X y) { \ + return equals::test((CXXTEST_T)x,(CXXTEST_T)y); } }; \ + template<> struct differs { \ + static bool test(CXXTEST_X x,CXXTEST_Y y) { \ + return differs::test((CXXTEST_T)x,(CXXTEST_T)y); } }; \ + template<> struct differs { \ + static bool test(CXXTEST_Y x,CXXTEST_X y) { \ + return differs::test((CXXTEST_T)x,(CXXTEST_T)y); } }; \ + template<> struct lessThan { \ + static bool test(CXXTEST_X x,CXXTEST_Y y) { \ + return lessThan::test((CXXTEST_T)x,(CXXTEST_T)y); } }; \ + template<> struct lessThan { \ + static bool test(CXXTEST_Y x,CXXTEST_X y) { \ + return lessThan::test((CXXTEST_T)x,(CXXTEST_T)y); } }; \ + template<> struct lessThanEquals { \ + static bool test(CXXTEST_X x,CXXTEST_Y y) { \ + return lessThanEquals::test((CXXTEST_T)x,(CXXTEST_T)y); } }; \ + template<> struct lessThanEquals { \ + static bool test(CXXTEST_Y x,CXXTEST_X y) { \ + return lessThanEquals::test((CXXTEST_T)x,(CXXTEST_T)y); } } +#if 0 +// These specializations are not needed because delta makes use of +// CxxTest::lessThanEquals for the actual comparison +template struct delta +{ + \ + static bool test(CXXTEST_X x, CXXTEST_Y y, D d) + { + \ + return delta::test((CXXTEST_T)x, (CXXTEST_T)y, d); + } +}; \ +template struct delta +{ + \ + static bool test(CXXTEST_Y x, CXXTEST_X y, D d) + { + \ + return delta::test((CXXTEST_T)x, (CXXTEST_T)y, d); + } +} +#endif + +# define CXXTEST_INTEGRAL(CXXTEST_T) \ + CXXTEST_COMPARISONS( signed CXXTEST_T, unsigned CXXTEST_T, unsigned CXXTEST_T ) + +CXXTEST_INTEGRAL(char); +CXXTEST_INTEGRAL(short); +CXXTEST_INTEGRAL(int); +CXXTEST_INTEGRAL(long); +# ifdef _CXXTEST_LONGLONG +CXXTEST_INTEGRAL(_CXXTEST_LONGLONG); +# endif // _CXXTEST_LONGLONG + +# define CXXTEST_SMALL_BIG(CXXTEST_SMALL, CXXTEST_BIG) \ + CXXTEST_COMPARISONS( signed CXXTEST_SMALL, unsigned CXXTEST_BIG, unsigned CXXTEST_BIG ); \ + CXXTEST_COMPARISONS( signed CXXTEST_BIG, unsigned CXXTEST_SMALL, unsigned CXXTEST_BIG ) + +CXXTEST_SMALL_BIG(char, short); +CXXTEST_SMALL_BIG(char, int); +CXXTEST_SMALL_BIG(short, int); +CXXTEST_SMALL_BIG(char, long); +CXXTEST_SMALL_BIG(short, long); +CXXTEST_SMALL_BIG(int, long); + +# ifdef _CXXTEST_LONGLONG +CXXTEST_SMALL_BIG(char, _CXXTEST_LONGLONG); +CXXTEST_SMALL_BIG(short, _CXXTEST_LONGLONG); +CXXTEST_SMALL_BIG(int, _CXXTEST_LONGLONG); +CXXTEST_SMALL_BIG(long, _CXXTEST_LONGLONG); +# endif // _CXXTEST_LONGLONG +} + +#ifdef _CXXTEST_HAVE_STD +# include +#endif // _CXXTEST_HAVE_STD + +#endif // __cxxtest__TestSuite_h__ + diff --git a/third-party/cxxtest/cxxtest/TestTracker.cpp b/third-party/cxxtest/cxxtest/TestTracker.cpp new file mode 100644 index 00000000..fbb6dcde --- /dev/null +++ b/third-party/cxxtest/cxxtest/TestTracker.cpp @@ -0,0 +1,288 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__TestTracker_cpp__ +#define __cxxtest__TestTracker_cpp__ + +#include + +namespace CxxTest +{ +bool TestTracker::_created = false; +bool TestTracker::print_tracing = false; + +TestTracker::TestTracker() +{ + if (!_created) + { + initialize(); + setListener(0); + _created = true; + } +} + +TestTracker::~TestTracker() +{ +} + +TestTracker & TestTracker::tracker() +{ + static TestTracker theTracker; + return theTracker; +} + +void TestTracker::initialize() +{ + _warnings = 0; + _skippedTests = 0; + _testSkipped = false; + _failedTests = 0; + _testFailedAsserts = 0; + _suiteFailedTests = 0; + _failedSuites = 0; + _world = 0; + _suite = 0; + _test = 0; +} + +const TestDescription *TestTracker::fixTest(const TestDescription *d) const +{ + return d ? d : &dummyTest(); +} + +const SuiteDescription *TestTracker::fixSuite(const SuiteDescription *d) const +{ + return d ? d : &dummySuite(); +} + +const WorldDescription *TestTracker::fixWorld(const WorldDescription *d) const +{ + return d ? d : &dummyWorld(); +} + +const TestDescription &TestTracker::dummyTest() const +{ + return dummySuite().testDescription(0); +} + +const SuiteDescription &TestTracker::dummySuite() const +{ + return dummyWorld().suiteDescription(0); +} + +const WorldDescription &TestTracker::dummyWorld() const +{ + return _dummyWorld; +} + +void TestTracker::setListener(TestListener *l) +{ + _l = l ? l : &_dummyListener; +} + +void TestTracker::enterWorld(const WorldDescription &wd) +{ + setWorld(&wd); + _warnings = _skippedTests = _failedTests = _testFailedAsserts = _suiteFailedTests = _failedSuites = 0; + _testSkipped = false; + _l->enterWorld(wd); +} + +void TestTracker::enterSuite(const SuiteDescription &sd) +{ + setSuite(&sd); + _testFailedAsserts = _suiteFailedTests = 0; + _testSkipped = false; + _l->enterSuite(sd); +} + +void TestTracker::enterTest(const TestDescription &td) +{ + setTest(&td); + _testFailedAsserts = false; + _testSkipped = false; + _l->enterTest(td); +} + +void TestTracker::leaveTest(const TestDescription &td) +{ + _l->leaveTest(td); + setTest(0); +} + +void TestTracker::leaveSuite(const SuiteDescription &sd) +{ + _l->leaveSuite(sd); + setSuite(0); +} + +void TestTracker::leaveWorld(const WorldDescription &wd) +{ + _l->leaveWorld(wd); + setWorld(0); +} + +void TestTracker::trace(const char *file, int line, const char *expression) +{ + _l->trace(file, line, expression); +} + +void TestTracker::warning(const char *file, int line, const char *expression) +{ + countWarning(); + _l->warning(file, line, expression); +} + +void TestTracker::skippedTest(const char *file, int line, const char *expression) +{ + countSkipped(); + _testSkipped = true; + _l->skippedTest(file, line, expression); +} + +void TestTracker::failedTest(const char *file, int line, const char *expression) +{ + countFailure(); + _l->failedTest(file, line, expression); +} + +void TestTracker::failedAssert(const char *file, int line, const char *expression) +{ + countFailure(); + _l->failedAssert(file, line, expression); +} + +void TestTracker::failedAssertEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) +{ + countFailure(); + _l->failedAssertEquals(file, line, xStr, yStr, x, y); +} + +void TestTracker::failedAssertSameData(const char *file, int line, + const char *xStr, const char *yStr, + const char *sizeStr, const void *x, + const void *y, unsigned size) +{ + countFailure(); + _l->failedAssertSameData(file, line, xStr, yStr, sizeStr, x, y, size); +} + +void TestTracker::failedAssertDelta(const char *file, int line, + const char *xStr, const char *yStr, const char *dStr, + const char *x, const char *y, const char *d) +{ + countFailure(); + _l->failedAssertDelta(file, line, xStr, yStr, dStr, x, y, d); +} + +void TestTracker::failedAssertDiffers(const char *file, int line, + const char *xStr, const char *yStr, + const char *value) +{ + countFailure(); + _l->failedAssertDiffers(file, line, xStr, yStr, value); +} + +void TestTracker::failedAssertLessThan(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) +{ + countFailure(); + _l->failedAssertLessThan(file, line, xStr, yStr, x, y); +} + +void TestTracker::failedAssertLessThanEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) +{ + countFailure(); + _l->failedAssertLessThanEquals(file, line, xStr, yStr, x, y); +} + +void TestTracker::failedAssertPredicate(const char *file, int line, + const char *predicate, const char *xStr, const char *x) +{ + countFailure(); + _l->failedAssertPredicate(file, line, predicate, xStr, x); +} + +void TestTracker::failedAssertRelation(const char *file, int line, + const char *relation, const char *xStr, const char *yStr, + const char *x, const char *y) +{ + countFailure(); + _l->failedAssertRelation(file, line, relation, xStr, yStr, x, y); +} + +void TestTracker::failedAssertThrows(const char *file, int line, + const char *expression, const char *type, + bool otherThrown) +{ + countFailure(); + _l->failedAssertThrows(file, line, expression, type, otherThrown); +} + +void TestTracker::failedAssertThrowsNot(const char *file, int line, const char *expression) +{ + countFailure(); + _l->failedAssertThrowsNot(file, line, expression); +} + +void TestTracker::failedAssertSameFiles(const char *file, int line, const char *file1, const char* file2, const char* explanation) +{ + countFailure(); + _l->failedAssertSameFiles(file, line, file1, file2, explanation); +} + +void TestTracker::setWorld(const WorldDescription *w) +{ + _world = fixWorld(w); + setSuite(0); +} + +void TestTracker::setSuite(const SuiteDescription *s) +{ + _suite = fixSuite(s); + setTest(0); +} + +void TestTracker::setTest(const TestDescription *t) +{ + _test = fixTest(t); +} + +void TestTracker::countWarning() +{ + ++ _warnings; +} + +void TestTracker::countSkipped() +{ + ++ _skippedTests; +} + +void TestTracker::countFailure() +{ + if (++ _testFailedAsserts == 1) + { + ++ _failedTests; + if (++ _suiteFailedTests == 1) + { + ++ _failedSuites; + } + } +} +} + +#endif // __cxxtest__TestTracker_cpp__ + diff --git a/third-party/cxxtest/cxxtest/TestTracker.h b/third-party/cxxtest/cxxtest/TestTracker.h new file mode 100644 index 00000000..50e59bc8 --- /dev/null +++ b/third-party/cxxtest/cxxtest/TestTracker.h @@ -0,0 +1,134 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__TestTracker_h__ +#define __cxxtest__TestTracker_h__ + +// +// The TestTracker tracks running tests +// The actual work is done in CountingListenerProxy, +// but this way avoids cyclic references TestListener<->CountingListenerProxy +// + +#include +#include + +namespace CxxTest +{ +class TestListener; + +class TestTracker : public TestListener +{ +public: + virtual ~TestTracker(); + + static TestTracker &tracker(); + static bool print_tracing; + + const TestDescription *fixTest(const TestDescription *d) const; + const SuiteDescription *fixSuite(const SuiteDescription *d) const; + const WorldDescription *fixWorld(const WorldDescription *d) const; + + const TestDescription &test() const { return *_test; } + const SuiteDescription &suite() const { return *_suite; } + const WorldDescription &world() const { return *_world; } + + bool testSkipped() const { return _testSkipped; } + bool testFailed() const { return (testFailedAsserts() > 0); } + bool suiteFailed() const { return (suiteFailedTests() > 0); } + bool worldFailed() const { return (failedSuites() > 0); } + + unsigned warnings() const { return _warnings; } + unsigned skippedTests() const { return _skippedTests; } + unsigned failedTests() const { return _failedTests; } + unsigned testFailedAsserts() const { return _testFailedAsserts; } + unsigned suiteFailedTests() const { return _suiteFailedTests; } + unsigned failedSuites() const { return _failedSuites; } + + void enterWorld(const WorldDescription &wd); + void enterSuite(const SuiteDescription &sd); + void enterTest(const TestDescription &td); + void leaveTest(const TestDescription &td); + void leaveSuite(const SuiteDescription &sd); + void leaveWorld(const WorldDescription &wd); + void trace(const char *file, int line, const char *expression); + void warning(const char *file, int line, const char *expression); + void skippedTest(const char *file, int line, const char *expression); + void failedTest(const char *file, int line, const char *expression); + void failedAssert(const char *file, int line, const char *expression); + void failedAssertEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y); + void failedAssertSameData(const char *file, int line, + const char *xStr, const char *yStr, + const char *sizeStr, const void *x, + const void *y, unsigned size); + void failedAssertDelta(const char *file, int line, + const char *xStr, const char *yStr, const char *dStr, + const char *x, const char *y, const char *d); + void failedAssertDiffers(const char *file, int line, + const char *xStr, const char *yStr, + const char *value); + void failedAssertLessThan(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y); + void failedAssertLessThanEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y); + void failedAssertPredicate(const char *file, int line, + const char *predicate, const char *xStr, const char *x); + void failedAssertRelation(const char *file, int line, + const char *relation, const char *xStr, const char *yStr, + const char *x, const char *y); + void failedAssertThrows(const char *file, int line, + const char *expression, const char *type, + bool otherThrown); + void failedAssertThrowsNot(const char *file, int line, const char *expression); + void failedAssertSameFiles(const char* file, int line, const char* file1, const char* file2, const char* explanation); + + void initialize(); + +private: + TestTracker(const TestTracker &); + TestTracker &operator=(const TestTracker &); + + static bool _created; + TestListener _dummyListener; + DummyWorldDescription _dummyWorld; + bool _testSkipped; + unsigned _warnings, _skippedTests, _failedTests, _testFailedAsserts, _suiteFailedTests, _failedSuites; + TestListener *_l; + const WorldDescription *_world; + const SuiteDescription *_suite; + const TestDescription *_test; + + const TestDescription &dummyTest() const; + const SuiteDescription &dummySuite() const; + const WorldDescription &dummyWorld() const; + + void setWorld(const WorldDescription *w); + void setSuite(const SuiteDescription *s); + void setTest(const TestDescription *t); + void countWarning(); + void countFailure(); + void countSkipped(); + + friend class TestRunner; + + TestTracker(); + void setListener(TestListener *l); +}; + +inline TestTracker &tracker() { return TestTracker::tracker(); } +} + +#endif // __cxxtest__TestTracker_h__ + diff --git a/third-party/cxxtest/cxxtest/ValueTraits.cpp b/third-party/cxxtest/cxxtest/ValueTraits.cpp new file mode 100644 index 00000000..095830ad --- /dev/null +++ b/third-party/cxxtest/cxxtest/ValueTraits.cpp @@ -0,0 +1,195 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__ValueTraits_cpp__ +#define __cxxtest__ValueTraits_cpp__ + +#include + +namespace CxxTest +{ +// +// Non-inline functions from ValueTraits.h +// + +char digitToChar(unsigned digit) +{ + if (digit < 10) + { + return (char)('0' + digit); + } + if (digit <= 10 + 'Z' - 'A') + { + return (char)('A' + digit - 10); + } + return '?'; +} + +const char *byteToHex(unsigned char byte) +{ + static char asHex[3]; + asHex[0] = digitToChar(byte >> 4); + asHex[1] = digitToChar(byte & 0x0F); + asHex[2] = '\0'; + return asHex; +} + +char *copyString(char *dst, const char *src) +{ + while ((*dst = *src) != '\0') + { + ++ dst; + ++ src; + } + return dst; +} + +bool stringsEqual(const char *s1, const char *s2) +{ + char c; + while ((c = *s1++) == *s2++) + { + if (c == '\0') + { + return true; + } + } + return false; +} + +char *charToString(unsigned long c, char *s) +{ + switch (c) + { + case '\\': return copyString(s, "\\\\"); + case '\"': return copyString(s, "\\\""); + case '\'': return copyString(s, "\\\'"); + case '\0': return copyString(s, "\\0"); + case '\a': return copyString(s, "\\a"); + case '\b': return copyString(s, "\\b"); + case '\n': return copyString(s, "\\n"); + case '\r': return copyString(s, "\\r"); + case '\t': return copyString(s, "\\t"); + } + if (c >= 32 && c <= 127) + { + s[0] = (char)c; + s[1] = '\0'; + return s + 1; + } + else + { + s[0] = '\\'; + s[1] = 'x'; + if (c < 0x10) + { + s[2] = '0'; + ++ s; + } + return numberToString(c, s + 2, 16UL); + } +} + +char *charToString(char c, char *s) +{ + return charToString((unsigned long)(unsigned char)c, s); +} + +char *bytesToString(const unsigned char *bytes, unsigned numBytes, unsigned maxBytes, char *s) +{ + bool truncate = (numBytes > maxBytes); + if (truncate) + { + numBytes = maxBytes; + } + + s = copyString(s, "{ "); + for (unsigned i = 0; i < numBytes; ++ i, ++ bytes) + { + s = copyString(copyString(s, byteToHex(*bytes)), " "); + } + if (truncate) + { + s = copyString(s, "..."); + } + return copyString(s, " }"); +} + +#ifndef CXXTEST_USER_VALUE_TRAITS +unsigned ValueTraits::requiredDigitsOnLeft(double t) +{ + unsigned digits = 1; + for (t = (t < 0.0) ? -t : t; t > 1.0; t /= BASE) + { + ++ digits; + } + return digits; +} + +char *ValueTraits::doNegative(double &t) +{ + if (t >= 0) + { + return _asString; + } + _asString[0] = '-'; + t = -t; + return _asString + 1; +} + +void ValueTraits::hugeNumber(double t) +{ + char *s = doNegative(t); + s = doubleToString(t, s, 0, 1); + s = copyString(s, "."); + s = doubleToString(t, s, 1, DIGITS_ON_RIGHT); + s = copyString(s, "E"); + s = numberToString(requiredDigitsOnLeft(t) - 1, s); +} + +void ValueTraits::normalNumber(double t) +{ + char *s = doNegative(t); + s = doubleToString(t, s); + s = copyString(s, "."); + for (unsigned i = 0; i < DIGITS_ON_RIGHT; ++ i) + { + s = numberToString((unsigned)(t *= BASE) % BASE, s); + } +} + +void ValueTraits::nonFiniteNumber(double t) +{ + char *s = _asString; + if (t != t) + { + s = copyString(s, "nan"); + } + //else if ( t == 1.0/0.0 ) + else if (t >= HUGE_VAL) + { + s = copyString(s, "-inf"); + } + else if (t <= -HUGE_VAL) + { + //else if ( t == -1.0/0.0 ) + s = copyString(s, "inf"); + } +} + +char *ValueTraits::doubleToString(double t, char *s, unsigned skip, unsigned max) +{ + return numberToString(t, s, BASE, skip, max); +} +#endif // !CXXTEST_USER_VALUE_TRAITS +} + +#endif // __cxxtest__ValueTraits_cpp__ diff --git a/third-party/cxxtest/cxxtest/ValueTraits.h b/third-party/cxxtest/cxxtest/ValueTraits.h new file mode 100644 index 00000000..d9989d9d --- /dev/null +++ b/third-party/cxxtest/cxxtest/ValueTraits.h @@ -0,0 +1,435 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__ValueTraits_h__ +#define __cxxtest__ValueTraits_h__ + +// +// ValueTraits are used by CxxTest to convert arbitrary +// values used in TS_ASSERT_EQUALS() to a string representation. +// +// This header file contains value traits for builtin integral types. +// To declare value traits for new types you should instantiate the class +// ValueTraits. +// + +#include + +#ifdef _CXXTEST_OLD_TEMPLATE_SYNTAX +# define CXXTEST_TEMPLATE_INSTANTIATION +#else // !_CXXTEST_OLD_TEMPLATE_SYNTAX +# define CXXTEST_TEMPLATE_INSTANTIATION template<> +#endif // _CXXTEST_OLD_TEMPLATE_SYNTAX + +#ifdef _CXXTEST_HAVE_STD +#include +#else +#include +#endif + +namespace CxxTest +{ +// +// This is how we use the value traits +// +# define TS_AS_STRING(x) CxxTest::traits(x).asString() + +// +// Char representation of a digit +// +char digitToChar(unsigned digit); + +// +// Convert byte value to hex digits +// Returns pointer to internal buffer +// +const char *byteToHex(unsigned char byte); + +// +// Convert byte values to string +// Returns one past the copied data +// +char *bytesToString(const unsigned char *bytes, unsigned numBytes, unsigned maxBytes, char *s); + +// +// Copy a string. +// Returns one past the end of the destination string +// Remember -- we can't use the standard library! +// +char *copyString(char *dst, const char *src); + +// +// Compare two strings. +// Remember -- we can't use the standard library! +// +bool stringsEqual(const char *s1, const char *s2); + +// +// Represent a character value as a string +// Returns one past the end of the string +// This will be the actual char if printable or '\xXXXX' otherwise +// +char *charToString(unsigned long c, char *s); + +// +// Prevent problems with negative (signed char)s +// +char *charToString(char c, char *s); + +// +// The default ValueTraits class dumps up to 8 bytes as hex values +// +template +class ValueTraits +{ + enum { MAX_BYTES = 8 }; + char _asString[sizeof("{ ") + sizeof("XX ") * MAX_BYTES + sizeof("... }")]; + +public: + ValueTraits(const T &t) { bytesToString((const unsigned char *)&t, sizeof(T), MAX_BYTES, _asString); } + const char *asString(void) const { return _asString; } +}; + +// +// traits( T t ) +// Creates an object of type ValueTraits +// +template +inline ValueTraits traits(T t) +{ + return ValueTraits(t); +} + +// +// You can duplicate the implementation of an existing ValueTraits +// +# define CXXTEST_COPY_TRAITS(CXXTEST_NEW_CLASS, CXXTEST_OLD_CLASS) \ + CXXTEST_TEMPLATE_INSTANTIATION \ + class ValueTraits< CXXTEST_NEW_CLASS > \ + { \ + ValueTraits< CXXTEST_OLD_CLASS > _old; \ + public: \ + ValueTraits( CXXTEST_NEW_CLASS n ) : _old( (CXXTEST_OLD_CLASS)n ) {} \ + const char *asString( void ) const { return _old.asString(); } \ + } + +// +// Certain compilers need separate declarations for T and const T +// +# ifdef _CXXTEST_NO_COPY_CONST +# define CXXTEST_COPY_CONST_TRAITS(CXXTEST_CLASS) +# else // !_CXXTEST_NO_COPY_CONST +# define CXXTEST_COPY_CONST_TRAITS(CXXTEST_CLASS) CXXTEST_COPY_TRAITS(CXXTEST_CLASS, const CXXTEST_CLASS) +# endif // _CXXTEST_NO_COPY_CONST + +// +// Avoid compiler warnings about unsigned types always >= 0 +// +template inline bool negative(N n) { return n < 0; } +template inline N abs(N n) { return negative(n) ? -n : n; } + +# define CXXTEST_NON_NEGATIVE(Type) \ + CXXTEST_TEMPLATE_INSTANTIATION \ + inline bool negative( Type ) { return false; } \ + CXXTEST_TEMPLATE_INSTANTIATION \ + inline Type abs( Type value ) { return value; } + +CXXTEST_NON_NEGATIVE(bool) +CXXTEST_NON_NEGATIVE(unsigned char) +CXXTEST_NON_NEGATIVE(unsigned short int) +CXXTEST_NON_NEGATIVE(unsigned int) +CXXTEST_NON_NEGATIVE(unsigned long int) +# ifdef _CXXTEST_LONGLONG +CXXTEST_NON_NEGATIVE(unsigned _CXXTEST_LONGLONG) +# endif // _CXXTEST_LONGLONG + +// +// Represent (integral) number as a string +// Returns one past the end of the string +// Remember -- we can't use the standard library! +// +template +char *numberToString(N n, char *s, + N base = 10, + unsigned skipDigits = 0, + unsigned maxDigits = (unsigned) - 1) +{ + if (negative(n)) + { + *s++ = '-'; + n = abs(n); + } + + N digit = 1; + while (digit <= (n / base)) + { + digit *= base; + } + N digitValue; + for (; digit >= 1 && skipDigits; n -= digit * digitValue, digit /= base, -- skipDigits) + { + digitValue = (unsigned)(n / digit); + } + for (; digit >= 1 && maxDigits; n -= digit * digitValue, digit /= base, -- maxDigits) + { + *s++ = digitToChar((unsigned)(digitValue = (unsigned)(n / digit))); + } + + *s = '\0'; + return s; +} + +// +// All the specific ValueTraits follow. +// You can #define CXXTEST_USER_VALUE_TRAITS if you don't want them +// + +#ifndef CXXTEST_USER_VALUE_TRAITS +// +// ValueTraits: const char * const & +// This is used for printing strings, as in TS_FAIL( "Message" ) +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits +{ + ValueTraits &operator=(const ValueTraits &); + const char *_asString; + +public: + ValueTraits(const char * const &value) : _asString(value) {} + ValueTraits(const ValueTraits &other) : _asString(other._asString) {} + const char *asString(void) const { return _asString; } +#if 0 + const char *asString(void) const + { + std::string tmp(1, '"'); + for (char const* src = _asString; src && *src; ++src) + { + switch (*src) + { + case '\\': tmp += "\\\\"; break; + case '\n': tmp += "\\n"; break; + case '\r': tmp += "\\r"; break; + case '\t': tmp += "\\t"; break; + case '"': tmp += "\\\""; break; + default: tmp += *src; break; + } + } + tmp += '"'; + + char* res = new char[tmp.size() + 1]; + return strcpy(res, tmp.c_str()); + } +#endif +}; + +CXXTEST_COPY_TRAITS(const char *, const char * const &); +CXXTEST_COPY_TRAITS(char *, const char * const &); + +// +// ValueTraits: bool +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits +{ + bool _value; + +public: + ValueTraits(const bool value) : _value(value) {} + const char *asString(void) const { return _value ? "true" : "false"; } +}; + +CXXTEST_COPY_CONST_TRAITS(bool); + +# ifdef _CXXTEST_LONGLONG +// +// ValueTraits: signed long long +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits +{ + typedef _CXXTEST_LONGLONG T; + char _asString[2 + 3 * sizeof(T)]; +public: + ValueTraits(T t) { numberToString(t, _asString); } + const char *asString(void) const { return _asString; } +}; + +CXXTEST_COPY_CONST_TRAITS(signed _CXXTEST_LONGLONG); + +// +// ValueTraits: unsigned long long +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits +{ + typedef unsigned _CXXTEST_LONGLONG T; + char _asString[1 + 3 * sizeof(T)]; +public: + ValueTraits(T t) { numberToString(t, _asString); } + const char *asString(void) const { return _asString; } +}; + +CXXTEST_COPY_CONST_TRAITS(unsigned _CXXTEST_LONGLONG); +# endif // _CXXTEST_LONGLONG + +// +// ValueTraits: signed long +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits +{ + typedef signed long int T; + char _asString[2 + 3 * sizeof(T)]; +public: + ValueTraits(T t) { numberToString(t, _asString); } + const char *asString(void) const { return _asString; } +}; + +CXXTEST_COPY_CONST_TRAITS(signed long int); + +// +// ValueTraits: unsigned long +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits +{ + typedef unsigned long int T; + char _asString[1 + 3 * sizeof(T)]; +public: + ValueTraits(T t) { numberToString(t, _asString); } + const char *asString(void) const { return _asString; } +}; + +CXXTEST_COPY_CONST_TRAITS(unsigned long int); + +// +// All decimals are the same as the long version +// + +CXXTEST_COPY_TRAITS(const signed int, const signed long int); +CXXTEST_COPY_TRAITS(const unsigned int, const unsigned long int); +CXXTEST_COPY_TRAITS(const signed short int, const signed long int); +CXXTEST_COPY_TRAITS(const unsigned short int, const unsigned long int); +CXXTEST_COPY_TRAITS(const unsigned char, const unsigned long int); + +CXXTEST_COPY_CONST_TRAITS(signed int); +CXXTEST_COPY_CONST_TRAITS(unsigned int); +CXXTEST_COPY_CONST_TRAITS(signed short int); +CXXTEST_COPY_CONST_TRAITS(unsigned short int); +CXXTEST_COPY_CONST_TRAITS(unsigned char); + +// +// ValueTraits: char +// Returns 'x' for printable chars, '\x??' for others +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits +{ + char _asString[sizeof("'\\xXX'")]; +public: + ValueTraits(char c) { copyString(charToString(c, copyString(_asString, "'")), "'"); } + const char *asString(void) const { return _asString; } +}; + +CXXTEST_COPY_CONST_TRAITS(char); + +// +// ValueTraits: signed char +// Same as char, some compilers need it +// +CXXTEST_COPY_TRAITS(const signed char, const char); +CXXTEST_COPY_CONST_TRAITS(signed char); + +// +// ValueTraits: double +// +CXXTEST_TEMPLATE_INSTANTIATION +class ValueTraits +{ +public: + ValueTraits(double t) + { + if ((t != t) || (t >= HUGE_VAL) || (t == -HUGE_VAL)) + { + nonFiniteNumber(t); + } + else if (requiredDigitsOnLeft(t) > MAX_DIGITS_ON_LEFT) + { + hugeNumber(t); + } + else + { + normalNumber(t); + } + } + + const char *asString(void) const { return _asString; } + +private: + enum { MAX_DIGITS_ON_LEFT = 24, DIGITS_ON_RIGHT = 4, BASE = 10 }; + char _asString[1 + MAX_DIGITS_ON_LEFT + 1 + DIGITS_ON_RIGHT + 1]; + + static unsigned requiredDigitsOnLeft(double t); + char *doNegative(double &t); + void hugeNumber(double t); + void normalNumber(double t); + void nonFiniteNumber(double t); + char *doubleToString(double t, char *s, unsigned skip = 0, unsigned max = (unsigned) - 1); +}; + +CXXTEST_COPY_CONST_TRAITS(double); + +// +// ValueTraits: float +// +CXXTEST_COPY_TRAITS(const float, const double); +CXXTEST_COPY_CONST_TRAITS(float); +#endif // !CXXTEST_USER_VALUE_TRAITS +} + +#ifdef _CXXTEST_HAVE_STD +# include +#endif // _CXXTEST_HAVE_STD + +namespace dummy_enum_ns {} + +// +// CXXTEST_ENUM_TRAITS +// +#define CXXTEST_ENUM_TRAITS( TYPE, VALUES ) \ + namespace CxxTest \ + { \ + CXXTEST_TEMPLATE_INSTANTIATION \ + class ValueTraits \ + { \ + TYPE _value; \ + char _fallback[sizeof("(" #TYPE ")") + 3 * sizeof(TYPE)]; \ + public: \ + ValueTraits( TYPE value ) { \ + _value = value; \ + numberToString( _value, copyString( _fallback, "(" #TYPE ")" ) ); \ + } \ + const char *asString( void ) const \ + { \ + switch ( _value ) \ + { \ + VALUES \ + default: return _fallback; \ + } \ + } \ + }; \ + } using namespace dummy_enum_ns + +#define CXXTEST_ENUM_MEMBER( MEMBER ) \ + case MEMBER: return #MEMBER; + +#endif // __cxxtest__ValueTraits_h__ diff --git a/third-party/cxxtest/cxxtest/Win32Gui.h b/third-party/cxxtest/cxxtest/Win32Gui.h new file mode 100644 index 00000000..bf05bd9f --- /dev/null +++ b/third-party/cxxtest/cxxtest/Win32Gui.h @@ -0,0 +1,572 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__Win32Gui_h__ +#define __cxxtest__Win32Gui_h__ + +// +// The Win32Gui displays a simple progress bar using the Win32 API. +// +// It accepts the following command line options: +// -minimized Start minimized, pop up on error +// -keep Don't close the window at the end +// -title TITLE Set the window caption +// +// If both -minimized and -keep are specified, GUI will only keep the +// window if it's in focus. +// +// N.B. If you're wondering why this class doesn't use any standard +// library or STL ( would have been nice) it's because it only +// uses "straight" Win32 API. +// + +#include + +#include +#include + +namespace CxxTest +{ +class Win32Gui : public GuiListener +{ +public: + void enterGui(int &argc, char **argv) + { + parseCommandLine(argc, argv); + } + + void enterWorld(const WorldDescription &wd) + { + getTotalTests(wd); + _testsDone = 0; + startGuiThread(); + } + + void guiEnterSuite(const char *suiteName) + { + showSuiteName(suiteName); + reset(_suiteStart); + } + + void guiEnterTest(const char *suiteName, const char *testName) + { + ++ _testsDone; + setTestCaption(suiteName, testName); + showTestName(testName); + showTestsDone(); + progressBarMessage(PBM_STEPIT); + reset(_testStart); + } + + void yellowBar() + { + setColor(255, 255, 0); + setIcon(IDI_WARNING); + getTotalTests(); + } + + void redBar() + { + if (_startMinimized) + { + showMainWindow(SW_SHOWNORMAL); + } + setColor(255, 0, 0); + setIcon(IDI_ERROR); + getTotalTests(); + } + + void leaveGui() + { + if (keep()) + { + showSummary(); + WaitForSingleObject(_gui, INFINITE); + } + DestroyWindow(_mainWindow); + } + +private: + const char *_title; + bool _startMinimized, _keep; + HANDLE _gui; + WNDCLASSEX _windowClass; + HWND _mainWindow, _progressBar, _statusBar; + HANDLE _canStartTests; + unsigned _numTotalTests, _testsDone; + char _strTotalTests[WorldDescription::MAX_STRLEN_TOTAL_TESTS]; + enum + { + STATUS_SUITE_NAME, STATUS_SUITE_TIME, + STATUS_TEST_NAME, STATUS_TEST_TIME, + STATUS_TESTS_DONE, STATUS_WORLD_TIME, + STATUS_TOTAL_PARTS + }; + int _statusWidths[STATUS_TOTAL_PARTS]; + unsigned _statusOffsets[STATUS_TOTAL_PARTS]; + unsigned _statusTotal; + char _statusTestsDone[sizeof("1000000000 of (100%)") + WorldDescription::MAX_STRLEN_TOTAL_TESTS]; + DWORD _worldStart, _suiteStart, _testStart; + char _timeString[sizeof("00:00:00")]; + + void parseCommandLine(int argc, char **argv) + { + _startMinimized = _keep = false; + _title = argv[0]; + + for (int i = 1; i < argc; ++ i) + { + if (!lstrcmpA(argv[i], "-minimized")) + { + _startMinimized = true; + } + else if (!lstrcmpA(argv[i], "-keep")) + { + _keep = true; + } + else if (!lstrcmpA(argv[i], "-title") && (i + 1 < argc)) + { + _title = argv[++i]; + } + } + } + + void getTotalTests() + { + getTotalTests(tracker().world()); + } + + void getTotalTests(const WorldDescription &wd) + { + _numTotalTests = wd.numTotalTests(); + wd.strTotalTests(_strTotalTests); + } + + void startGuiThread() + { + _canStartTests = CreateEvent(NULL, TRUE, FALSE, NULL); + DWORD threadId; + _gui = CreateThread(NULL, 0, &(Win32Gui::guiThread), (LPVOID)this, 0, &threadId); + WaitForSingleObject(_canStartTests, INFINITE); + } + + static DWORD WINAPI guiThread(LPVOID parameter) + { + ((Win32Gui *)parameter)->gui(); + return 0; + } + + void gui() + { + registerWindowClass(); + createMainWindow(); + initCommonControls(); + createProgressBar(); + createStatusBar(); + centerMainWindow(); + showMainWindow(); + startTimer(); + startTests(); + + messageLoop(); + } + + void registerWindowClass() + { + _windowClass.cbSize = sizeof(_windowClass); + _windowClass.style = CS_HREDRAW | CS_VREDRAW; + _windowClass.lpfnWndProc = &(Win32Gui::windowProcedure); + _windowClass.cbClsExtra = 0; + _windowClass.cbWndExtra = sizeof(LONG); + _windowClass.hInstance = (HINSTANCE)NULL; + _windowClass.hIcon = (HICON)NULL; + _windowClass.hCursor = (HCURSOR)NULL; + _windowClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); + _windowClass.lpszMenuName = NULL; + _windowClass.lpszClassName = TEXT("CxxTest Window Class"); + _windowClass.hIconSm = (HICON)NULL; + + RegisterClassEx(&_windowClass); + } + + void createMainWindow() + { + _mainWindow = createWindow(_windowClass.lpszClassName, WS_OVERLAPPEDWINDOW); + } + + void initCommonControls() + { + HMODULE dll = LoadLibraryA("comctl32.dll"); + if (!dll) { return; } + + typedef void (WINAPI * FUNC)(void); + FUNC func = (FUNC)GetProcAddress(dll, "InitCommonControls"); + if (!func) { return; } + func(); + } + + void createProgressBar() + { + _progressBar = createWindow(PROGRESS_CLASS, WS_CHILD | WS_VISIBLE | PBS_SMOOTH, _mainWindow); + +#ifdef PBM_SETRANGE32 + progressBarMessage(PBM_SETRANGE32, 0, _numTotalTests); +#else // No PBM_SETRANGE32, use PBM_SETRANGE + progressBarMessage(PBM_SETRANGE, 0, MAKELPARAM(0, (WORD)_numTotalTests)); +#endif // PBM_SETRANGE32 + progressBarMessage(PBM_SETPOS, 0); + progressBarMessage(PBM_SETSTEP, 1); + greenBar(); + UpdateWindow(_progressBar); + } + + void createStatusBar() + { + _statusBar = createWindow(STATUSCLASSNAME, WS_CHILD | WS_VISIBLE, _mainWindow); + setRatios(4, 1, 3, 1, 3, 1); + } + + void setRatios(unsigned suiteNameRatio, unsigned suiteTimeRatio, + unsigned testNameRatio, unsigned testTimeRatio, + unsigned testsDoneRatio, unsigned worldTimeRatio) + { + _statusTotal = 0; + _statusOffsets[STATUS_SUITE_NAME] = (_statusTotal += suiteNameRatio); + _statusOffsets[STATUS_SUITE_TIME] = (_statusTotal += suiteTimeRatio); + _statusOffsets[STATUS_TEST_NAME] = (_statusTotal += testNameRatio); + _statusOffsets[STATUS_TEST_TIME] = (_statusTotal += testTimeRatio); + _statusOffsets[STATUS_TESTS_DONE] = (_statusTotal += testsDoneRatio); + _statusOffsets[STATUS_WORLD_TIME] = (_statusTotal += worldTimeRatio); + } + + HWND createWindow(LPCTSTR className, DWORD style, HWND parent = (HWND)NULL) + { + return CreateWindow(className, NULL, style, 0, 0, 0, 0, parent, + (HMENU)NULL, (HINSTANCE)NULL, (LPVOID)this); + } + + void progressBarMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0) + { + SendMessage(_progressBar, message, wParam, lParam); + } + + void centerMainWindow() + { + RECT screen; + getScreenArea(screen); + + LONG screenWidth = screen.right - screen.left; + LONG screenHeight = screen.bottom - screen.top; + + LONG xCenter = (screen.right + screen.left) / 2; + LONG yCenter = (screen.bottom + screen.top) / 2; + + LONG windowWidth = (screenWidth * 4) / 5; + LONG windowHeight = screenHeight / 10; + LONG minimumHeight = 2 * (GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFRAME)); + if (windowHeight < minimumHeight) + { + windowHeight = minimumHeight; + } + + SetWindowPos(_mainWindow, HWND_TOP, + xCenter - (windowWidth / 2), yCenter - (windowHeight / 2), + windowWidth, windowHeight, 0); + } + + void getScreenArea(RECT &area) + { + if (!getScreenAreaWithoutTaskbar(area)) + { + getWholeScreenArea(area); + } + } + + bool getScreenAreaWithoutTaskbar(RECT &area) + { + return (SystemParametersInfo(SPI_GETWORKAREA, sizeof(RECT), &area, 0) != 0); + } + + void getWholeScreenArea(RECT &area) + { + area.left = area.top = 0; + area.right = GetSystemMetrics(SM_CXSCREEN); + area.bottom = GetSystemMetrics(SM_CYSCREEN); + } + + void showMainWindow() + { + showMainWindow(_startMinimized ? SW_MINIMIZE : SW_SHOWNORMAL); + UpdateWindow(_mainWindow); + } + + void showMainWindow(int mode) + { + ShowWindow(_mainWindow, mode); + } + + enum { TIMER_ID = 1, TIMER_DELAY = 1000 }; + + void startTimer() + { + reset(_worldStart); + reset(_suiteStart); + reset(_testStart); + SetTimer(_mainWindow, TIMER_ID, TIMER_DELAY, 0); + } + + void reset(DWORD &tick) + { + tick = GetTickCount(); + } + + void startTests() + { + SetEvent(_canStartTests); + } + + void messageLoop() + { + MSG message; + while (BOOL haveMessage = GetMessage(&message, NULL, 0, 0)) + { + if (haveMessage != -1) + { + DispatchMessage(&message); + } + } + } + + static LRESULT CALLBACK windowProcedure(HWND window, UINT message, WPARAM wParam, LPARAM lParam) + { + if (message == WM_CREATE) + { + setUp(window, (LPCREATESTRUCT)lParam); + } + + Win32Gui *that = (Win32Gui *)GetWindowLong(window, GWL_USERDATA); + return that->handle(window, message, wParam, lParam); + } + + static void setUp(HWND window, LPCREATESTRUCT create) + { + SetWindowLong(window, GWL_USERDATA, (LONG)create->lpCreateParams); + } + + LRESULT handle(HWND window, UINT message, WPARAM wParam, LPARAM lParam) + { + switch (message) + { + case WM_SIZE: resizeControls(); break; + + case WM_TIMER: updateTime(); break; + + case WM_CLOSE: + case WM_DESTROY: + case WM_QUIT: + ExitProcess(tracker().failedTests()); + + default: return DefWindowProc(window, message, wParam, lParam); + } + return 0; + } + + void resizeControls() + { + RECT r; + GetClientRect(_mainWindow, &r); + LONG width = r.right - r.left; + LONG height = r.bottom - r.top; + + GetClientRect(_statusBar, &r); + LONG statusHeight = r.bottom - r.top; + LONG resizeGripWidth = statusHeight; + LONG progressHeight = height - statusHeight; + + SetWindowPos(_progressBar, HWND_TOP, 0, 0, width, progressHeight, 0); + SetWindowPos(_statusBar, HWND_TOP, 0, progressHeight, width, statusHeight, 0); + setStatusParts(width - resizeGripWidth); + } + + void setStatusParts(LONG width) + { + for (unsigned i = 0; i < STATUS_TOTAL_PARTS; ++ i) + { + _statusWidths[i] = (width * _statusOffsets[i]) / _statusTotal; + } + + statusBarMessage(SB_SETPARTS, STATUS_TOTAL_PARTS, _statusWidths); + } + + void statusBarMessage(UINT message, WPARAM wParam = 0, const void *lParam = 0) + { + SendMessage(_statusBar, message, wParam, (LPARAM)lParam); + } + + void greenBar() + { + setColor(0, 255, 0); + setIcon(IDI_INFORMATION); + } + +#ifdef PBM_SETBARCOLOR + void setColor(BYTE red, BYTE green, BYTE blue) + { + progressBarMessage(PBM_SETBARCOLOR, 0, RGB(red, green, blue)); + } +#else // !PBM_SETBARCOLOR + void setColor(BYTE, BYTE, BYTE) + { + } +#endif // PBM_SETBARCOLOR + + void setIcon(LPCTSTR icon) + { + SendMessage(_mainWindow, WM_SETICON, ICON_BIG, (LPARAM)loadStandardIcon(icon)); + } + + HICON loadStandardIcon(LPCTSTR icon) + { + return LoadIcon((HINSTANCE)NULL, icon); + } + + void setTestCaption(const char *suiteName, const char *testName) + { + setCaption(suiteName, "::", testName, "()"); + } + + void setCaption(const char *a = "", const char *b = "", const char *c = "", const char *d = "") + { + unsigned length = lstrlenA(_title) + sizeof(" - ") + + lstrlenA(a) + lstrlenA(b) + lstrlenA(c) + lstrlenA(d); + char *name = allocate(length); + lstrcpyA(name, _title); + lstrcatA(name, " - "); + lstrcatA(name, a); + lstrcatA(name, b); + lstrcatA(name, c); + lstrcatA(name, d); + SetWindowTextA(_mainWindow, name); + deallocate(name); + } + + void showSuiteName(const char *suiteName) + { + setStatusPart(STATUS_SUITE_NAME, suiteName); + } + + void showTestName(const char *testName) + { + setStatusPart(STATUS_TEST_NAME, testName); + } + + void showTestsDone() + { + wsprintfA(_statusTestsDone, "%u of %s (%u%%)", + _testsDone, _strTotalTests, + (_testsDone * 100) / _numTotalTests); + setStatusPart(STATUS_TESTS_DONE, _statusTestsDone); + } + + void updateTime() + { + setStatusTime(STATUS_WORLD_TIME, _worldStart); + setStatusTime(STATUS_SUITE_TIME, _suiteStart); + setStatusTime(STATUS_TEST_TIME, _testStart); + } + + void setStatusTime(unsigned part, DWORD start) + { + unsigned total = (GetTickCount() - start) / 1000; + unsigned hours = total / 3600; + unsigned minutes = (total / 60) % 60; + unsigned seconds = total % 60; + + if (hours) + { + wsprintfA(_timeString, "%u:%02u:%02u", hours, minutes, seconds); + } + else + { + wsprintfA(_timeString, "%02u:%02u", minutes, seconds); + } + + setStatusPart(part, _timeString); + } + + bool keep() + { + if (!_keep) + { + return false; + } + if (!_startMinimized) + { + return true; + } + return (_mainWindow == GetForegroundWindow()); + } + + void showSummary() + { + stopTimer(); + setSummaryStatusBar(); + setSummaryCaption(); + } + + void setStatusPart(unsigned part, const char *text) + { + statusBarMessage(SB_SETTEXTA, part, text); + } + + void stopTimer() + { + KillTimer(_mainWindow, TIMER_ID); + setStatusTime(STATUS_WORLD_TIME, _worldStart); + } + + void setSummaryStatusBar() + { + setRatios(0, 0, 0, 0, 1, 1); + resizeControls(); + + const char *tests = (_numTotalTests == 1) ? "test" : "tests"; + if (tracker().failedTests()) + { + wsprintfA(_statusTestsDone, "Failed %u of %s %s", + tracker().failedTests(), _strTotalTests, tests); + } + else + { + wsprintfA(_statusTestsDone, "%s %s passed", _strTotalTests, tests); + } + + setStatusPart(STATUS_TESTS_DONE, _statusTestsDone); + } + + void setSummaryCaption() + { + setCaption(_statusTestsDone); + } + + char *allocate(unsigned length) + { + return (char *)HeapAlloc(GetProcessHeap(), 0, length); + } + + void deallocate(char *data) + { + HeapFree(GetProcessHeap(), 0, data); + } +}; +} + +#endif // __cxxtest__Win32Gui_h__ diff --git a/third-party/cxxtest/cxxtest/X11Gui.h b/third-party/cxxtest/cxxtest/X11Gui.h new file mode 100644 index 00000000..6e7ef595 --- /dev/null +++ b/third-party/cxxtest/cxxtest/X11Gui.h @@ -0,0 +1,367 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__X11Gui_h__ +#define __cxxtest__X11Gui_h__ + +// +// X11Gui displays a simple progress bar using X11 +// +// It accepts the following command-line arguments: +// -title - Sets the application title +// -fn or -font <font> - Sets the font +// -bg or -background <color> - Sets the background color (default=Grey) +// -fg or -foreground <color> - Sets the text color (default=Black) +// -green/-yellow/-red <color> - Sets the colors of the bar +// + +#include <cxxtest/Gui.h> + +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +namespace CxxTest +{ +class X11Gui : public GuiListener +{ +public: + void enterGui(int &argc, char **argv) + { + parseCommandLine(argc, argv); + } + + void enterWorld(const WorldDescription &wd) + { + openDisplay(); + if (_display) + { + createColors(); + createWindow(); + createGc(); + createFont(); + centerWindow(); + initializeEvents(); + initializeBar(wd); + processEvents(); + } + } + + void guiEnterTest(const char *suiteName, const char *testName) + { + if (_display) + { + ++ _testsDone; + setWindowName(suiteName, testName); + redraw(); + } + } + + void yellowBar() + { + if (_display) + { + _barColor = getColor(_yellowName); + getTotalTests(); + processEvents(); + } + } + + void redBar() + { + if (_display) + { + _barColor = getColor(_redName); + getTotalTests(); + processEvents(); + } + } + + void leaveGui() + { + if (_display) + { + freeFontInfo(); + destroyGc(); + destroyWindow(); + closeDisplay(); + } + } + +private: + const char *_programName; + Display *_display; + Window _window; + unsigned _numTotalTests, _testsDone; + char _strTotalTests[WorldDescription::MAX_STRLEN_TOTAL_TESTS]; + const char *_foregroundName, *_backgroundName; + const char *_greenName, *_yellowName, *_redName; + unsigned long _foreground, _background, _barColor; + int _width, _height; + GC _gc; + const char *_fontName; + XID _fontId; + XFontStruct *_fontInfo; + int _textHeight, _textDescent; + long _eventMask; + Colormap _colormap; + + void parseCommandLine(int &argc, char **argv) + { + _programName = argv[0]; + + _fontName = 0; + _foregroundName = "Black"; + _backgroundName = "Grey"; + _greenName = "Green"; + _yellowName = "Yellow"; + _redName = "Red"; + + for (int i = 1; i + 1 < argc; ++ i) + { + if (!strcmp(argv[i], "-title")) + { + _programName = argv[++ i]; + } + else if (!strcmp(argv[i], "-fn") || !strcmp(argv[i], "-font")) + { + _fontName = argv[++ i]; + } + else if (!strcmp(argv[i], "-fg") || !strcmp(argv[i], "-foreground")) + { + _foregroundName = argv[++ i]; + } + else if (!strcmp(argv[i], "-bg") || !strcmp(argv[i], "-background")) + { + _backgroundName = argv[++ i]; + } + else if (!strcmp(argv[i], "-green")) + { + _greenName = argv[++ i]; + } + else if (!strcmp(argv[i], "-yellow")) + { + _yellowName = argv[++ i]; + } + else if (!strcmp(argv[i], "-red")) + { + _redName = argv[++ i]; + } + } + } + + void openDisplay() + { + _display = XOpenDisplay(NULL); + } + + void createColors() + { + _colormap = DefaultColormap(_display, 0); + _foreground = getColor(_foregroundName); + _background = getColor(_backgroundName); + } + + unsigned long getColor(const char *colorName) + { + XColor color; + XParseColor(_display, _colormap, colorName, &color); + XAllocColor(_display, _colormap, &color); + return color.pixel; + } + + void createWindow() + { + _window = XCreateSimpleWindow(_display, RootWindow(_display, 0), 0, 0, 1, 1, 0, 0, _background); + } + + void createGc() + { + _gc = XCreateGC(_display, _window, 0, 0); + } + + void createFont() + { + if (!loadFont()) + { + useDefaultFont(); + } + getFontInfo(); + _textHeight = _fontInfo->ascent + _fontInfo->descent; + _textDescent = _fontInfo->descent; + } + + bool loadFont() + { + if (!_fontName) + { + return false; + } + _fontId = XLoadFont(_display, _fontName); + return (XSetFont(_display, _gc, _fontId) == Success); + } + + void useDefaultFont() + { + _fontId = XGContextFromGC(_gc); + } + + void getFontInfo() + { + _fontInfo = XQueryFont(_display, _fontId); + } + + void freeFontInfo() + { + XFreeFontInfo(NULL, _fontInfo, 1); + } + + void initializeEvents() + { + _eventMask = ExposureMask; + XSelectInput(_display, _window, _eventMask); + } + + void initializeBar(const WorldDescription &wd) + { + getTotalTests(wd); + _testsDone = 0; + _barColor = getColor(_greenName); + } + + void getTotalTests() + { + getTotalTests(tracker().world()); + } + + void getTotalTests(const WorldDescription &wd) + { + _numTotalTests = wd.numTotalTests(); + wd.strTotalTests(_strTotalTests); + } + + void centerWindow() + { + XMapWindow(_display, _window); + + Screen *screen = XDefaultScreenOfDisplay(_display); + int screenWidth = WidthOfScreen(screen); + int screenHeight = HeightOfScreen(screen); + int xCenter = screenWidth / 2; + int yCenter = screenHeight / 2; + + _width = (screenWidth * 4) / 5; + _height = screenHeight / 14; + + XMoveResizeWindow(_display, _window, xCenter - (_width / 2), yCenter - (_height / 2), _width, _height); + } + + void processEvents() + { + redraw(); + + XEvent event; + while (XCheckMaskEvent(_display, _eventMask, &event)) + { + redraw(); + } + } + + void setWindowName(const char *suiteName, const char *testName) + { + unsigned length = strlen(_programName) + strlen(suiteName) + strlen(testName) + sizeof(" - ::()"); + char *name = (char *)malloc(length); + sprintf(name, "%s - %s::%s()", _programName, suiteName, testName); + XSetStandardProperties(_display, _window, name, 0, 0, 0, 0, 0); + free(name); + } + + void redraw() + { + getWindowSize(); + drawSolidBar(); + drawDividers(); + drawPercentage(); + flush(); + } + + void getWindowSize() + { + XWindowAttributes attributes; + XGetWindowAttributes(_display, _window, &attributes); + _width = attributes.width; + _height = attributes.height; + } + + void drawSolidBar() + { + unsigned barWidth = (_width * _testsDone) / _numTotalTests; + + XSetForeground(_display, _gc, _barColor); + XFillRectangle(_display, _window, _gc, 0, 0, barWidth, _height); + + XSetForeground(_display, _gc, _background); + XFillRectangle(_display, _window, _gc, barWidth, 0, _width + 1 - barWidth, _height); + } + + void drawDividers() + { + if (_width / _numTotalTests < 5) + { + return; + } + for (unsigned i = 1; i < _testsDone; ++ i) + { + int x = (_width * i) / _numTotalTests; + XDrawLine(_display, _window, _gc, x, 0, x, _height); + } + } + + void drawPercentage() + { + XSetForeground(_display, _gc, _foreground); + + char str[sizeof("1000000000 of ") + sizeof(_strTotalTests) + sizeof(" (100%)")]; + sprintf(str, "%u of %s (%u%%)", _testsDone, _strTotalTests, (_testsDone * 100) / _numTotalTests); + unsigned len = strlen(str); + + int textWidth = XTextWidth(_fontInfo, str, len); + + XDrawString(_display, _window, _gc, + (_width - textWidth) / 2, ((_height + _textHeight) / 2) - _textDescent, + str, len); + } + + void flush() + { + XFlush(_display); + } + + void destroyGc() + { + XFreeGC(_display, _gc); + } + + void destroyWindow() + { + XDestroyWindow(_display, _window); + } + + void closeDisplay() + { + XCloseDisplay(_display); + } +}; +} + +#endif //__cxxtest__X11Gui_h__ diff --git a/third-party/cxxtest/cxxtest/XUnitPrinter.h b/third-party/cxxtest/cxxtest/XUnitPrinter.h new file mode 100644 index 00000000..b82fbffb --- /dev/null +++ b/third-party/cxxtest/cxxtest/XUnitPrinter.h @@ -0,0 +1,48 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __CXXTEST__XUNIT_PRINTER_H +#define __CXXTEST__XUNIT_PRINTER_H + +// +// XUnitPrinter combines an ErrorPrinter with an XML formatter. +// + +#include <cxxtest/TeeListener.h> +#include <cxxtest/ErrorPrinter.h> +#include <cxxtest/XmlPrinter.h> + +namespace CxxTest +{ +class XUnitPrinter : public TeeListener +{ +public: + + XmlPrinter xml_printer; + ErrorPrinter error_printer; + + XUnitPrinter(CXXTEST_STD(ostream) &o = CXXTEST_STD(cout)) + : xml_printer(o) + { + setFirst(error_printer); + setSecond(xml_printer); + } + + int run() + { + TestRunner::runAllTests(*this); + return tracker().failedTests(); + } +}; +} + +#endif //__CXXTEST__XUNIT_PRINTER_H + diff --git a/third-party/cxxtest/cxxtest/XmlFormatter.h b/third-party/cxxtest/cxxtest/XmlFormatter.h new file mode 100644 index 00000000..b6fd1a2f --- /dev/null +++ b/third-party/cxxtest/cxxtest/XmlFormatter.h @@ -0,0 +1,664 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +// Licensed under the LGPL, see http://www.gnu.org/licenses/lgpl.html + +#ifndef __CXXTEST__XMLFORMATTER_H +#define __CXXTEST__XMLFORMATTER_H + +// +// The XmlFormatter is a TestListener that +// prints reports of the errors to an output +// stream in the form of an XML document. +// + +// The following definitions are used if stack trace support is enabled, +// to give the traces an easily-parsable XML format. If stack tracing is +// not enabled, then these definitions will be ignored. +#define CXXTEST_STACK_TRACE_ESCAPE_AS_XML +#define CXXTEST_STACK_TRACE_NO_ESCAPE_FILELINE_AFFIXES + +#define CXXTEST_STACK_TRACE_INITIAL_PREFIX "<stack-frame function=\"" +#define CXXTEST_STACK_TRACE_INITIAL_SUFFIX "\"/>\n" +#define CXXTEST_STACK_TRACE_OTHER_PREFIX CXXTEST_STACK_TRACE_INITIAL_PREFIX +#define CXXTEST_STACK_TRACE_OTHER_SUFFIX CXXTEST_STACK_TRACE_INITIAL_SUFFIX +#define CXXTEST_STACK_TRACE_ELLIDED_MESSAGE "" +#define CXXTEST_STACK_TRACE_FILELINE_PREFIX "\" location=\"" +#define CXXTEST_STACK_TRACE_FILELINE_SUFFIX "" + + +#include <cxxtest/TestRunner.h> +#include <cxxtest/TestListener.h> +#include <cxxtest/TestTracker.h> +#include <cxxtest/ValueTraits.h> +#include <cxxtest/ErrorFormatter.h> +#include <cxxtest/StdHeaders.h> +#include <iostream> +#include <sstream> +#include <cstring> +#include <cstdio> +#include <ctime> + +namespace CxxTest +{ +class TeeOutputStreams +{ +private: + class teebuffer : public std::basic_streambuf<char> + { + typedef std::basic_streambuf<char> streambuf_t; + public: + teebuffer(streambuf_t * buf1, streambuf_t * buf2) + : buffer1(buf1), buffer2(buf2) + {} + + virtual int overflow(int c) + { + if (c == EOF) + { + return !EOF; + } + else + { + int const ans1 = buffer1->sputc(c); + int const ans2 = buffer2->sputc(c); + return ans1 == EOF || ans2 == EOF ? EOF : c; + } + } + + virtual int sync() + { + int ans1 = buffer1->pubsync(); + int ans2 = buffer2->pubsync(); + return ans1 || ans2 ? -1 : 0; + } + + streambuf_t * buffer1; + streambuf_t * buffer2; + }; + +public: + TeeOutputStreams(std::ostream& _cout, std::ostream& _cerr) + : out(), + err(), + orig_cout(_cout), + orig_cerr(_cerr), + tee_out(out.rdbuf(), _cout.rdbuf()), + tee_err(err.rdbuf(), _cerr.rdbuf()) + { + orig_cout.rdbuf(&tee_out); + orig_cerr.rdbuf(&tee_err); + } + + ~TeeOutputStreams() + { + orig_cout.rdbuf(tee_out.buffer2); + orig_cerr.rdbuf(tee_err.buffer2); + } + + std::stringstream out; + std::stringstream err; + +private: + std::ostream& orig_cout; + std::ostream& orig_cerr; + teebuffer tee_out; + teebuffer tee_err; +}; + +class ElementInfo +{ +public: + std::string name; + std::stringstream value; + std::map<std::string, std::string> attribute; + + ElementInfo() + : name(), value(), attribute() + {} + + ElementInfo(const ElementInfo& rhs) + : name(rhs.name), value(rhs.value.str()), attribute(rhs.attribute) + {} + + ElementInfo& operator=(const ElementInfo& rhs) + { + name = rhs.name; + value.str(rhs.value.str()); + attribute = rhs.attribute; + return *this; + } + + template <class Type> + void add(const std::string& name_, Type& value_) + { + std::ostringstream os; + os << value_; + attribute[name_] = os.str(); + } + + void write(OutputStream& os) + { + os << " <" << name.c_str() << " "; + std::map<std::string, std::string>::iterator curr = attribute.begin(); + std::map<std::string, std::string>::iterator end = attribute.end(); + while (curr != end) + { + os << curr->first.c_str() + << "=\"" << curr->second.c_str() << "\" "; + curr++; + } + if (value.str().empty()) + { + os << "/>"; + } + else + { + os << ">" << escape(value.str()).c_str() + << "</" << name.c_str() << ">"; + } + os.endl(os); + } + + std::string escape(const std::string& str) + { + std::string escStr = ""; + for (size_t i = 0; i < str.length(); i++) + { + switch (str[i]) + { + case '"': escStr += """; break; + case '\'': escStr += "'"; break; + case '<': escStr += "<"; break; + case '>': escStr += ">"; break; + case '&': escStr += "&"; break; + default: escStr += str[i]; break; + } + } + return escStr; + } + +}; + +class TestCaseInfo +{ +public: + + TestCaseInfo() : fail(false), error(false), runtime(0.0) {} + std::string className; + std::string testName; + std::string line; + bool fail; + bool error; + double runtime; + std::list<ElementInfo> elements; + typedef std::list<ElementInfo>::iterator element_t; + std::string world; + + element_t add_element(const std::string& name) + { + element_t elt = elements.insert(elements.end(), ElementInfo()); + elt->name = name; + return elt; + } + + element_t update_element(const std::string& name) + { + element_t elt = elements.begin(); + while (elt != elements.end()) + { + if (elt->name == name) + { + return elt; + } + elt++; + } + return add_element(name); + } + + void write(OutputStream &o) + { + o << " <testcase classname=\"" << className.c_str() + << "\" name=\"" << testName.c_str() + << "\" line=\"" << line.c_str() << "\""; + bool elts = false; + element_t curr = elements.begin(); + element_t end = elements.end(); + while (curr != end) + { + if (!elts) + { + o << ">"; + o.endl(o); + elts = true; + } + curr->write(o); + curr++; + } + if (elts) + { + o << " </testcase>"; + } + else + { + o << " />"; + } + o.endl(o); + } + +}; + +class XmlFormatter : public TestListener +{ +public: + XmlFormatter(OutputStream *o, OutputStream *ostr, std::ostringstream *os) + : _o(o), _ostr(ostr), _os(os), stream_redirect(NULL) + { + testcase = info.end(); + } + + std::list<TestCaseInfo> info; + std::list<TestCaseInfo>::iterator testcase; + typedef std::list<ElementInfo>::iterator element_t; + std::string classname; + int ntests; + int nfail; + int nerror; + double totaltime; + + int run() + { + TestRunner::runAllTests(*this); + return tracker().failedTests(); + } + + void enterWorld(const WorldDescription & /*desc*/) + { + ntests = 0; + nfail = 0; + nerror = 0; + totaltime = 0; + } + + static void totalTests(OutputStream &o) + { + char s[WorldDescription::MAX_STRLEN_TOTAL_TESTS]; + const WorldDescription &wd = tracker().world(); + o << wd.strTotalTests(s) + << (wd.numTotalTests() == 1 ? " test" : " tests"); + } + + void enterSuite(const SuiteDescription& desc) + { + classname = desc.suiteName(); + // replace "::" namespace with java-style "." + size_t pos = 0; + while ((pos = classname.find("::", pos)) != + CXXTEST_STD(string::npos)) + { + classname.replace(pos, 2, "."); + } + while (! classname.empty() && classname[0] == '.') + { + classname.erase(0, 1); + } + + //CXXTEST_STD(cout) << "HERE " << desc.file() << " " + // << classname << CXXTEST_STD(endl); + + //classname=desc.suiteName(); + //(*_o) << "file=\"" << desc.file() << "\" "; + //(*_o) << "line=\"" << desc.line() << "\""; + //_o->flush(); + } + + void leaveSuite(const SuiteDescription &) + { + std::list<TestCaseInfo>::iterator curr = info.begin(); + std::list<TestCaseInfo>::iterator end = info.end(); + while (curr != end) + { + if (curr->fail) { nfail++; } + if (curr->error) { nerror++; } + totaltime += curr->runtime; + ntests++; + curr++; + } + curr = info.begin(); + end = info.end(); + while (curr != end) + { + (*curr).write(*_ostr); + curr++; + } + info.clear(); + } + + void enterTest(const TestDescription & desc) + { + testcase = info.insert(info.end(), TestCaseInfo()); + testcase->testName = desc.testName(); + testcase->className = classname; + std::ostringstream os; + os << desc.line(); + testcase->line = os.str(); + + if (stream_redirect) + CXXTEST_STD(cerr) << "ERROR: The stream_redirect != NULL" + << CXXTEST_STD(endl); + + stream_redirect = + new TeeOutputStreams(CXXTEST_STD(cout), CXXTEST_STD(cerr)); + } + + void leaveTest(const TestDescription &) + { + if (stream_redirect != NULL) + { + std::string out = stream_redirect->out.str(); + if (! out.empty()) + { + // silently ignore the '.' + if (out[0] != '.' || out.size() > 1) + { + testcase->add_element("system-out")->value << out; + } + } + if (! stream_redirect->err.str().empty()) + { + testcase->add_element("system-err")->value << stream_redirect->err.str(); + } + + delete stream_redirect; + stream_redirect = NULL; + } + } + + void leaveWorld(const WorldDescription& desc) + { + std::ostringstream os; + const std::string currentDateTime = currentDateTimeStr(); + os << totaltime; + (*_o) << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" << endl; + (*_o) << "<testsuite name=\"" << desc.worldName() << "\" "; + (*_o) << "date=\"" << currentDateTime.c_str(); + (*_o) << "\" tests=\"" << ntests + << "\" errors=\"" << nerror + << "\" failures=\"" << nfail + << "\" time=\"" << os.str().c_str() << "\" >"; + _o->endl(*_o); + (*_o) << _os->str().c_str(); + _os->clear(); + (*_o) << "</testsuite>" << endl; + _o->flush(); + } + + void trace(const char* /*file*/, int line, const char *expression) + { + if (testcase == info.end()) { + return; + } + element_t elt = testcase->add_element("trace"); + elt->add("line", line); + elt->value << expression; + } + + void warning(const char* /*file*/, int line, const char *expression) + { + if (testcase == info.end()) { + return; + } + element_t elt = testcase->add_element("warning"); + elt->add("line", line); + elt->value << expression; + } + + void skippedTest(const char* file, int line, const char* expression) + { + testSkipped(file, line, "skipped") << "Test skipped: " << expression; + } + + void failedTest(const char* file, int line, const char* expression) + { + testFailure(file, line, "failure") << "Test failed: " << expression; + } + + void failedAssert(const char *file, int line, const char *expression) + { + testFailure(file, line, "failedAssert") + << "Assertion failed: " << expression; + } + + void failedAssertEquals(const char *file, int line, + const char* xStr, const char* yStr, + const char *x, const char *y) + { + testFailure(file, line, "failedAssertEquals") + << "Error: Expected (" + << xStr << " == " << yStr << "), found (" + << x << " != " << y << ")"; + } + + void failedAssertSameData(const char *file, int line, + const char *xStr, const char *yStr, const char *sizeStr, + const void* /*x*/, const void* /*y*/, unsigned size) + { + testFailure(file, line, "failedAssertSameData") + << "Error: Expected " << sizeStr + << " (" << size << ") bytes to be equal at (" + << xStr << ") and (" << yStr << "), found"; + } + + void failedAssertSameFiles(const char *file, int line, + const char *, const char *, + const char* explanation + ) + { + testFailure(file, line, "failedAssertSameFiles") + << "Error: " << explanation; + } + + void failedAssertDelta(const char *file, int line, + const char *xStr, const char *yStr, const char *dStr, + const char *x, const char *y, const char *d) + { + testFailure(file, line, "failedAssertDelta") + << "Error: Expected (" + << xStr << " == " << yStr << ") up to " << dStr + << " (" << d << "), found (" + << x << " != " << y << ")"; + } + + void failedAssertDiffers(const char *file, int line, + const char *xStr, const char *yStr, + const char *value) + { + testFailure(file, line, "failedAssertDiffers") + << "Error: Expected (" + << xStr << " != " << yStr << "), found (" + << value << ")"; + } + + void failedAssertLessThan(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + testFailure(file, line, "failedAssertLessThan") + << "Error: Expected (" << + xStr << " < " << yStr << "), found (" << + x << " >= " << y << ")"; + } + + void failedAssertLessThanEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + testFailure(file, line, "failedAssertLessThanEquals") + << "Error: Expected (" << + xStr << " <= " << yStr << "), found (" << + x << " > " << y << ")"; + } + + void failedAssertRelation(const char *file, int line, + const char *relation, const char *xStr, const char *yStr, + const char *x, const char *y) + { + testFailure(file, line, "failedAssertRelation") + << "Error: Expected " << relation << "( " << + xStr << ", " << yStr << " ), found !" << relation + << "( " << x << ", " << y << " )"; + } + + void failedAssertPredicate(const char *file, int line, + const char *predicate, const char *xStr, const char *x) + { + testFailure(file, line, "failedAssertPredicate") + << "Error: Expected " << predicate << "( " << + xStr << " ), found !" << predicate << "( " << x << " )"; + } + + void failedAssertThrows(const char *file, int line, + const char *expression, const char *type, + bool otherThrown) + { + testFailure(file, line, "failedAssertThrows") + << "Error: Expected (" << expression << ") to throw (" << + type << ") but it " + << (otherThrown ? "threw something else" : "didn't throw"); + } + + void failedAssertThrowsNot(const char *file, int line, const char *expression) + { + testFailure(file, line, "failedAssertThrowsNot") + << "Error: Expected (" << expression + << ") not to throw, but it did"; + } + +protected: + + OutputStream *outputStream() const + { + return _o; + } + + OutputStream *outputFileStream() const + { + return _ostr; + } + +private: + XmlFormatter(const XmlFormatter &); + XmlFormatter &operator=(const XmlFormatter &); + + std::stringstream& testFailure(const char* file, int line, const char *failureType) + { + testcase->fail = true; + element_t elt = testcase->update_element("failure"); + if (elt->value.str().empty()) + { + elt->add("type", failureType); + elt->add("line", line); + elt->add("file", file); + } + else + { + elt->value << CXXTEST_STD(endl); + } + return elt->value; + //failedTest(file,line,message.c_str()); + } + + std::stringstream& testSkipped(const char* file, int line, const char *failureType) + { + //testcase->fail = true; + element_t elt = testcase->update_element("skipped"); + if (elt->value.str().empty()) + { + elt->add("type", failureType); + elt->add("line", line); + elt->add("file", file); + } + else + { + elt->value << CXXTEST_STD(endl); + } + return elt->value; + } + + std::string currentDateTimeStr() + { + std::string retVal; + const time_t now(time(NULL)); + char current_date_string[27]; + +#ifdef WIN32 + if (ctime_s(current_date_string, sizeof(current_date_string)-1, &now) == 0) + { + retVal = current_date_string; + retVal.erase(retVal.find_last_not_of(" \n\r\t")+1); // trim trailing whitespace + } +#else + const size_t n = strlen(ctime_r(&now, current_date_string)); + if (n) + { + current_date_string[n-1] = '\0'; // remove the ending \n + retVal = current_date_string; + } +#endif + return retVal; + } + +#if 0 + void attributeBinary(const char* name, const void *value, unsigned size) + { + (*_o) << name; + (*_o) << "=\""; + dump(value, size); + (*_o) << "\" "; + } + + void dump(const void *buffer, unsigned size) + { + if (!buffer) { return; } + + unsigned dumpSize = size; + if (maxDumpSize() && dumpSize > maxDumpSize()) + { + dumpSize = maxDumpSize(); + } + + const unsigned char *p = (const unsigned char *)buffer; + for (unsigned i = 0; i < dumpSize; ++ i) + { + (*_o) << byteToHex(*p++) << " "; + } + if (dumpSize < size) + { + (*_o) << "... "; + } + } +#endif + + static void endl(OutputStream &o) + { + OutputStream::endl(o); + } + + OutputStream *_o; + OutputStream *_ostr; + std::ostringstream *_os; + + TeeOutputStreams *stream_redirect; +}; +} + +#endif // __CXXTEST__XMLFORMATTER_H + diff --git a/third-party/cxxtest/cxxtest/XmlPrinter.h b/third-party/cxxtest/cxxtest/XmlPrinter.h new file mode 100644 index 00000000..a3ee08c2 --- /dev/null +++ b/third-party/cxxtest/cxxtest/XmlPrinter.h @@ -0,0 +1,75 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__XmlPrinter_h__ +#define __cxxtest__XmlPrinter_h__ + +// +// The XmlPrinter is a simple TestListener that +// prints JUnit style xml to the output stream +// + + +#include <cxxtest/Flags.h> + +#ifndef _CXXTEST_HAVE_STD +# define _CXXTEST_HAVE_STD +#endif // _CXXTEST_HAVE_STD + +#include <cxxtest/XmlFormatter.h> +#include <cxxtest/StdValueTraits.h> + +#include <sstream> +#ifdef _CXXTEST_OLD_STD +# include <iostream.h> +#else // !_CXXTEST_OLD_STD +# include <iostream> +#endif // _CXXTEST_OLD_STD + +namespace CxxTest +{ +class XmlPrinter : public XmlFormatter +{ +public: + XmlPrinter(CXXTEST_STD(ostream) &o = CXXTEST_STD(cout), const char* /*preLine*/ = ":", const char* /*postLine*/ = "") : + XmlFormatter(new Adapter(o), new Adapter(ostr), &ostr) {} + + virtual ~XmlPrinter() + { + delete outputStream(); + delete outputFileStream(); + } + +private: + + std::ostringstream ostr; + + class Adapter : public OutputStream + { + CXXTEST_STD(ostream) &_o; + public: + Adapter(CXXTEST_STD(ostream) &o) : _o(o) {} + void flush() { _o.flush(); } + OutputStream &operator<<(const char *s) { _o << s; return *this; } + OutputStream &operator<<(Manipulator m) { return OutputStream::operator<<(m); } + OutputStream &operator<<(unsigned i) + { + char s[1 + 3 * sizeof(unsigned)]; + numberToString(i, s); + _o << s; + return *this; + } + }; +}; +} + +#endif // __cxxtest__XmlPrinter_h__ + diff --git a/third-party/cxxtest/cxxtest/YesNoRunner.h b/third-party/cxxtest/cxxtest/YesNoRunner.h new file mode 100644 index 00000000..6c1a921b --- /dev/null +++ b/third-party/cxxtest/cxxtest/YesNoRunner.h @@ -0,0 +1,40 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef __cxxtest__YesNoRunner_h__ +#define __cxxtest__YesNoRunner_h__ + +// +// The YesNoRunner is a simple TestListener that +// just returns true iff all tests passed. +// + +#include <cxxtest/TestRunner.h> +#include <cxxtest/TestListener.h> + +namespace CxxTest +{ +class YesNoRunner : public TestListener +{ +public: + YesNoRunner() + { + } + + int run() + { + TestRunner::runAllTests(*this); + return tracker().failedTests(); + } +}; +} + +#endif // __cxxtest__YesNoRunner_h__ diff --git a/third-party/cxxtest/cxxtest/unix.h b/third-party/cxxtest/cxxtest/unix.h new file mode 100644 index 00000000..91f3c6fa --- /dev/null +++ b/third-party/cxxtest/cxxtest/unix.h @@ -0,0 +1,311 @@ +/* +------------------------------------------------------------------------- + CxxTest: A lightweight C++ unit testing library. + Copyright (c) 2008 Sandia Corporation. + This software is distributed under the LGPL License v3 + For more information, see the COPYING file in the top CxxTest directory. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +------------------------------------------------------------------------- +*/ + +#ifndef UNIX_ERROR_PRINTER_H_N4C6JUX4 +#define UNIX_ERROR_PRINTER_H_N4C6JUX4 + +#ifndef _CXXTEST_HAVE_STD +# define _CXXTEST_HAVE_STD +#endif // _CXXTEST_HAVE_STD + +#include <cxxtest/Flags.h> +#include <cxxtest/TestRunner.h> +#include <cxxtest/TestListener.h> +#include <cxxtest/TestTracker.h> +#include <cxxtest/ValueTraits.h> +#include <cxxtest/StdValueTraits.h> +#include <cxxtest/ErrorFormatter.h> // CxxTest::OutputStream + +namespace CxxTest +{ +class UNIXErrorFormatter : public TestListener +{ +public: + UNIXErrorFormatter(OutputStream *o, const char *preLine = ":", const char *postLine = "") : + _reported(false), + _o(o), + _preLine(preLine), + _postLine(postLine) + { + } + + int run() + { + TestRunner::runAllTests(*this); + return tracker().failedTests(); + } + + static void totalTests(OutputStream &o) + { + char s[WorldDescription::MAX_STRLEN_TOTAL_TESTS]; + const WorldDescription &wd = tracker().world(); + o << wd.strTotalTests(s) << (wd.numTotalTests() == 1 ? " test" : " tests"); + } + + void enterTest(const TestDescription &) + { + _reported = false; + } + + void leaveWorld(const WorldDescription &desc) + { + if (tracker().failedTests()) + { + (*_o) << "Failed " << tracker().failedTests() << " of " << totalTests << endl; + unsigned numPassed = desc.numTotalTests() - tracker().failedTests() - tracer().skippedTests(); + unsigned numTotal = desc.numTotalTests() - tracker().skippedTests(); + if (numTotal == 0) + { + (*_o) << "Success rate: 100%" << endl; + } + else + { + (*_o) << "Success rate: " << (unsigned)(numPassed * 100.0 / numTotal) << "%" << endl; + } + } + } + + void trace(const char *file, int line, const char *expression) + { + stop(file, line) << "Trace: " << + expression << endl; + } + + void warning(const char *file, int line, const char *expression) + { + stop(file, line) << "Warning: " << + expression << endl; + } + + void skippedTest(const char *file, int line, const char *expression) + { + stop(file, line) << "Warning: Test skipped: " << + expression << endl; + } + + void failedTest(const char *file, int line, const char *expression) + { + stop(file, line) << "Error: Test failed: " << + expression << endl; + } + + void failedAssert(const char *file, int line, const char *expression) + { + stop(file, line) << "Error: Assertion failed: " << + expression << endl; + } + + void failedAssertEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + stop(file, line) << "Error: Expected (" << + xStr << " == " << yStr << "), found (" << + x << " != " << y << ")" << endl; + } + + void failedAssertSameData(const char *file, int line, + const char *xStr, const char *yStr, + const char *sizeStr, const void *x, + const void *y, unsigned size) + { + stop(file, line) << "Error: Expected " << sizeStr << " (" << size << ") bytes to be equal at (" << + xStr << ") and (" << yStr << "), found:" << endl; + dump(x, size); + (*_o) << " differs from" << endl; + dump(y, size); + } + + void failedAssertSameFiles(const char* file, int line, + const char*, const char*, + const char* explanation + ) + { + stop(file, line) << "Error: " << explanation << endl; + } + + void failedAssertDelta(const char *file, int line, + const char *xStr, const char *yStr, const char *dStr, + const char *x, const char *y, const char *d) + { + stop(file, line) << "Error: Expected (" << + xStr << " == " << yStr << ") up to " << dStr << " (" << d << "), found (" << + x << " != " << y << ")" << endl; + } + + void failedAssertDiffers(const char *file, int line, + const char *xStr, const char *yStr, + const char *value) + { + stop(file, line) << "Error: Expected (" << + xStr << " != " << yStr << "), found (" << + value << ")" << endl; + } + + void failedAssertLessThan(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + stop(file, line) << "Error: Expected (" << + xStr << " < " << yStr << "), found (" << + x << " >= " << y << ")" << endl; + } + + void failedAssertLessThanEquals(const char *file, int line, + const char *xStr, const char *yStr, + const char *x, const char *y) + { + stop(file, line) << "Error: Expected (" << + xStr << " <= " << yStr << "), found (" << + x << " > " << y << ")" << endl; + } + + void failedAssertRelation(const char *file, int line, + const char *relation, const char *xStr, const char *yStr, + const char *x, const char *y) + { + stop(file, line) << "Error: Expected " << relation << "( " << + xStr << ", " << yStr << " ), found !" << relation << "( " << x << ", " << y << " )" << endl; + } + + void failedAssertPredicate(const char *file, int line, + const char *predicate, const char *xStr, const char *x) + { + stop(file, line) << "Error: Expected " << predicate << "( " << + xStr << " ), found !" << predicate << "( " << x << " )" << endl; + } + + void failedAssertThrows(const char *file, int line, + const char *expression, const char *type, + bool otherThrown) + { + stop(file, line) << "Error: Expected (" << expression << ") to throw (" << + type << ") but it " << (otherThrown ? "threw something else" : "didn't throw") << + endl; + } + + void failedAssertThrowsNot(const char *file, int line, const char *expression) + { + stop(file, line) << "Error: Expected (" << expression << ") not to throw, but it did" << + endl; + } + +protected: + OutputStream *outputStream() const + { + return _o; + } + +private: + UNIXErrorFormatter(const UNIXErrorFormatter &); + UNIXErrorFormatter &operator=(const UNIXErrorFormatter &); + + OutputStream &stop(const char *file, int line) + { + reportTest(); + return (*_o) << file << _preLine << line << _postLine << ": "; + } + + void reportTest(void) + { + if (_reported) + { + return; + } + (*_o) << tracker().suite().file() << ": In " << tracker().suite().suiteName() << "::" << tracker().test().testName() << ":" << endl; + _reported = true; + } + + void dump(const void *buffer, unsigned size) + { + if (!buffer) + { + dumpNull(); + } + else + { + dumpBuffer(buffer, size); + } + } + + void dumpNull() + { + (*_o) << " (null)" << endl; + } + + void dumpBuffer(const void *buffer, unsigned size) + { + unsigned dumpSize = size; + if (maxDumpSize() && dumpSize > maxDumpSize()) + { + dumpSize = maxDumpSize(); + } + + const unsigned char *p = (const unsigned char *)buffer; + (*_o) << " { "; + for (unsigned i = 0; i < dumpSize; ++ i) + { + (*_o) << byteToHex(*p++) << " "; + } + if (dumpSize < size) + { + (*_o) << "... "; + } + (*_o) << "}" << endl; + } + + static void endl(OutputStream &o) + { + OutputStream::endl(o); + } + + bool _reported; + OutputStream *_o; + const char *_preLine; + const char *_postLine; +}; + +// ======================================================================================== +// = Actual runner is a subclass only because that is how the original ErrorPrinter works = +// ======================================================================================== + +class unix : public UNIXErrorFormatter +{ +public: + unix(CXXTEST_STD(ostream) &o = CXXTEST_STD(cerr), const char *preLine = ":", const char *postLine = "") : + UNIXErrorFormatter(new Adapter(o), preLine, postLine) {} + virtual ~unix() { delete outputStream(); } + +private: + class Adapter : public OutputStream + { + CXXTEST_STD(ostream) &_o; + public: + Adapter(CXXTEST_STD(ostream) &o) : _o(o) {} + void flush() { _o.flush(); } + OutputStream &operator<<(const char *s) { _o << s; return *this; } + OutputStream &operator<<(Manipulator m) { return OutputStream::operator<<(m); } + OutputStream &operator<<(unsigned i) + { + char s[1 + 3 * sizeof(unsigned)]; + numberToString(i, s); + _o << s; + return *this; + } + }; +}; +} + +#endif /* end of include guard: UNIX_ERROR_PRINTER_H_N4C6JUX4 */ + +// Copyright 2008 Sandia Corporation. Under the terms of Contract +// DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government +// retains certain rights in this software.