Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* fix gcc4 build of cppunit library by explicitly spelling out std:: in

Browse Source 
the headers and importing the required classes in the implementation files
* automatic whitespace cleanup

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@30586 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Oliver Tappe 2009-05-02 19:04:52 +00:00
parent 226136446a
commit 58481f0f6e
50 changed files with 683 additions and 605 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
headers/tools/cppunit/TestCase.h
View File

@ -9,30 +9,30 @@
//! Base class for single threaded unit tests
class CPPUNIT_API BTestCase : public CppUnit::TestCase {
public:
BTestCase(string Name = "");
BTestCase(std::string Name = "");
//! Displays the next sub test progress indicator (i.e. [0][1][2][3]...).
virtual void NextSubTest();
//! Starts a new sub test block (i.e. prints a newline :-)
virtual void NextSubTestBlock();
/*! \brief Prints to standard out just like printf, except shell verbosity
settings are honored.
*/
virtual void Outputf(const char *str, ...);
//! Saves the location of the current working directory.
//! Saves the location of the current working directory.
void SaveCWD();
virtual void tearDown();
//! Restores the current working directory to last directory saved by a call to SaveCWD().
//! Restores the current working directory to last directory saved by a call to SaveCWD().
void RestoreCWD(const char *alternate = NULL);
protected:
bool fValidCWD;
char fCurrentWorkingDir[B_PATH_NAME_LENGTH+1];
int32 fSubTestNum;
char fCurrentWorkingDir[B_PATH_NAME_LENGTH+1];
int32 fSubTestNum;
};
#endif // _beos_test_case_h_

10
headers/tools/cppunit/TestListener.h
View File

@ -4,15 +4,17 @@
#include <cppunit/TestListener.h>
#include <SupportDefs.h>
class CppUnit::Test;
class CppUnit::TestFailure;
class CppUnit::Exception;
namespace CppUnit {
class Test;
class TestFailure;
class Exception;
}
//! Handles printing of test information
/*! Receives notification of the beginning and end of each test,
and notification of all failures and errors. Prints out said
information in a standard format to standard output.
You should not need to explicitly use this class in any
of your tests.
*/

38
headers/tools/cppunit/TestShell.h
View File

@ -48,9 +48,9 @@ typedef CppUnit::SynchronizedObject::SynchronizationObject SyncObject;
*/
class CPPUNIT_API BTestShell {
public:
BTestShell(const string &description = "", SyncObject *syncObject = 0);
BTestShell(const std::string &description = "", SyncObject *syncObject = 0);
virtual ~BTestShell();
// This function is used to add the tests for a given kit (as contained
// in a BTestSuite object) to the list of available tests. The shell assumes
// ownership of the BTestSuite object. Each test in the kit is added to
@ -64,7 +64,7 @@ public:
// when the program is run with "--list" as an argument. Usually the
// given suite would be a test suite for an entire class, but that's
// not a requirement.
void AddTest(const string &name, CppUnit::Test* test);
void AddTest(const std::string &name, CppUnit::Test* test);
// This function loads all the test addons it finds in the given
// directory, returning the number of tests actually loaded.
@ -75,7 +75,7 @@ public:
// help, or lists installed tests, or whatever, depending on the
// command-line arguments passed in.
int Run(int argc, char *argv[]);
// Verbosity Level enumeration and accessor function
enum VerbosityLevel { v0, v1, v2, v3, v4 };
VerbosityLevel Verbosity() const;
@ -92,9 +92,9 @@ public:
// have to (and always make sure the pointer it returns isn't NULL
// before you try to use it :-).
static BTestShell* GlobalShell() { return fGlobalShell; };
// Sets the global BTestShell pointer. The BTestShell class does
// not assume ownership of the object.
// not assume ownership of the object.
static void SetGlobalShell(BTestShell *shell) { fGlobalShell = shell; };
const char* TestDir() const;
@ -104,18 +104,18 @@ public:
bool WasDebuggerCalled();
protected:
typedef map<string, CppUnit::Test*> TestMap;
typedef map<string, BTestSuite*> SuiteMap;
typedef std::map<std::string, CppUnit::Test*> TestMap;
typedef std::map<std::string, BTestSuite*> SuiteMap;
VerbosityLevel fVerbosityLevel;
set<string> fTestsToRun;
set<string> fSuitesToRun;
std::set<std::string> fTestsToRun;
std::set<std::string> fSuitesToRun;
TestMap fTests;
SuiteMap fSuites;
set<string> fLibDirs;
std::set<std::string> fLibDirs;
CppUnit::TestResult fTestResults;
CppUnit::TestResultCollector fResultsCollector;
string fDescription;
std::string fDescription;
static BTestShell* fGlobalShell;
static const char indent[];
bool fListTestsAndExit;
@ -134,7 +134,7 @@ protected:
//! Prints out command line argument instructions
void PrintHelp();
/*! \brief Prints out the list of valid command line arguments.
Called by PrintHelp().
*/
@ -142,15 +142,15 @@ protected:
//! Prints out a list of all the currently available tests
void PrintInstalledTests();
/*! \brief Handles command line arguments; returns true if everything goes
okay, false if not (or if the program just needs to terminate without
running any tests). Modifies settings in "settings" as necessary.
*/
bool ProcessArguments(int argc, char *argv[]);
//! Processes a single argument, given by the \c arg parameter.
virtual bool ProcessArgument(string arg, int argc, char *argv[]);
virtual bool ProcessArgument(std::string arg, int argc, char *argv[]);
//! Makes any necessary pre-test preparations
void InitOutput();
@ -159,12 +159,12 @@ protected:
the specified verbosity level.
*/
void PrintResults();
/*! \brief Searches all the paths in \c fLibDirs, loading any dynamically
loadable suites it finds.
*/
virtual void LoadDynamicSuites();
//! Sets the current test directory.
void UpdateTestDir(char *argv[]);
@ -187,7 +187,7 @@ private:
static image_id _LoadAddOnHook(const char* path);
static status_t _UnloadAddOnHook(image_id image);
#endif // ! NO_ELF_SYMBOL_PATCHING
}; // class BTestShell
#endif // _beos_test_shell_h_

22
headers/tools/cppunit/TestSuite.h
View File

@ -6,31 +6,33 @@
#include <map>
#include <string>
class CppUnit::TestResult;
namespace CppUnit {
class TestResult;
}
//! Groups together a set of tests for a given kit.
class CPPUNIT_API BTestSuite : public CppUnit::Test {
public:
BTestSuite( string name = "" );
BTestSuite(std::string name = "");
virtual ~BTestSuite();
virtual void run( CppUnit::TestResult *result );
virtual void run(CppUnit::TestResult *result);
virtual int countTestCases() const;
virtual string getName() const;
virtual string toString() const;
virtual std::string getName() const;
virtual std::string toString() const;
virtual void addTest(string name, CppUnit::Test *test);
virtual void addTest(std::string name, CppUnit::Test *test);
virtual void deleteContents();
const map<string, CppUnit::Test*> &getTests() const;
const std::map<std::string, CppUnit::Test*> &getTests() const;
protected:
map<string, CppUnit::Test*> fTests;
const string fName;
std::map<std::string, CppUnit::Test*> fTests;
const std::string fName;
private:
BTestSuite(const BTestSuite &other);
BTestSuite& operator=(const BTestSuite &other);
BTestSuite& operator=(const BTestSuite &other);
};

4
headers/tools/cppunit/TestUtils.h
View File

@ -28,7 +28,7 @@ Equals(const A &a, const B &b, const C &c)
}
// Returns a string version of the given integer
extern CPPUNIT_API string IntToStr(int i);
extern CPPUNIT_API std::string IntToStr(int i);
// Calls system() with the concatenated string of command and parameter.
extern CPPUNIT_API void ExecCommand(const char *command, const char *parameter);
@ -40,5 +40,5 @@ extern CPPUNIT_API void ExecCommand(const char *command, const char *parameter1,
// Calls system() with the given command (kind of silly, but it's consistent :-)
extern CPPUNIT_API void ExecCommand(const char *command);
#endif // __beos_test_utils_h__

70
headers/tools/cppunit/ThreadedTestCaller.h
View File

@ -14,23 +14,23 @@
class TestResult;
template <class TestClass, class ExpectedException = CppUnit::NoExceptionExpected>
class CPPUNIT_API BThreadedTestCaller : public CppUnit::TestCase {
class CPPUNIT_API BThreadedTestCaller : public CppUnit::TestCase {
public:
/*! \brief Pointer to a test function in the given class.
Each ThreadMethod added with addThread() is run in its own thread.
*/
typedef void (TestClass::*ThreadMethod)();
BThreadedTestCaller(std::string name);
BThreadedTestCaller(std::string name, TestClass &object);
BThreadedTestCaller(std::string name, TestClass *object);
BThreadedTestCaller(std::string name);
BThreadedTestCaller(std::string name, TestClass &object);
BThreadedTestCaller(std::string name, TestClass *object);
virtual ~BThreadedTestCaller();
virtual CppUnit::TestResult *run();
virtual void run(CppUnit::TestResult *result);
//! Adds a thread to the test. \c threadName must be unique to this BThreadedTestCaller.
void addThread(std::string threadName, ThreadMethod method);
void addThread(std::string threadName, ThreadMethod method);
protected:
virtual void setUp();
@ -42,9 +42,9 @@ protected:
bool fOwnObject;
TestClass *fObject;
ThreadManagerMap fThreads;
sem_id fThreadSem;
};
@ -78,19 +78,19 @@ BThreadedTestCaller<TestClass, ExpectedException>::BThreadedTestCaller(std::stri
template <class TestClass, class ExpectedException>
BThreadedTestCaller<TestClass, ExpectedException>::~BThreadedTestCaller() {
if (fOwnObject)
delete fObject;
for (ThreadManagerMap::iterator it = fThreads.begin(); it != fThreads.end (); ++it) {
delete fObject;
for (typename ThreadManagerMap::iterator it = fThreads.begin(); it != fThreads.end (); ++it) {
delete it->second;
}
}
template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::addThread(std::string threadName, ThreadMethod method) {
if (fThreads.find(threadName) == fThreads.end()) {
// Unused name, go ahead and add
fThreads[threadName] = new BThreadManager<TestClass, ExpectedException>(threadName, fObject, method, fThreadSem);
fThreads[threadName] = new BThreadManager<TestClass, ExpectedException>(threadName, fObject, method, fThreadSem);
} else {
// Duplicate name, throw an exception
throw CppUnit::Exception("BThreadedTestCaller::addThread() - Attempt to add thread under duplicated name ('"
@ -110,11 +110,11 @@ template <class TestClass, class ExpectedException>
void
BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *result) {
result->startTest(this);
if (fThreads.size() <= 0)
throw CppUnit::Exception("BThreadedTestCaller::run() -- No threads added to BThreadedTestCaller()");
try {
try {
setUp();
// This try/catch block should never actually have to catch
@ -131,13 +131,13 @@ BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *resu
// blocked; their output appears later...).
//
// Each thread will acquire the semaphore once when launched,
// thus the initial thread count is equal the number of threads.
// thus the initial thread count is equal the number of threads.
fThreadSem = create_sem(fThreads.size(), "ThreadSem");
if (fThreadSem < B_OK)
throw CppUnit::Exception("BThreadedTestCaller::run() -- Error creating fThreadSem");
throw CppUnit::Exception("BThreadedTestCaller::run() -- Error creating fThreadSem");
// Launch all the threads.
for (ThreadManagerMap::iterator i = fThreads.begin();
for (typename ThreadManagerMap::iterator i = fThreads.begin();
i != fThreads.end ();
++i)
{
@ -146,7 +146,7 @@ BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *resu
result->addError(this, new CppUnit::Exception("Error launching thread '" + i->second->getName() + "'"));
// printf("Launch(%s)\n", i->second->getName().c_str());
}
// Now we loop. Before you faint, there is a reason for this:
// Calls to NextSubTest() from other threads don't actually
// print anything while the main thread is blocked waiting
@ -158,13 +158,13 @@ BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *resu
// any pending updates, and tries to acquire the semaphore
// again. When it finally manages to acquire it, all the
// test threads have terminated, and it's safe to clean up.
status_t err;
do {
// Try to acquire the semaphore
err = acquire_sem_etc(fThreadSem, fThreads.size(), B_RELATIVE_TIMEOUT, 500000);
// Empty the UpdateList
// Empty the UpdateList
std::vector<std::string> &list = fObject->AcquireUpdateList();
for (std::vector<std::string>::iterator i = list.begin();
i != list.end();
@ -172,16 +172,16 @@ BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *resu
{
// Only print to standard out if the current global shell
// lets us (or if no global shell is designated).
if (BTestShell::GlobalBeVerbose()) {
if (BTestShell::GlobalBeVerbose()) {
printf("%s", (*i).c_str());
fflush(stdout);
}
}
list.clear();
fObject->ReleaseUpdateList();
fObject->ReleaseUpdateList();
} while (err != B_OK);
// If we get this far, we actually managed to acquire the semaphore,
// so we should release it now.
release_sem_etc(fThreadSem, fThreads.size(), 0);
@ -189,9 +189,9 @@ BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *resu
// Print out a newline for asthetics :-)
printf("\n");
/*
/*
// Wait for them all to finish, then clean up
for (ThreadManagerMap::iterator i = fThreads.begin();
i != fThreads.end ();
@ -206,21 +206,21 @@ BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *resu
*/
fThreads.clear();
} catch ( CppUnit::Exception &e ) {
// Add on the a note that this exception was caught by the
// thread caller (which is a bad thing), then note the exception
CppUnit::Exception *threadException = new CppUnit::Exception(
std::string(e.what()) + " (NOTE: caught by BThreadedTestCaller)",
e.sourceLine()
);
);
result->addFailure( fObject, threadException );
}
catch ( std::exception &e ) {
// Add on the thread name, then note the exception
CppUnit::Exception *threadException = new CppUnit::Exception(
std::string(e.what()) + " (NOTE: caught by BThreadedTestCaller)"
);
);
result->addError( fObject, threadException );
}
catch (...) {
@ -237,7 +237,7 @@ BThreadedTestCaller<TestClass, ExpectedException>::run(CppUnit::TestResult *resu
tearDown();
} catch (...) {
result->addError(this, new CppUnit::Exception("tearDown() failed"));
}
}
} catch (...) {
result->addError(this, new CppUnit::Exception("setUp() failed"));
} // setUp() try/catch block
@ -253,7 +253,7 @@ BThreadedTestCaller<TestClass, ExpectedException>::setUp() {
throw CppUnit::Exception("BThreadedTestCaller::runTest() -- NULL fObject pointer");
if (!fObject->RegisterForUse())
throw CppUnit::Exception("BThreadedTestCaller::runTest() -- Attempt to reuse ThreadedTestCase object already in use");
fObject->setUp();
}
@ -265,8 +265,8 @@ BThreadedTestCaller<TestClass, ExpectedException>::tearDown() {
template <class TestClass, class ExpectedException>
std::string
BThreadedTestCaller<TestClass, ExpectedException>::toString() const {
return std::string("BThreadedTestCaller for ") + getName();
BThreadedTestCaller<TestClass, ExpectedException>::toString() const {
return std::string("BThreadedTestCaller for ") + getName();
}
#endif // _beos_threaded_test_caller_h_

32
headers/tools/cppunit/ThreadedTestCase.h
View File

@ -11,46 +11,46 @@
//! Base class for single threaded unit tests
class CPPUNIT_API BThreadedTestCase : public BTestCase {
public:
BThreadedTestCase(string Name = "", string progressSeparator = ".");
BThreadedTestCase(std::string Name = "", std::string progressSeparator = ".");
virtual ~BThreadedTestCase();
/*! \brief Displays the next sub test progress indicator for the
thread in which it's called (i.e. [A.0][B.0][A.1][A.2][B.1]...). */
virtual void NextSubTest();
/*! \brief Prints to standard out just like printf, except shell verbosity
settings are honored, and output from threads other than the main thread
happens before the test is over.
\note Currently your output is limited to a length of 1024 characters. If
you really need to print a single string that's long than that, fix the
function yourself :-).
*/
virtual void Outputf(const char *str, ...);
//! Saves the location of the current working directory.
//! Saves the location of the current working directory.
void SaveCWD();
//! Restores the current working directory to last directory saved by a call to SaveCWD().
//! Restores the current working directory to last directory saved by a call to SaveCWD().
void RestoreCWD(const char *alternate = NULL);
void InitThreadInfo(thread_id id, string threadName);
void InitThreadInfo(thread_id id, std::string threadName);
bool RegisterForUse();
void UnregisterForUse();
vector<string>& AcquireUpdateList();
std::vector<std::string>& AcquireUpdateList();
void ReleaseUpdateList();
protected:
bool fInUse;
// friend class ThreadManager<BThreadedTestCase>;
string fProgressSeparator;
std::string fProgressSeparator;
struct ThreadSubTestInfo {
string name;
int32 subTestNum;
std::string name;
int32 subTestNum;
};
map<thread_id, ThreadSubTestInfo*> fNumberMap;
vector<string> fUpdateList;
std::map<thread_id, ThreadSubTestInfo*> fNumberMap;
std::vector<std::string> fUpdateList;
BLocker *fUpdateLock;
};

28
headers/tools/cppunit/cppunit/Asserter.h
View File

@ -16,23 +16,23 @@ namespace CppUnit
* \code
* #include <cppunit/SourceLine.h>
* #include <cppunit/TestAssert.h>
*
* void
*
* void
* checkXmlEqual( string expectedXml,
* string actualXml,
* CppUnit::SourceLine sourceLine )
* {
* string expected = XmlUniformiser( expectedXml ).stripped();
* string actual = XmlUniformiser( actualXml ).stripped();
*
*
* if ( expected == actual )
* return;
*
*
* ::CppUnit::Asserter::failNotEqual( expected,
* actual,
* sourceLine );
* }
*
*
* /// Asserts that two XML strings are equivalent.
* #define CPPUNITTEST_ASSERT_XML_EQUAL( expected, actual ) \
* checkXmlEqual( expected, actual, \
@ -44,7 +44,7 @@ namespace Asserter
/*! Throws a Exception with the specified message and location.
*/
void CPPUNIT_API fail( string message,
void CPPUNIT_API fail( std::string message,
SourceLine sourceLine = SourceLine() );
/*! Throws a Exception with the specified message and location.
@ -53,8 +53,8 @@ namespace Asserter
* \param message Message explaining the assertion failiure.
* \param sourceLine Location of the assertion.
*/
void CPPUNIT_API failIf( bool shouldFail,
string message,
void CPPUNIT_API failIf( bool shouldFail,
std::string message,
SourceLine sourceLine = SourceLine() );
/*! Throws a NotEqualException with the specified message and location.
@ -64,10 +64,10 @@ namespace Asserter
* where the "difference" is located.
* \param sourceLine Location of the assertion.
*/
void CPPUNIT_API failNotEqual( string expected,
string actual,
void CPPUNIT_API failNotEqual( std::string expected,
std::string actual,
SourceLine sourceLine = SourceLine(),
string additionalMessage ="" );
std::string additionalMessage ="" );
/*! Throws a NotEqualException with the specified message and location.
* \param shouldFail if \c true then the exception is thrown. Otherwise
@ -79,10 +79,10 @@ namespace Asserter
* \param sourceLine Location of the assertion.
*/
void CPPUNIT_API failNotEqualIf( bool shouldFail,
string expected,
string actual,
std::string expected,
std::string actual,
SourceLine sourceLine = SourceLine(),
string additionalMessage ="" );
std::string additionalMessage ="" );
} // namespace Asserter
} // namespace CppUnit

24
headers/tools/cppunit/cppunit/CompilerOutputter.h
View File

@ -15,7 +15,7 @@ class Test;
class TestFailure;
class TestResultCollector;
/*!
/*!
* \brief Outputs a TestResultCollector in a compiler compatible format.
* \ingroup WritingTestResult
*
@ -33,23 +33,23 @@ class TestResultCollector;
* int main( int argc, char* argv[] ) {
* // if command line contains "-selftest" then this is the post build check
* // => the output must be in the compiler error format.
* bool selfTest = (argc > 1) &&
* bool selfTest = (argc > 1) &&
* (string("-selftest") == argv[1]);
*
* CppUnit::TextUi::TestRunner runner;
* runner.addTest( CppUnitTest::suite() ); // Add the top suite to the test runner
*
*
* if ( selfTest )
* { // Change the default outputter to a compiler error format outputter
* // The test runner owns the new outputter.
* runner.setOutputter( CppUnit::CompilerOutputter::defaultOutputter(
* runner.setOutputter( CppUnit::CompilerOutputter::defaultOutputter(
* &runner.result(),
* cerr ) );
* }
*
*
* // Run the test and don't wait a key if post build check.
* bool wasSucessful = runner.run( "", !selfTest );
*
*
* // Return error code 1 if the one of test failed.
* return wasSucessful ? 0 : 1;
* }
@ -61,7 +61,7 @@ public:
/*! Constructs a CompilerOutputter object.
*/
CompilerOutputter( TestResultCollector *result,
ostream &stream );
std::ostream &stream );
/// Destructor.
virtual ~CompilerOutputter();
@ -69,7 +69,7 @@ public:
/*! Creates an instance of an outputter that matches your current compiler.
*/
static CompilerOutputter *defaultOutputter( TestResultCollector *result,
ostream &stream );
std::ostream &stream );
void write();
@ -84,7 +84,7 @@ public:
virtual void printFailureMessage( TestFailure *failure );
virtual void printNotEqualMessage( Exception *thrownException );
virtual void printDefaultMessage( Exception *thrownException );
virtual string wrap( string message );
virtual std::string wrap( std::string message );
private:
/// Prevents the use of the copy constructor.
@ -93,12 +93,12 @@ private:
/// Prevents the use of the copy operator.
void operator =( const CompilerOutputter &copy );
typedef vector<string> Lines;
static Lines splitMessageIntoLines( string message );
typedef std::vector<std::string> Lines;
static Lines splitMessageIntoLines( std::string message );
private:
TestResultCollector *m_result;
ostream &m_stream;
std::ostream &m_stream;
};

22
headers/tools/cppunit/cppunit/Exception.h
View File

@ -14,31 +14,31 @@ namespace CppUnit {
* Exception is an exception that serves
* descriptive strings through its what() method
*/
class CPPUNIT_API Exception : public exception
class CPPUNIT_API Exception : public std::exception
{
public:
class Type
{
public:
Type( string type ) : m_type ( type ) {}
Type( std::string type ) : m_type ( type ) {}
bool operator ==( const Type &other ) const
{
return m_type == other.m_type;
}
private:
const string m_type;
const std::string m_type;
};
Exception( string message = "",
Exception( std::string message = "",
SourceLine sourceLine = SourceLine() );
#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
Exception( string message,
long lineNumber,
string fileName );
Exception( std::string message,
long lineNumber,
std::string fileName );
#endif
Exception (const Exception& other);
@ -55,12 +55,12 @@ public:
long lineNumber() const;
string fileName() const;
static const string UNKNOWNFILENAME;
static const std::string UNKNOWNFILENAME;
static const long UNKNOWNLINENUMBER;
#endif
virtual Exception *clone() const;
virtual bool isInstanceOf( const Type &type ) const;
static Type type();
@ -68,9 +68,9 @@ public:
private:
// VC++ does not recognize call to parent class when prefixed
// with a namespace. This is a workaround.
typedef exception SuperClass;
typedef std::exception SuperClass;
string m_message;
std::string m_message;
SourceLine m_sourceLine;
};

26
headers/tools/cppunit/cppunit/NotEqualException.h
View File

@ -19,16 +19,16 @@ public:
* \param additionalMessage Additionnal information provided to further qualify
* the inequality.
*/
NotEqualException( string expected,
string actual,
NotEqualException( std::string expected,
std::string actual,
SourceLine sourceLine = SourceLine(),
string additionalMessage = "" );
std::string additionalMessage = "" );
#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
NotEqualException( string expected,
string actual,
long lineNumber,
string fileName );
NotEqualException( std::string expected,
std::string actual,
long lineNumber,
std::string fileName );
#endif
NotEqualException( const NotEqualException &other );
@ -36,11 +36,11 @@ public:
virtual ~NotEqualException() throw();
string expectedValue() const;
std::string expectedValue() const;
string actualValue() const;
std::string actualValue() const;
string additionalMessage() const;
std::string additionalMessage() const;
/*! Copy operator.
* @param other Object to copy.
@ -55,9 +55,9 @@ public:
static Type type();
private:
string m_expected;
string m_actual;
string m_additionalMessage;
std::string m_expected;
std::string m_actual;
std::string m_additionalMessage;
};
} // namespace CppUnit

18
headers/tools/cppunit/cppunit/Portability.h
View File

@ -21,6 +21,10 @@
#undef CPPUNIT_FUNC_STRING_COMPARE_STRING_FIRST
#endif
#if __GNUC__ > 2
#undef CPPUNIT_FUNC_STRING_COMPARE_STRING_FIRST
#endif
/* Define to 1 if you wish to have the old-style macros
assert(), assertEqual(), assertDoublesEqual(), and assertLongsEqual() */
#ifndef CPPUNIT_ENABLE_NAKED_ASSERT
@ -33,7 +37,7 @@
#define CPPUNIT_ENABLE_CU_TEST_MACROS 0
#endif
/* Define to 1 if the preprocessor expands (#foo) to "foo" (quotes incl.)
/* Define to 1 if the preprocessor expands (#foo) to "foo" (quotes incl.)
I don't think there is any C preprocess that does NOT support this! */
#ifndef CPPUNIT_HAVE_CPP_SOURCE_ANNOTATION
#define CPPUNIT_HAVE_CPP_SOURCE_ANNOTATION 1
@ -60,11 +64,11 @@
#if CPPUNIT_HAVE_SSTREAM
# include <sstream>
namespace CppUnit {
class OStringStream : public ostringstream
class OStringStream : public ostringstream
{
};
}
#else
#else
#if CPPUNIT_HAVE_CLASS_STRSTREAM
# include <string>
# if CPPUNIT_HAVE_STRSTREAM
@ -74,14 +78,14 @@
# endif
namespace CppUnit {
class OStringStream : public ostrstream
class OStringStream : public std::ostrstream
{
public:
string str()
std::string str()
{
(*this) << '\0';
string msg(ostrstream::str());
ostrstream::freeze(false);
std::string msg(std::ostrstream::str());
std::ostrstream::freeze(false);
return msg;
}
};

8
headers/tools/cppunit/cppunit/SourceLine.h
View File

@ -21,7 +21,7 @@ namespace CppUnit
* \ingroup BrowsingCollectedTestResult
*
* Used to capture the failure location in assertion.
*
*
* Use the CPPUNIT_SOURCELINE() macro to construct that object. Typically used when
* writing an assertion macro in association with Asserter.
*
@ -32,7 +32,7 @@ class CPPUNIT_API SourceLine
public:
SourceLine();
SourceLine( const string &fileName,
SourceLine( const std::string &fileName,
int lineNumber );
/// Destructor.
@ -42,13 +42,13 @@ public:
int lineNumber() const;
string fileName() const;
std::string fileName() const;
bool operator ==( const SourceLine &other ) const;
bool operator !=( const SourceLine &other ) const;
private:
string m_fileName;
std::string m_fileName;
int m_lineNumber;
};

10
headers/tools/cppunit/cppunit/Test.h
View File

@ -13,7 +13,7 @@ class TestResult;
*
* All test objects should be a subclass of Test. Some test objects,
* TestCase for example, represent one individual test. Other test
* objects, such as TestSuite, are comprised of several tests.
* objects, such as TestSuite, are comprised of several tests.
*
* When a Test is run, the result is collected by a TestResult object.
*
@ -38,20 +38,20 @@ public:
virtual int countTestCases () const = 0;
/*! \brief Returns the test name.
*
*
* Each test has a name. This name may be used to find the
* test in a suite or registry of tests.
*/
virtual string getName () const = 0;
virtual std::string getName () const = 0;
/*! \brief Description of the test, for diagnostic output.
*
* The test description will typically include the test name,
* but may have additional description. For example, a test
* suite named <tt>complex_add</tt> may be described as
* suite named <tt>complex_add</tt> may be described as
* <tt>suite complex_add</tt>.
*/
virtual string toString () const = 0;
virtual std::string toString () const = 0;
};

40
headers/tools/cppunit/cppunit/TestAssert.h
View File

@ -20,7 +20,7 @@ namespace CppUnit {
* {
* return x == y;
* }
*
*
* static string toString( const string& x )
* {
* string text = '"' + x + '"'; // adds quote around the string to see whitespace
@ -32,14 +32,14 @@ namespace CppUnit {
* \endcode
*/
template <class T>
struct assertion_traits
{
struct assertion_traits
{
static bool equal( const T& x, const T& y )
{
return x == y;
}
static string toString( const T& x )
static std::string toString( const T& x )
{
OStringStream ost;
ost << x;
@ -51,37 +51,37 @@ namespace CppUnit {
namespace TestAssert
{
#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
void CPPUNIT_API assertImplementation( bool condition,
string conditionExpression = "",
void CPPUNIT_API assertImplementation( bool condition,
std::string conditionExpression = "",
long lineNumber,
string fileName );
std::string fileName );
void CPPUNIT_API assertNotEqualImplementation( string expected,
string actual,
void CPPUNIT_API assertNotEqualImplementation( std::string expected,
std::string actual,
long lineNumber,
string fileName );
std::string fileName );
template <class T>
void assertEquals( const T& expected,
const T& actual,
long lineNumber,
string fileName )
std::string fileName )
{
if ( !assertion_traits<T>::equal(expected,actual) ) // lazy toString conversion...
{
assertNotEqualImplementation( assertion_traits<T>::toString(expected),
assertion_traits<T>::toString(actual),
lineNumber,
lineNumber,
fileName );
}
}
void CPPUNIT_API assertEquals( double expected,
double actual,
double delta,
void CPPUNIT_API assertEquals( double expected,
double actual,
double delta,
long lineNumber,
string fileName );
std::string fileName );
#else // using SourceLine
@ -89,7 +89,7 @@ namespace CppUnit {
void assertEquals( const T& expected,
const T& actual,
SourceLine sourceLine,
const string &message ="" )
const std::string &message ="" )
{
if ( !assertion_traits<T>::equal(expected,actual) ) // lazy toString conversion...
{
@ -167,7 +167,7 @@ namespace CppUnit {
* Requirement for \a expected and \a actual parameters:
* - They are exactly of the same type
* - They are serializable into a strstream using operator <<.
* - They can be compared using operator ==.
* - They can be compared using operator ==.
*
* The last two requirements (serialization and comparison) can be
* removed by specializing the CppUnit::assertion_traits.
@ -190,7 +190,7 @@ namespace CppUnit {
* Requirement for \a expected and \a actual parameters:
* - They are exactly of the same type
* - They are serializable into a strstream using operator <<.
* - They can be compared using operator ==.
* - They can be compared using operator ==.
*
* The last two requirements (serialization and comparison) can be
* removed by specializing the CppUnit::assertion_traits.

68
headers/tools/cppunit/cppunit/TestCaller.h
View File

@ -33,18 +33,18 @@ struct ExpectedExceptionTraits
static void expectedException()
{
#if CPPUNIT_USE_TYPEINFO_NAME
string message( "Expected exception of type " );
std::string message( "Expected exception of type " );
message += TypeInfoHelper::getClassName( typeid( ExceptionType ) );
message += ", but got none";
#else
string message( "Expected exception but got none" );
std::string message( "Expected exception but got none" );
#endif
throw Exception( message );
}
};
/*! \brief (Implementation) Traits specialization used by TestCaller to
/*! \brief (Implementation) Traits specialization used by TestCaller to
* expect no exception.
*
* This class is an implementation detail. You should never use this class directly.
@ -65,13 +65,13 @@ struct ExpectedExceptionTraits<NoExceptionExpected>
/*! \brief Generate a test case from a fixture method.
* \ingroup WritingTestFixture
*
* A test caller provides access to a test case method
* on a test fixture class. Test callers are useful when
* you want to run an individual test or add it to a
* A test caller provides access to a test case method
* on a test fixture class. Test callers are useful when
* you want to run an individual test or add it to a
* suite.
* Test Callers invoke only one Test (i.e. test method) on one
* Test Callers invoke only one Test (i.e. test method) on one
* Fixture of a TestFixture.
*
*
* Here is an example:
* \code
* class MathTest : public CppUnit::TestFixture {
@ -94,16 +94,16 @@ struct ExpectedExceptionTraits<NoExceptionExpected>
*
* You can use a TestCaller to bind any test method on a TestFixture
* class, as long as it accepts void and returns void.
*
*
* \see TestCase
*/
template <typename Fixture,
template <typename Fixture,
typename ExpectedException = NoExceptionExpected>
class TestCaller : public TestCase
{
{
typedef void (Fixture::*TestMethod)();
public:
/*!
* Constructor for TestCaller. This constructor builds a new Fixture
@ -111,8 +111,8 @@ public:
* \param name name of this TestCaller
* \param test the method this TestCaller calls in runTest()
*/
TestCaller( string name, TestMethod test ) :
TestCase( name ),
TestCaller( std::string name, TestMethod test ) :
TestCase( name ),
m_ownFixture( true ),
m_fixture( new Fixture() ),
m_test( test )
@ -120,7 +120,7 @@ public:
}
/*!
* Constructor for TestCaller.
* Constructor for TestCaller.
* This constructor does not create a new Fixture instance but accepts
* an existing one as parameter. The TestCaller will not own the
* Fixture object.
@ -128,16 +128,16 @@ public:
* \param test the method this TestCaller calls in runTest()
* \param fixture the Fixture to invoke the test method on.
*/
TestCaller(string name, TestMethod test, Fixture& fixture) :
TestCase( name ),
TestCaller(std::string name, TestMethod test, Fixture& fixture) :
TestCase( name ),
m_ownFixture( false ),
m_fixture( &fixture ),
m_test( test )
{
}
/*!
* Constructor for TestCaller.
* Constructor for TestCaller.
* This constructor does not create a new Fixture instance but accepts
* an existing one as parameter. The TestCaller will own the
* Fixture object and delete it in its destructor.
@ -145,15 +145,15 @@ public:
* \param test the method this TestCaller calls in runTest()
* \param fixture the Fixture to invoke the test method on.
*/
TestCaller(string name, TestMethod test, Fixture* fixture) :
TestCase( name ),
TestCaller(std::string name, TestMethod test, Fixture* fixture) :
TestCase( name ),
m_ownFixture( true ),
m_fixture( fixture ),
m_test( test )
{
}
~TestCaller()
~TestCaller()
{
if (m_ownFixture)
delete m_fixture;
@ -161,7 +161,7 @@ public:
protected:
void runTest()
{
{
try {
(m_fixture->*m_test)();
}
@ -170,25 +170,25 @@ protected:
}
ExpectedExceptionTraits<ExpectedException>::expectedException();
}
}
void setUp()
{
m_fixture->setUp ();
{
m_fixture->setUp ();
}
void tearDown()
{
m_fixture->tearDown ();
{
m_fixture->tearDown ();
}
string toString() const
{
return "TestCaller " + getName();
std::string toString() const
{
return "TestCaller " + getName();
}
private:
TestCaller( const TestCaller &other );
private:
TestCaller( const TestCaller &other );
TestCaller &operator =( const TestCaller &other );
private:

22
headers/tools/cppunit/cppunit/TestCase.h
View File

@ -28,34 +28,34 @@ class CPPUNIT_API TestCase : public Test,
{
public:
TestCase( string Name );
TestCase( std::string Name );
//! \internal
TestCase();
~TestCase();
virtual void run(TestResult *result);
virtual int countTestCases() const;
string getName() const;
string toString() const;
std::string getName() const;
std::string toString() const;
//! FIXME: what is this for?
virtual TestResult *run();
protected:
//! FIXME: this should probably be pure virtual.
virtual void runTest();
//! Create TestResult for the run(void) method.
TestResult *defaultResult();
private:
TestCase( const TestCase &other );
TestCase &operator=( const TestCase &other );
TestCase( const TestCase &other );
TestCase &operator=( const TestCase &other );
private:
const string m_name;
const std::string m_name;
};
} // namespace CppUnit
#endif // CPPUNIT_TESTCASE_H
#endif // CPPUNIT_TESTCASE_H

14
headers/tools/cppunit/cppunit/TestFailure.h
View File

@ -20,7 +20,7 @@ class Test;
* TestFailure assumes lifetime control for any exception
* passed to it.
*/
class CPPUNIT_API TestFailure
class CPPUNIT_API TestFailure
{
public:
TestFailure( Test *failedTest,
@ -37,9 +37,9 @@ public:
virtual bool isError() const;
virtual string failedTestName() const;
virtual string toString() const;
virtual std::string failedTestName() const;
virtual std::string toString() const;
virtual TestFailure *clone() const;
@ -48,9 +48,9 @@ protected:
Exception *m_thrownException;
bool m_isError;
private:
TestFailure( const TestFailure &other );
TestFailure &operator =( const TestFailure& other );
private:
TestFailure( const TestFailure &other );
TestFailure &operator =( const TestFailure& other );
};

10
headers/tools/cppunit/cppunit/TestResult.h
View File

@ -35,9 +35,9 @@ class TestListener;
* TestResult supplies a template method 'setSynchronizationObject()'
* so that subclasses can provide mutual exclusion in the face of multiple
* threads. This can be useful when tests execute in one thread and
* they fill a subclass of TestResult which effects change in another
* they fill a subclass of TestResult which effects change in another
* thread. To have mutual exclusion, override setSynchronizationObject()
* and make sure that you create an instance of ExclusiveZone at the
* and make sure that you create an instance of ExclusiveZone at the
* beginning of each method.
*
* \see Test, TestListener, TestResultCollector, Outputter.
@ -63,13 +63,13 @@ public:
protected:
void addFailure( const TestFailure &failure );
protected:
typedef deque<TestListener *> TestListeners;
typedef std::deque<TestListener *> TestListeners;
TestListeners m_listeners;
bool m_stop;
private:
private:
TestResult( const TestResult &other );
TestResult &operator =( const TestResult &other );
};

8
headers/tools/cppunit/cppunit/TestResultCollector.h
View File

@ -25,8 +25,8 @@ namespace CppUnit
/*! \brief Collects test result.
* \ingroup WritingTestResult
* \ingroup BrowsingCollectedTestResult
*
* A TestResultCollector is a TestListener which collects the results of executing
*
* A TestResultCollector is a TestListener which collects the results of executing
* a test case. It is an instance of the Collecting Parameter pattern.
*
* The test framework distinguishes between failures and errors.
@ -38,8 +38,8 @@ namespace CppUnit
class CPPUNIT_API TestResultCollector : public TestSucessListener
{
public:
typedef deque<TestFailure *> TestFailures;
typedef deque<Test *> Tests;
typedef std::deque<TestFailure *> TestFailures;
typedef std::deque<Test *> Tests;
/*! Constructs a TestResultCollector object.

7
headers/tools/cppunit/cppunit/TestSuite.h
View File

@ -12,6 +12,9 @@
#include <vector>
#include <string>
using std::string;
using std::vector;
namespace CppUnit {
class TestResult;
@ -36,7 +39,7 @@ class TestResult;
* control for any tests added to them.
*
* TestSuites do not register themselves in the TestRegistry.
* \see Test
* \see Test
* \see TestCaller
*/
@ -59,7 +62,7 @@ public:
private:
TestSuite( const TestSuite &other );
TestSuite &operator =( const TestSuite &other );
TestSuite &operator =( const TestSuite &other );
private:
vector<Test *> m_tests;

4
headers/tools/cppunit/cppunit/TextOutputter.h
View File

@ -21,7 +21,7 @@ class CPPUNIT_API TextOutputter : public Outputter
{
public:
TextOutputter( TestResultCollector *result,
ostream &stream );
std::ostream &stream );
/// Destructor.
virtual ~TextOutputter();
@ -42,7 +42,7 @@ public:
protected:
TestResultCollector *m_result;
ostream &m_stream;
std::ostream &m_stream;
private:
/// Prevents the use of the copy constructor.

26
headers/tools/cppunit/cppunit/TextTestResult.h
View File

@ -13,7 +13,7 @@ class Test;
/*! \brief Holds printable test result (DEPRECATED).
* \ingroup TrackingTestExecution
*
*
* deprecated Use class TextTestProgressListener and TextOutputter instead.
*/
class CPPUNIT_API TextTestResult : public TestResult,
@ -25,29 +25,29 @@ public:
virtual void addFailure( Test *test, Exception *e );
virtual void addFailure( const TestFailure &failure );
virtual void startTest( Test *test );
virtual void print( ostream &stream );
virtual void printFailures( ostream &stream );
virtual void printHeader( ostream &stream );
virtual void print( std::ostream &stream );
virtual void printFailures( std::ostream &stream );
virtual void printHeader( std::ostream &stream );
virtual void printFailure( TestFailure *failure,
int failureNumber,
ostream &stream );
std::ostream &stream );
virtual void printFailureListMark( int failureNumber,
ostream &stream );
std::ostream &stream );
virtual void printFailureTestName( TestFailure *failure,
ostream &stream );
std::ostream &stream );
virtual void printFailureType( TestFailure *failure,
ostream &stream );
std::ostream &stream );
virtual void printFailureLocation( SourceLine sourceLine,
ostream &stream );
std::ostream &stream );
virtual void printFailureDetail( Exception *thrownException,
ostream &stream );
virtual void printFailureWarning( ostream &stream );
virtual void printStatistics( ostream &stream );
std::ostream &stream );
virtual void printFailureWarning( std::ostream &stream );
virtual void printStatistics( std::ostream &stream );
};
/** insertion operator for easy output */
ostream &operator <<( ostream &stream,
std::ostream &operator <<( std::ostream &stream,
TextTestResult &result );
} // namespace CppUnit

44
headers/tools/cppunit/cppunit/XmlOutputter.h
View File

@ -33,11 +33,11 @@ public:
/*! Constructs a XmlOutputter object.
* \param result Result of the test run.
* \param stream Stream used to output the XML output.
* \param encoding Encoding used in the XML file (default is Latin-1).
* \param encoding Encoding used in the XML file (default is Latin-1).
*/
XmlOutputter( TestResultCollector *result,
ostream &stream,
string encoding = "ISO-8859-1" );
std::ostream &stream,
std::string encoding = "ISO-8859-1" );
/// Destructor.
virtual ~XmlOutputter();
@ -56,33 +56,33 @@ public:
class CPPUNIT_API Node
{
public:
Node( string elementName,
string content ="" );
Node( string elementName,
Node( std::string elementName,
std::string content ="" );
Node( std::string elementName,
int numericContent );
virtual ~Node();
void addAttribute( string attributeName,
string value );
void addAttribute( string attributeName,
void addAttribute( std::string attributeName,
std::string value );
void addAttribute( std::string attributeName,
int numericValue );
void addNode( Node *node );
string toString() const;
std::string toString() const;
private:
typedef pair<string,string> Attribute;
typedef std::pair<std::string,std::string> Attribute;
string attributesAsString() const;
string escape( string value ) const;
static string asString( int value );
std::string attributesAsString() const;
std::string escape( std::string value ) const;
static std::string asString( int value );
private:
string m_name;
string m_content;
typedef deque<Attribute> Attributes;
std::string m_name;
std::string m_content;
typedef std::deque<Attribute> Attributes;
Attributes m_attributes;
typedef deque<Node *> Nodes;
typedef std::deque<Node *> Nodes;
Nodes m_nodes;
};
@ -90,7 +90,7 @@ public:
virtual void writeProlog();
virtual void writeTestsResult();
typedef map<Test *,TestFailure*> FailedTests;
typedef std::map<Test *,TestFailure*> FailedTests;
virtual Node *makeRootNode();
virtual void addFailedTests( FailedTests &failedTests,
Node *rootNode );
@ -103,7 +103,7 @@ public:
Node *testsNode );
virtual void addFailureLocation( TestFailure *failure,
Node *testNode );
virtual void addSucessfulTest( Test *test,
virtual void addSucessfulTest( Test *test,
int testNumber,
Node *testsNode );
protected:
@ -111,8 +111,8 @@ protected:
protected:
TestResultCollector *m_result;
ostream &m_stream;
string m_encoding;
std::ostream &m_stream;
std::string m_encoding;
private:
/// Prevents the use of the copy constructor.

10
headers/tools/cppunit/cppunit/extensions/RepeatedTest.h
View File

@ -14,17 +14,17 @@ class TestResult;
*
* Does not assume ownership of the test it decorates
*/
class CPPUNIT_API RepeatedTest : public TestDecorator
class CPPUNIT_API RepeatedTest : public TestDecorator
{
public:
RepeatedTest( Test *test,
int timesRepeat ) :
TestDecorator( test ),
RepeatedTest( Test *test,
int timesRepeat ) :
TestDecorator( test ),
m_timesRepeat(timesRepeat) {}
void run( TestResult *result );
int countTestCases() const;
string toString() const;
std::string toString() const;
private:
RepeatedTest( const RepeatedTest & );

12
headers/tools/cppunit/cppunit/extensions/TestDecorator.h
View File

@ -16,8 +16,8 @@ class TestResult;
* subclass the decorater and use it to wrap the test class.
*
* Does not assume ownership of the test it decorates
*/
class CPPUNIT_API TestDecorator : public Test
*/
class CPPUNIT_API TestDecorator : public Test
{
public:
TestDecorator (Test *test);
@ -25,8 +25,8 @@ public:
void run (TestResult *result);
int countTestCases () const;
string getName () const;
string toString () const;
std::string getName () const;
std::string toString () const;
protected:
Test *m_test;
@ -53,11 +53,11 @@ inline void TestDecorator::run (TestResult *result)
{ m_test->run (result); }
inline string TestDecorator::toString () const
inline std::string TestDecorator::toString () const
{ return m_test->toString (); }
inline string TestDecorator::getName () const
inline std::string TestDecorator::getName () const
{ return m_test->getName(); }
} // namespace CppUnit

20
headers/tools/cppunit/cppunit/extensions/TestFactoryRegistry.h
View File

@ -66,7 +66,7 @@ class TestSuite;
* CppUnit::TestSuite *suite = registry.makeTest();
* \endcode
*
* Since a TestFactoryRegistry is a TestFactory, the named registries can be
* Since a TestFactoryRegistry is a TestFactory, the named registries can be
* registered in the unnamed registry, creating the hierarchy links.
*
* \see TestSuiteFactory, AutoRegisterSuite
@ -79,19 +79,19 @@ public:
* \param name Name of the registry. It is the name of TestSuite returned by
* makeTest().
*/
TestFactoryRegistry( string name = "All Tests" );
TestFactoryRegistry( std::string name = "All Tests" );
/// Destructor.
virtual ~TestFactoryRegistry();
/** Returns a new TestSuite that contains the registered test.
* \return A new TestSuite which contains all the test added using
* \return A new TestSuite which contains all the test added using
* registerFactory(TestFactory *).
*/
virtual Test *makeTest();
/** Returns unnamed the registry.
* TestSuite registered using CPPUNIT_TEST_SUITE_REGISTRATION() are registered
* TestSuite registered using CPPUNIT_TEST_SUITE_REGISTRATION() are registered
* in this registry.
* \return Registry which name is "All Tests".
*/
@ -104,7 +104,7 @@ public:
* \return Registry. If the registry does not exist, it is created with the
* specified name.
*/
static TestFactoryRegistry &getRegistry( const string &name );
static TestFactoryRegistry &getRegistry( const std::string &name );
/** Adds the registered tests to the specified suite.
* \param suite Suite the tests are added to.
@ -113,15 +113,15 @@ public:
/** Adds the specified TestFactory with a specific name (DEPRECATED).
* \param name Name associated to the factory.
* \param factory Factory to register.
* \param factory Factory to register.
* \deprecated Use registerFactory( TestFactory *) instead.
*/
void registerFactory( const string &name,
void registerFactory( const std::string &name,
TestFactory *factory );
/** Adds the specified TestFactory to the registry.
*
* \param factory Factory to register.
* \param factory Factory to register.
*/
void registerFactory( TestFactory *factory );
@ -130,10 +130,10 @@ private:
void operator =( const TestFactoryRegistry &copy );
private:
typedef map<string, TestFactory *> Factories;
typedef std::map<std::string, TestFactory *> Factories;
Factories m_factories;
string m_name;
std::string m_name;
};

2
headers/tools/cppunit/cppunit/extensions/TypeInfoHelper.h
View File

@ -21,7 +21,7 @@ namespace CppUnit {
* the "class" prefix. If the name is not prefixed
* by "class", it is returned as this.
*/
static string getClassName( const type_info &info );
static std::string getClassName( const std::type_info &info );
};
} // namespace CppUnit

4
src/tools/cppunit/BTestCase.cpp
View File

@ -4,6 +4,8 @@
#include <stdio.h>
#include <stdarg.h>
using std::string;
_EXPORT
BTestCase::BTestCase(string name)
: CppUnit::TestCase(name)
@ -31,7 +33,7 @@ BTestCase::NextSubTest() {
_EXPORT
void
BTestCase::NextSubTestBlock() {
if (BTestShell::GlobalBeVerbose())
if (BTestShell::GlobalBeVerbose())
printf("\n");
}

31
src/tools/cppunit/BTestSuite.cpp
View File

@ -2,6 +2,9 @@
#include <cppunit/Test.h>
#include <cppunit/TestResult.h>
using std::map;
using std::string;
// Default constructor
_EXPORT
BTestSuite::BTestSuite( string name )
@ -11,14 +14,14 @@ BTestSuite::BTestSuite( string name )
// Destructor
_EXPORT
BTestSuite::~BTestSuite() {
deleteContents();
BTestSuite::~BTestSuite() {
deleteContents();
}
// Deletes all tests in the suite.
_EXPORT
void
void
BTestSuite::deleteContents() {
for ( map<string, CppUnit::Test*>::iterator it = fTests.begin();
it != fTests.end();
@ -30,7 +33,7 @@ BTestSuite::deleteContents() {
/// Runs the tests and collects their result in a TestResult.
_EXPORT
void
void
BTestSuite::run( CppUnit::TestResult *result ) {
for ( map<string, CppUnit::Test*>::iterator it = fTests.begin();
it != fTests.end();
@ -47,7 +50,7 @@ BTestSuite::run( CppUnit::TestResult *result ) {
// Counts the number of test cases that will be run by this test.
_EXPORT
int
int
BTestSuite::countTestCases() const {
int count = 0;
@ -60,27 +63,27 @@ BTestSuite::countTestCases() const {
}
// Adds a test to the suite.
// Adds a test to the suite.
_EXPORT
void
BTestSuite::addTest(string name, CppUnit::Test *test) {
fTests[name] = test;
void
BTestSuite::addTest(string name, CppUnit::Test *test) {
fTests[name] = test;
}
// Returns a string representation of the test suite.
_EXPORT
string
BTestSuite::toString() const {
string
BTestSuite::toString() const {
return "suite " + getName();
}
// Returns the name of the test suite.
_EXPORT
string
BTestSuite::getName() const {
return fName;
string
BTestSuite::getName() const {
return fName;
}

1
src/tools/cppunit/TestApp.cpp
View File

@ -1,6 +1,7 @@
// TestApp.cpp
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <Autolock.h>

7
src/tools/cppunit/TestListener.cpp
View File

@ -7,6 +7,9 @@
#include <stdio.h>
#include <OS.h>
using std::cout;
using std::endl;
_EXPORT
void
BTestListener::startTest( CppUnit::Test *test ) {
@ -25,7 +28,7 @@ BTestListener::addFailure( const CppUnit::TestFailure &failure ) {
cout << (failure.thrownException() != NULL
? failure.thrownException()->what()
: "(unknown error)");
cout << endl;
cout << endl;
}
_EXPORT
@ -38,7 +41,7 @@ BTestListener::endTest( CppUnit::Test *test ) {
// cout << " - FAILED" << endl;
printTime(length);
cout << endl;
}
}
_EXPORT
void

80
src/tools/cppunit/TestShell.cpp
View File

@ -26,6 +26,10 @@
# include <ElfSymbolPatcher.h>
#endif
using std::cout;
using std::endl;
using std::set;
_EXPORT BTestShell *BTestShell::fGlobalShell = NULL;
const char BTestShell::indent[] = " ";
@ -62,20 +66,20 @@ BTestShell::AddSuite(BTestSuite *suite) {
if (suite) {
if (Verbosity() >= v3)
cout << "Adding suite '" << suite->getName() << "'" << endl;
// Add the suite
fSuites[suite->getName()] = suite;
// Add its tests
const TestMap &map = suite->getTests();
for (TestMap::const_iterator i = map.begin();
i != map.end();
i++) {
AddTest(i->first, i->second);
if (Verbosity() >= v4 && i->second)
if (Verbosity() >= v4 && i->second)
cout << " " << i->first << endl;
}
return B_OK;
} else
return B_BAD_VALUE;
@ -121,7 +125,7 @@ BTestShell::LoadSuitesFrom(BDirectory *libDir) {
} else {
// cout << " !!! err == " << err << endl;
}
if (!err)
if (!err)
err = AddSuite(func());
if (!err)
count++;
@ -133,11 +137,11 @@ _EXPORT
int
BTestShell::Run(int argc, char *argv[]) {
// Make note of which directory we started in
UpdateTestDir(argv);
UpdateTestDir(argv);
// Parse the command line args
if (!ProcessArguments(argc, argv))
return 0;
return 0;
// Load any dynamically loadable tests we can find
LoadDynamicSuites();
@ -147,24 +151,24 @@ BTestShell::Run(int argc, char *argv[]) {
if (fListTestsAndExit) {
PrintInstalledTests();
return 0;
}
}
// Add the proper tests to our suite (or exit if there
// are no tests installed).
CppUnit::TestSuite suite;
CppUnit::TestSuite suite;
if (fTests.empty()) {
// No installed tests whatsoever, so bail
cout << "ERROR: No installed tests to run!" << endl;
return 0;
} else if (fSuitesToRun.empty() && fTestsToRun.empty()) {
// None specified, so run them all
TestMap::iterator i;
for (i = fTests.begin(); i != fTests.end(); ++i)
suite.addTest( i->second );
} else {
set<string>::const_iterator i;
set<string> suitesToRemove;
@ -187,14 +191,14 @@ BTestShell::Run(int argc, char *argv[]) {
}
}
}
// Remove the names of all of the suites we discovered from the
// list of tests to run (unless there's also an installed individual
// test of the same name).
for (i = suitesToRemove.begin(); i != suitesToRemove.end(); i++) {
fTestsToRun.erase(*i);
}
// Everything still in fTestsToRun must then be an explicit test
for (i = fTestsToRun.begin(); i != fTestsToRun.end(); ++i) {
// Make sure it's a valid test
@ -206,9 +210,9 @@ BTestShell::Run(int argc, char *argv[]) {
return 0;
}
}
}
// Run all the tests
InitOutput();
InstallPatches();
@ -223,7 +227,7 @@ _EXPORT
BTestShell::VerbosityLevel
BTestShell::Verbosity() const {
return fVerbosityLevel;
}
}
_EXPORT
const char*
@ -276,7 +280,7 @@ BTestShell::PrintHelp() {
cout << "VALID ARGUMENTS: " << endl;
PrintValidArguments();
cout << endl;
}
_EXPORT
@ -308,7 +312,7 @@ BTestShell::PrintInstalledTests() {
cout << "------------------------------------------------------------------------------" << endl;
cout << "Available Suites:" << endl;
cout << "------------------------------------------------------------------------------" << endl;
SuiteMap::const_iterator j;
SuiteMap::const_iterator j;
for (j = fSuites.begin(); j != fSuites.end(); ++j)
cout << j->first << endl;
cout << endl;
@ -317,7 +321,7 @@ BTestShell::PrintInstalledTests() {
cout << "------------------------------------------------------------------------------" << endl;
cout << "Available Tests:" << endl;
cout << "------------------------------------------------------------------------------" << endl;
TestMap::const_iterator i;
TestMap::const_iterator i;
for (i = fTests.begin(); i != fTests.end(); ++i)
cout << i->first << endl;
cout << endl;
@ -335,11 +339,11 @@ BTestShell::ProcessArguments(int argc, char *argv[]) {
// which is just the app name)
for (int i = 1; i < argc; i++) {
string str(argv[i]);
if (!ProcessArgument(str, argc, argv))
return false;
return false;
}
return true;
}
@ -363,12 +367,12 @@ BTestShell::ProcessArgument(string arg, int argc, char *argv[]) {
} else if (arg == "-v4") {
fVerbosityLevel = v4;
} else if (arg.length() >= 2 && arg[0] == '-' && arg[1] == 'l') {
fLibDirs.insert(arg.substr(2, arg.size()-2));
fLibDirs.insert(arg.substr(2, arg.size()-2));
} else {
fTestsToRun.insert(arg);
}
return true;
}
}
_EXPORT
void
@ -404,7 +408,7 @@ BTestShell::PrintResults() {
iFailure != fResultsCollector.failures().end();
++iFailure)
{
if (!(*iFailure)->isError())
if (!(*iFailure)->isError())
cout << " " << (*iFailure)->toString() << endl;
}
}
@ -414,17 +418,17 @@ BTestShell::PrintResults() {
iFailure != fResultsCollector.failures().end();
++iFailure)
{
if ((*iFailure)->isError())
if ((*iFailure)->isError())
cout << " " << (*iFailure)->toString() << endl;
}
}
}
else
cout << "+ PASSED" << endl;
cout << endl;
}
else {
// Print out concise results for verbosity level == 0
@ -433,7 +437,7 @@ BTestShell::PrintResults() {
else
cout << "+ PASSED" << endl;
}
}
_EXPORT
@ -448,15 +452,15 @@ BTestShell::LoadDynamicSuites() {
set<string>::iterator i;
for (i = fLibDirs.begin(); i != fLibDirs.end(); i++) {
BDirectory libDir((*i).c_str());
if (Verbosity() >= v3)
if (Verbosity() >= v3)
cout << "Checking " << *i << endl;
/* int count =*/ LoadSuitesFrom(&libDir);
if (Verbosity() >= v3) {
if (Verbosity() >= v3) {
// cout << "Loaded " << count << " suite" << (count == 1 ? "" : "s");
// cout << " from " << *i << endl;
}
}
if (Verbosity() >= v3)
cout << endl;
@ -466,11 +470,11 @@ BTestShell::LoadDynamicSuites() {
if (fTests.find(i->first) != fTests.end() && Verbosity() > v0) {
cout << "WARNING: '" << i->first << "' refers to both a test suite *and* an individual" <<
endl << " test. Both will be executed, but it is reccommended you rename" <<
endl << " one of them to resolve the conflict." <<
endl << " one of them to resolve the conflict." <<
endl << endl;
}
}
}
}
_EXPORT

80
src/tools/cppunit/TestUtils.cpp
View File

@ -3,8 +3,16 @@
#include <TestUtils.h>
#include <TestShell.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
using std::cout;
using std::dec;
using std::endl;
using std::hex;
using std::string;
_EXPORT
status_t DecodeResult(status_t result) {
if (!BTestShell::GlobalBeVerbose())
@ -20,134 +28,134 @@ status_t DecodeResult(status_t result) {
case B_ERROR:
str = "B_ERROR";
break;
// Storage Kit Errors
case B_FILE_ERROR:
str = "B_FILE_ERROR";
break;
case B_FILE_NOT_FOUND:
str = "B_FILE_NOT_FOUND";
break;
case B_FILE_EXISTS:
str = "B_FILE_EXISTS";
break;
case B_ENTRY_NOT_FOUND:
str = "B_ENTRY_NOT_FOUND";
break;
case B_NAME_TOO_LONG:
str = "B_NAME_TOO_LONG";
break;
case B_DIRECTORY_NOT_EMPTY:
str = "B_DIRECTORY_NOT_EMPTY";
break;
case B_DEVICE_FULL:
str = "B_DEVICE_FULL";
break;
case B_READ_ONLY_DEVICE:
str = "B_READ_ONLY_DEVICE";
break;
case B_IS_A_DIRECTORY:
str = "B_IS_A_DIRECTORY";
break;
case B_NO_MORE_FDS:
str = "B_NO_MORE_FDS";
break;
case B_CROSS_DEVICE_LINK:
str = "B_CROSS_DEVICE_LINK";
break;
case B_LINK_LIMIT:
str = "B_LINK_LIMIT";
break;
case B_BUSTED_PIPE:
str = "B_BUSTED_PIPE";
break;
case B_UNSUPPORTED:
str = "B_UNSUPPORTED";
break;
case B_PARTITION_TOO_SMALL:
str = "B_PARTITION_TOO_SMALL";
break;
case B_BAD_MIME_SNIFFER_RULE:
str = "B_BAD_MIME_SNIFFER_RULE";
break;
break;
// General Errors
case B_NO_MEMORY:
str = "B_NO_MEMORY";
break;
case B_IO_ERROR:
str = "B_IO_ERROR";
break;
case B_PERMISSION_DENIED:
str = "B_PERMISSION_DENIED";
break;
case B_BAD_INDEX:
str = "B_BAD_INDEX";
break;
case B_BAD_TYPE:
str = "B_BAD_TYPE";
break;
case B_BAD_VALUE:
str = "B_BAD_VALUE";
break;
case B_MISMATCHED_VALUES:
str = "B_MISMATCHED_VALUES";
break;
case B_NAME_NOT_FOUND:
str = "B_NAME_NOT_FOUND";
break;
case B_NAME_IN_USE:
str = "B_NAME_IN_USE";
break;
case B_TIMED_OUT:
str = "B_TIMED_OUT";
break;
case B_INTERRUPTED:
str = "B_INTERRUPTED";
break;
case B_WOULD_BLOCK:
str = "B_WOULD_BLOCK";
break;
case B_CANCELED:
str = "B_CANCELED";
break;
case B_NO_INIT:
str = "B_NO_INIT";
break;
case B_BUSY:
str = "B_BUSY";
break;
case B_NOT_ALLOWED:
str = "B_NOT_ALLOWED";
break;
@ -171,11 +179,11 @@ status_t DecodeResult(status_t result) {
default:
str = "??????????";
break;
}
cout << endl << "DecodeResult() -- " "0x" << hex << result << " (" << dec << result << ") == " << str << endl;
return result;
}

12
src/tools/cppunit/ThreadedTestCase.cpp
View File

@ -4,6 +4,10 @@
#include <stdio.h>
#include <stdarg.h>
using std::map;
using std::string;
using std::vector;
_EXPORT
BThreadedTestCase::BThreadedTestCase(string name, string progressSeparator)
: BTestCase(name)
@ -24,7 +28,7 @@ BThreadedTestCase::~BThreadedTestCase() {
i++)
{
delete i->second;
}
}
}
_EXPORT
@ -47,9 +51,9 @@ BThreadedTestCase::NextSubTest() {
return;
}
}
// Handle single-threaded case
BTestCase::NextSubTest();
BTestCase::NextSubTest();
}
_EXPORT
@ -62,7 +66,7 @@ BThreadedTestCase::Outputf(const char *str, ...) {
{
BAutolock lock(fUpdateLock);
isSingleThreaded = fNumberMap.find(id) == fNumberMap.end();
}
}
if (isSingleThreaded) {
va_list args;
va_start(args, str);

30
src/tools/cppunit/cppunit/Asserter.cpp
View File

@ -2,6 +2,8 @@
#include <cppunit/NotEqualException.h>
using std::string;
namespace CppUnit
{
@ -10,17 +12,17 @@ namespace Asserter
{
void
fail( string message,
void
fail( string message,
SourceLine sourceLine )
{
throw Exception( message, sourceLine );
}
void
failIf( bool shouldFail,
string message,
void
failIf( bool shouldFail,
string message,
SourceLine location )
{
if ( shouldFail )
@ -28,23 +30,23 @@ failIf( bool shouldFail,
}
void
failNotEqual( string expected,
string actual,
void
failNotEqual( string expected,
string actual,
SourceLine sourceLine,
string additionalMessage )
{
throw NotEqualException( expected,
actual,
sourceLine,
throw NotEqualException( expected,
actual,
sourceLine,
additionalMessage );
}
void
void
failNotEqualIf( bool shouldFail,
string expected,
string actual,
string expected,
string actual,
SourceLine sourceLine,
string additionalMessage )
{

40
src/tools/cppunit/cppunit/CompilerOutputter.cpp
View File

@ -6,6 +6,10 @@
#include <cppunit/CompilerOutputter.h>
using std::endl;
using std::ostream;
using std::string;
namespace CppUnit
{
@ -32,7 +36,7 @@ CompilerOutputter::defaultOutputter( TestResultCollector *result,
}
void
void
CompilerOutputter::write()
{
if ( m_result->wasSuccessful() )
@ -42,15 +46,15 @@ CompilerOutputter::write()
}
void
void
CompilerOutputter::printSucess()
{
m_stream << "OK (" << m_result->runTests() << ")"
m_stream << "OK (" << m_result->runTests() << ")"
<< endl;
}
void
void
CompilerOutputter::printFailureReport()
{
printFailuresList();
@ -58,7 +62,7 @@ CompilerOutputter::printFailureReport()
}
void
void
CompilerOutputter::printFailuresList()
{
for ( int index =0; index < m_result->testFailuresTotal(); ++index)
@ -68,7 +72,7 @@ CompilerOutputter::printFailuresList()
}
void
void
CompilerOutputter::printFailureDetail( TestFailure *failure )
{
printFailureLocation( failure->sourceLine() );
@ -77,26 +81,26 @@ CompilerOutputter::printFailureDetail( TestFailure *failure )
printFailureMessage( failure );
}
void
void
CompilerOutputter::printFailureLocation( SourceLine sourceLine )
{
if ( sourceLine.isValid() )
m_stream << sourceLine.fileName()
m_stream << sourceLine.fileName()
<< "(" << sourceLine.lineNumber() << ") : ";
else
m_stream << "##Failure Location unknown## : ";
}
void
void
CompilerOutputter::printFailureType( TestFailure *failure )
{
m_stream << (failure->isError() ? "Error" : "Assertion");
}
void
void
CompilerOutputter::printFailedTestName( TestFailure *failure )
{
m_stream << endl;
@ -104,7 +108,7 @@ CompilerOutputter::printFailedTestName( TestFailure *failure )
}
void
void
CompilerOutputter::printFailureMessage( TestFailure *failure )
{
m_stream << endl;
@ -117,7 +121,7 @@ CompilerOutputter::printFailureMessage( TestFailure *failure )
}
void
void
CompilerOutputter::printNotEqualMessage( Exception *thrownException )
{
NotEqualException *e = (NotEqualException *)thrownException;
@ -133,7 +137,7 @@ CompilerOutputter::printNotEqualMessage( Exception *thrownException )
}
void
void
CompilerOutputter::printDefaultMessage( Exception *thrownException )
{
string wrappedMessage = wrap( thrownException->what() );
@ -141,7 +145,7 @@ CompilerOutputter::printDefaultMessage( Exception *thrownException )
}
void
void
CompilerOutputter::printStatistics()
{
m_stream << "Failures !!!" << endl;
@ -177,7 +181,7 @@ CompilerOutputter::wrap( string message )
}
CompilerOutputter::Lines
CompilerOutputter::Lines
CompilerOutputter::splitMessageIntoLines( string message )
{
Lines lines;
@ -185,8 +189,8 @@ CompilerOutputter::splitMessageIntoLines( string message )
string::iterator itStart = message.begin();
while ( true )
{
string::iterator itEol = find( itStart,
message.end(),
string::iterator itEol = find( itStart,
message.end(),
'\n' );
lines.push_back( message.substr( itStart - message.begin(),
itEol - itStart ) );

54
src/tools/cppunit/cppunit/Exception.cpp
View File

@ -18,20 +18,20 @@ const long Exception::UNKNOWNLINENUMBER = -1;
/// Construct the exception
Exception::Exception( const Exception &other ) :
Exception::Exception( const Exception &other ) :
exception( other )
{
m_message = other.m_message;
{
m_message = other.m_message;
m_sourceLine = other.m_sourceLine;
}
}
/*!
* \deprecated Use other constructor instead.
*/
Exception::Exception( string message,
SourceLine sourceLine ) :
m_message( message ),
Exception::Exception( std::string message,
SourceLine sourceLine ) :
m_message( message ),
m_sourceLine( sourceLine )
{
}
@ -41,10 +41,10 @@ Exception::Exception( string message,
/*!
* \deprecated Use other constructor instead.
*/
Exception::Exception( string message,
long lineNumber,
string fileName ) :
m_message( message ),
Exception::Exception( std::string message,
long lineNumber,
std::string fileName ) :
m_message( message ),
m_sourceLine( fileName, lineNumber )
{
}
@ -58,33 +58,33 @@ Exception::~Exception () throw()
/// Perform an assignment
Exception&
Exception&
Exception::operator =( const Exception& other )
{
{
// Don't call superclass operator =(). VC++ STL implementation
// has a bug. It calls the destructor and copy constructor of
// has a bug. It calls the destructor and copy constructor of
// exception() which reset the virtual table to exception.
// SuperClass::operator =(other);
if ( &other != this )
{
m_message = other.m_message;
m_message = other.m_message;
m_sourceLine = other.m_sourceLine;
}
return *this;
return *this;
}
/// Return descriptive message
const char*
Exception::what() const throw()
{
return m_message.c_str ();
{
return m_message.c_str ();
}
/// Location where the error occured
SourceLine
SourceLine
Exception::sourceLine() const
{
return m_sourceLine;
@ -93,19 +93,19 @@ Exception::sourceLine() const
#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
/// The line on which the error occurred
long
long
Exception::lineNumber() const
{
return m_sourceLine.isValid() ? m_sourceLine.lineNumber() :
UNKNOWNLINENUMBER;
{
return m_sourceLine.isValid() ? m_sourceLine.lineNumber() :
UNKNOWNLINENUMBER;
}
/// The file in which the error occurred
string
string
Exception::fileName() const
{
return m_sourceLine.isValid() ? m_sourceLine.fileName() :
{
return m_sourceLine.isValid() ? m_sourceLine.fileName() :
UNKNOWNFILENAME;
}
#endif
@ -118,7 +118,7 @@ Exception::clone() const
}
bool
bool
Exception::isInstanceOf( const Type &exceptionType ) const
{
return exceptionType == type();

22
src/tools/cppunit/cppunit/NotEqualException.cpp
View File

@ -3,12 +3,14 @@
namespace CppUnit {
using std::string;
NotEqualException::NotEqualException( string expected,
string actual,
string actual,
SourceLine sourceLine ,
string additionalMessage ) :
Exception( "Expected: " + expected +
", but was: " + actual +
Exception( "Expected: " + expected +
", but was: " + actual +
"." + additionalMessage ,
sourceLine),
m_expected( expected ),
@ -24,8 +26,8 @@ NotEqualException::NotEqualException( string expected,
*/
NotEqualException::NotEqualException( string expected,
string actual,
long lineNumber,
string fileName ) :
long lineNumber,
string fileName ) :
Exception( "Expected: " + expected + ", but was: " + actual,
lineNumber,
fileName ),
@ -36,7 +38,7 @@ NotEqualException::NotEqualException( string expected,
#endif
NotEqualException::NotEqualException( const NotEqualException &other ) :
NotEqualException::NotEqualException( const NotEqualException &other ) :
Exception( other ),
m_expected( other.m_expected ),
m_actual( other.m_actual ),
@ -72,7 +74,7 @@ NotEqualException::clone() const
}
bool
bool
NotEqualException::isInstanceOf( const Type &exceptionType ) const
{
return exceptionType == type() ||
@ -87,21 +89,21 @@ NotEqualException::type()
}
string
string
NotEqualException::expectedValue() const
{
return m_expected;
}
string
string
NotEqualException::actualValue() const
{
return m_actual;
}
string
string
NotEqualException::additionalMessage() const
{
return m_additionalMessage;

17
src/tools/cppunit/cppunit/RepeatedTest.cpp
View File

@ -4,27 +4,28 @@
namespace CppUnit {
using std::string;
// Counts the number of test cases that will be run by this test.
int
RepeatedTest::countTestCases() const
{
return TestDecorator::countTestCases () * m_timesRepeat;
{
return TestDecorator::countTestCases () * m_timesRepeat;
}
// Returns the name of the test instance.
string
// Returns the name of the test instance.
string
RepeatedTest::toString() const
{
return TestDecorator::toString () + " (repeated)";
{
return TestDecorator::toString () + " (repeated)";
}
// Runs a repeated test
void
void
RepeatedTest::run( TestResult *result )
{
for ( int n = 0; n < m_timesRepeat; n++ )
for ( int n = 0; n < m_timesRepeat; n++ )
{
if ( result->shouldStop() )
break;

12
src/tools/cppunit/cppunit/SourceLine.cpp
View File

@ -1,6 +1,8 @@
#include <cppunit/SourceLine.h>
using std::string;
namespace CppUnit
{
@ -23,28 +25,28 @@ SourceLine::~SourceLine()
}
bool
bool
SourceLine::isValid() const
{
return !m_fileName.empty();
}
int
int
SourceLine::lineNumber() const
{
return m_lineNumber;
}
string
string
SourceLine::fileName() const
{
return m_fileName;
}
bool
bool
SourceLine::operator ==( const SourceLine &other ) const
{
return m_fileName == other.m_fileName &&
@ -52,7 +54,7 @@ SourceLine::operator ==( const SourceLine &other ) const
}
bool
bool
SourceLine::operator !=( const SourceLine &other ) const
{
return !( *this == other );

45
src/tools/cppunit/cppunit/TestCase.cpp
View File

@ -7,18 +7,21 @@
#include "cppunit/TestResult.h"
using std::exception;
using std::string;
namespace CppUnit {
/// Create a default TestResult
CppUnit::TestResult*
CppUnit::TestResult*
TestCase::defaultResult()
{
return new TestResult;
}
{
return new TestResult;
}
/// Run the test and catch any exceptions that are triggered by it
void
/// Run the test and catch any exceptions that are triggered by it
void
TestCase::run( TestResult *result )
{
result->startTest(this);
@ -51,12 +54,12 @@ TestCase::run( TestResult *result )
catch (...) {
result->addError( this, new Exception( "setUp() failed" ) );
}
result->endTest( this );
}
/// A default run method
/// A default run method
TestResult *
TestCase::run()
{
@ -67,8 +70,8 @@ TestCase::run()
}
/// All the work for runTest is deferred to subclasses
void
/// All the work for runTest is deferred to subclasses
void
TestCase::runTest()
{
}
@ -100,36 +103,36 @@ TestCase::~TestCase()
/// Returns a count of all the tests executed
int
int
TestCase::countTestCases() const
{
return 1;
{
return 1;
}
/// Returns the name of the test case
string
string
TestCase::getName() const
{
return m_name;
{
return m_name;
}
/// Returns the name of the test case instance
string
string
TestCase::toString() const
{
{
string className;
#if CPPUNIT_USE_TYPEINFO_NAME
const type_info& thisClass = typeid( *this );
const std::type_info& thisClass = typeid( *this );
className = thisClass.name();
#else
className = "TestCase";
#endif
return className + "." + getName();
return className + "." + getName();
}
} // namespace CppUnit

28
src/tools/cppunit/cppunit/TestFactoryRegistry.cpp
View File

@ -9,12 +9,16 @@
#endif
using std::map;
using std::set;
using std::string;
namespace CppUnit {
/** (Implementation) This class manages all the TestFactoryRegistry.
*
* Responsible for the life-cycle of the TestFactoryRegistry.
*
*
* TestFactory registry must call wasDestroyed() to indicate that
* a given TestRegistry was destroyed, and needDestroy() to
* know if a given TestFactory need to be destroyed (was not already
@ -71,13 +75,13 @@ NamedRegistries::getRegistry( string name )
{
TestFactoryRegistry *factory = new TestFactoryRegistry( name );
#if defined(__POWERPC__) && (defined(__BEOS__) || defined(__HAIKU__))
m_registries.insert(
m_registries.insert(
pair<
const basic_string< char, char_traits< char>, allocator<char> >,
const basic_string< char, char_traits< char>, allocator<char> >,
CppUnit::TestFactoryRegistry*
>(
name, factory
)
name, factory
)
);
#else
m_registries.insert( std::make_pair( name, factory ) );
@ -89,7 +93,7 @@ NamedRegistries::getRegistry( string name )
}
void
void
NamedRegistries::wasDestroyed( TestFactory *factory )
{
m_factoriesToDestroy.erase( factory );
@ -97,7 +101,7 @@ NamedRegistries::wasDestroyed( TestFactory *factory )
}
bool
bool
NamedRegistries::needDestroy( TestFactory *factory )
{
return m_destroyedFactories.count( factory ) == 0;
@ -143,7 +147,7 @@ TestFactoryRegistry::getRegistry( const string &name )
}
void
void
TestFactoryRegistry::registerFactory( const string &name,
TestFactory *factory )
{
@ -151,7 +155,7 @@ TestFactoryRegistry::registerFactory( const string &name,
}
void
void
TestFactoryRegistry::registerFactory( TestFactory *factory )
{
static int serialNumber = 1;
@ -172,11 +176,11 @@ TestFactoryRegistry::makeTest()
}
void
void
TestFactoryRegistry::addTestToSuite( TestSuite *suite )
{
for ( Factories::iterator it = m_factories.begin();
it != m_factories.end();
for ( Factories::iterator it = m_factories.begin();
it != m_factories.end();
++it )
{
TestFactory *factory = (*it).second;

30
src/tools/cppunit/cppunit/TestFailure.cpp
View File

@ -2,13 +2,15 @@
#include "cppunit/Test.h"
#include "cppunit/TestFailure.h"
using std::string;
namespace CppUnit {
/// Constructs a TestFailure with the given test and exception.
TestFailure::TestFailure( Test *failedTest,
TestFailure::TestFailure( Test *failedTest,
Exception *thrownException,
bool isError ) :
m_failedTest( failedTest ),
m_failedTest( failedTest ),
m_thrownException( thrownException ),
m_isError( isError )
{
@ -16,28 +18,28 @@ TestFailure::TestFailure( Test *failedTest,
/// Deletes the owned exception.
TestFailure::~TestFailure()
{
delete m_thrownException;
{
delete m_thrownException;
}
/// Gets the failed test.
Test *
TestFailure::failedTest() const
{
return m_failedTest;
{
return m_failedTest;
}
/// Gets the thrown exception. Never \c NULL.
Exception *
TestFailure::thrownException() const
{
return m_thrownException;
{
return m_thrownException;
}
/// Gets the failure location.
SourceLine
SourceLine
TestFailure::sourceLine() const
{
return m_thrownException->sourceLine();
@ -45,7 +47,7 @@ TestFailure::sourceLine() const
/// Indicates if the failure is a failed assertion or an error.
bool
bool
TestFailure::isError() const
{
return m_isError;
@ -53,7 +55,7 @@ TestFailure::isError() const
/// Gets the name of the failed test.
string
string
TestFailure::failedTestName() const
{
return m_failedTest->getName();
@ -61,9 +63,9 @@ TestFailure::failedTestName() const
/// Returns a short description of the failure.
string
TestFailure::toString() const
{
string
TestFailure::toString() const
{
return m_failedTest->toString() + ": " + m_thrownException->what();
}

23
src/tools/cppunit/cppunit/TestRunner.cpp
View File

@ -6,6 +6,9 @@
#include <cppunit/ui/text/TestRunner.h>
#include <iostream>
using std::cin;
using std::cout;
using std::endl;
namespace CppUnit {
namespace TextUi {
@ -13,7 +16,7 @@ namespace TextUi {
/*! Constructs a new text runner.
* \param outputter used to print text result. Owned by the runner.
*/
TestRunner::TestRunner( Outputter *outputter )
TestRunner::TestRunner( Outputter *outputter )
: m_suite( new TestSuite( "All Tests" ) )
, m_result( new TestResultCollector() )
, m_eventManager( new TestResult() )
@ -38,7 +41,7 @@ TestRunner::~TestRunner()
*
* \param test Test to add.
*/
void
void
TestRunner::addTest( Test *test )
{
if ( test != NULL )
@ -51,7 +54,7 @@ TestRunner::addTest( Test *test )
* \param testName Name of the test case to run. If an empty is given, then
* all added test are run. The name must be the name of
* of an added test.
* \param doWait if \c true then the user must press the RETURN key
* \param doWait if \c true then the user must press the RETURN key
* before the run() method exit.
* \param doPrintResult if \c true (default) then the test result are printed
* on the standard output.
@ -89,10 +92,10 @@ TestRunner::runTestByName( string testName,
}
void
void
TestRunner::wait( bool doWait )
{
if ( doWait )
if ( doWait )
{
cout << "<RETURN> to continue" << endl;
cin.get ();
@ -100,7 +103,7 @@ TestRunner::wait( bool doWait )
}
void
void
TestRunner::printResult( bool doPrintResult )
{
cout << endl;
@ -109,11 +112,11 @@ TestRunner::printResult( bool doPrintResult )
}
Test *
Test *
TestRunner::findTestByName( string name ) const
{
for ( vector<Test *>::const_iterator it = m_suite->getTests().begin();
it != m_suite->getTests().end();
for ( vector<Test *>::const_iterator it = m_suite->getTests().begin();
it != m_suite->getTests().end();
++it )
{
Test *test = *it;
@ -167,7 +170,7 @@ TestRunner::eventManager() const
* \c true.
* \see CompilerOutputter, XmlOutputter, TextOutputter.
*/
void
void
TestRunner::setOutputter( Outputter *outputter )
{
delete m_outputter;

31
src/tools/cppunit/cppunit/TextOutputter.cpp
View File

@ -5,6 +5,9 @@
#include <cppunit/TextOutputter.h>
using std::endl;
using std::ostream;
namespace CppUnit
{
@ -22,8 +25,8 @@ TextOutputter::~TextOutputter()
}
void
TextOutputter::write()
void
TextOutputter::write()
{
printHeader();
m_stream << endl;
@ -32,12 +35,12 @@ TextOutputter::write()
}
void
void
TextOutputter::printFailures()
{
TestResultCollector::TestFailures::const_iterator itFailure = m_result->failures().begin();
int failureNumber = 1;
while ( itFailure != m_result->failures().end() )
while ( itFailure != m_result->failures().end() )
{
m_stream << endl;
printFailure( *itFailure++, failureNumber++ );
@ -45,7 +48,7 @@ TextOutputter::printFailures()
}
void
void
TextOutputter::printFailure( TestFailure *failure,
int failureNumber )
{
@ -62,21 +65,21 @@ TextOutputter::printFailure( TestFailure *failure,
}
void
void
TextOutputter::printFailureListMark( int failureNumber )
{
m_stream << failureNumber << ")";
}
void
void
TextOutputter::printFailureTestName( TestFailure *failure )
{
m_stream << "test: " << failure->failedTestName();
}
void
void
TextOutputter::printFailureType( TestFailure *failure )
{
m_stream << "("
@ -85,7 +88,7 @@ TextOutputter::printFailureType( TestFailure *failure )
}
void
void
TextOutputter::printFailureLocation( SourceLine sourceLine )
{
if ( !sourceLine.isValid() )
@ -96,7 +99,7 @@ TextOutputter::printFailureLocation( SourceLine sourceLine )
}
void
void
TextOutputter::printFailureDetail( Exception *thrownException )
{
if ( thrownException->isInstanceOf( NotEqualException::type() ) )
@ -118,11 +121,11 @@ TextOutputter::printFailureDetail( Exception *thrownException )
}
void
void
TextOutputter::printHeader()
{
if ( m_result->wasSuccessful() )
m_stream << endl << "OK (" << m_result->runTests () << " tests)"
m_stream << endl << "OK (" << m_result->runTests () << " tests)"
<< endl;
else
{
@ -133,14 +136,14 @@ TextOutputter::printHeader()
}
void
void
TextOutputter::printFailureWarning()
{
m_stream << "!!!FAILURES!!!" << endl;
}
void
void
TextOutputter::printStatistics()
{
m_stream << "Test Results:" << endl;

9
src/tools/cppunit/cppunit/TextTestProgressListener.cpp
View File

@ -3,6 +3,9 @@
#include <iostream>
using std::cerr;
using std::endl;
namespace CppUnit
{
@ -17,7 +20,7 @@ TextTestProgressListener::~TextTestProgressListener()
}
void
void
TextTestProgressListener::startTest( Test *test )
{
cerr << ".";
@ -25,7 +28,7 @@ TextTestProgressListener::startTest( Test *test )
}
void
void
TextTestProgressListener::addFailure( const TestFailure &failure )
{
cerr << ( failure.isError() ? "E" : "F" );
@ -33,7 +36,7 @@ TextTestProgressListener::addFailure( const TestFailure &failure )
}
void
void
TextTestProgressListener::done()
{
cerr << endl;

44
src/tools/cppunit/cppunit/TextTestResult.cpp
View File

@ -6,6 +6,10 @@
#include <iostream>
using std::cerr;
using std::endl;
using std::ostream;
namespace CppUnit {
@ -15,14 +19,14 @@ TextTestResult::TextTestResult()
}
void
void
TextTestResult::addFailure( Test *test, Exception *e )
{
TestResult::addFailure( test, e );
}
void
void
TextTestResult::addFailure( const TestFailure &failure )
{
TestResultCollector::addFailure( failure );
@ -30,7 +34,7 @@ TextTestResult::addFailure( const TestFailure &failure )
}
void
void
TextTestResult::startTest( Test *test )
{
TestResultCollector::startTest (test);
@ -38,12 +42,12 @@ TextTestResult::startTest( Test *test )
}
void
void
TextTestResult::printFailures( ostream &stream )
{
TestFailures::const_iterator itFailure = failures().begin();
int failureNumber = 1;
while ( itFailure != failures().end() )
while ( itFailure != failures().end() )
{
stream << endl;
printFailure( *itFailure++, failureNumber++, stream );
@ -51,7 +55,7 @@ TextTestResult::printFailures( ostream &stream )
}
void
void
TextTestResult::printFailure( TestFailure *failure,
int failureNumber,
ostream &stream )
@ -69,7 +73,7 @@ TextTestResult::printFailure( TestFailure *failure,
}
void
void
TextTestResult::printFailureListMark( int failureNumber,
ostream &stream )
{
@ -77,7 +81,7 @@ TextTestResult::printFailureListMark( int failureNumber,
}
void
void
TextTestResult::printFailureTestName( TestFailure *failure,
ostream &stream )
{
@ -85,7 +89,7 @@ TextTestResult::printFailureTestName( TestFailure *failure,
}
void
void
TextTestResult::printFailureType( TestFailure *failure,
ostream &stream )
{
@ -95,7 +99,7 @@ TextTestResult::printFailureType( TestFailure *failure,
}
void
void
TextTestResult::printFailureLocation( SourceLine sourceLine,
ostream &stream )
{
@ -107,7 +111,7 @@ TextTestResult::printFailureLocation( SourceLine sourceLine,
}
void
void
TextTestResult::printFailureDetail( Exception *thrownException,
ostream &stream )
{
@ -130,8 +134,8 @@ TextTestResult::printFailureDetail( Exception *thrownException,
}
void
TextTestResult::print( ostream& stream )
void
TextTestResult::print( ostream& stream )
{
printHeader( stream );
stream << endl;
@ -139,11 +143,11 @@ TextTestResult::print( ostream& stream )
}
void
void
TextTestResult::printHeader( ostream &stream )
{
if (wasSuccessful ())
stream << endl << "OK (" << runTests () << " tests)"
stream << endl << "OK (" << runTests () << " tests)"
<< endl;
else
{
@ -154,14 +158,14 @@ TextTestResult::printHeader( ostream &stream )
}
void
void
TextTestResult::printFailureWarning( ostream &stream )
{
stream << "!!!FAILURES!!!" << endl;
}
void
void
TextTestResult::printStatistics( ostream &stream )
{
stream << "Test Results:" << endl;
@ -174,10 +178,10 @@ TextTestResult::printStatistics( ostream &stream )
ostream &
operator <<( ostream &stream,
operator <<( ostream &stream,
TextTestResult &result )
{
result.print (stream); return stream;
{
result.print (stream); return stream;
}

9
src/tools/cppunit/cppunit/TypeInfoHelper.cpp
View File

@ -6,9 +6,12 @@
#include <cppunit/extensions/TypeInfoHelper.h>
using std::string;
using std::type_info;
namespace CppUnit {
string
string
TypeInfoHelper::getClassName( const type_info &info )
{
static const string classPrefix( "class " );
@ -18,7 +21,7 @@ TypeInfoHelper::getClassName( const type_info &info )
#if CPPUNIT_FUNC_STRING_COMPARE_STRING_FIRST
name.compare( classPrefix, 0, classPrefix.length() );
#else
name.compare( 0, classPrefix.length(), classPrefix );
name.compare( 0, classPrefix.length(), classPrefix );
#endif
return has_class_prefix ? name.substr( classPrefix.length() ) : name;
@ -27,4 +30,4 @@ TypeInfoHelper::getClassName( const type_info &info )
} // namespace CppUnit
#endif
#endif

58
src/tools/cppunit/cppunit/XmlOutputter.cpp
View File

@ -7,6 +7,12 @@
#include <stdlib.h>
using std::endl;
using std::ostream;
using std::pair;
using std::string;
namespace CppUnit
{
@ -21,7 +27,7 @@ XmlOutputter::Node::Node( string elementName,
{
}
XmlOutputter::Node::Node( string elementName,
int numericContent ) :
m_name( elementName )
@ -38,7 +44,7 @@ XmlOutputter::Node::~Node()
}
void
void
XmlOutputter::Node::addAttribute( string attributeName,
string value )
{
@ -46,7 +52,7 @@ XmlOutputter::Node::addAttribute( string attributeName,
}
void
void
XmlOutputter::Node::addAttribute( string attributeName,
int numericValue )
{
@ -54,14 +60,14 @@ XmlOutputter::Node::addAttribute( string attributeName,
}
void
void
XmlOutputter::Node::addNode( Node *node )
{
m_nodes.push_back( node );
}
string
string
XmlOutputter::Node::toString() const
{
string element = "<";
@ -87,7 +93,7 @@ XmlOutputter::Node::toString() const
}
string
string
XmlOutputter::Node::attributesAsString() const
{
string attributes;
@ -104,7 +110,7 @@ XmlOutputter::Node::attributesAsString() const
}
string
string
XmlOutputter::Node::escape( string value ) const
{
string escaped;
@ -113,31 +119,31 @@ XmlOutputter::Node::escape( string value ) const
char c = value[index ];
switch ( c ) // escape all predefined XML entity (safe?)
{
case '<':
case '<':
escaped += "&lt;";
break;
case '>':
case '>':
escaped += "&gt;";
break;
case '&':
case '&':
escaped += "&amp;";
break;
case '\'':
case '\'':
escaped += "&apos;";
break;
case '"':
case '"':
escaped += "&quot;";
break;
default:
escaped += c;
}
}
return escaped;
}
// should be somewhere else... Future CppUnit::String ?
string
// should be somewhere else... Future CppUnit::String ?
string
XmlOutputter::Node::asString( int value )
{
OStringStream stream;
@ -166,7 +172,7 @@ XmlOutputter::~XmlOutputter()
}
void
void
XmlOutputter::write()
{
writeProlog();
@ -174,7 +180,7 @@ XmlOutputter::write()
}
void
void
XmlOutputter::writeProlog()
{
m_stream << "<?xml version=\"1.0\" "
@ -183,7 +189,7 @@ XmlOutputter::writeProlog()
}
void
void
XmlOutputter::writeTestsResult()
{
Node *rootNode = makeRootNode();
@ -208,7 +214,7 @@ XmlOutputter::makeRootNode()
}
void
void
XmlOutputter::fillFailedTestsMap( FailedTests &failedTests )
{
const TestResultCollector::TestFailures &failures = m_result->failures();
@ -216,11 +222,11 @@ XmlOutputter::fillFailedTestsMap( FailedTests &failedTests )
while ( itFailure != failures.end() )
{
TestFailure *failure = *itFailure++;
failedTests.insert(
failedTests.insert(
pair< CppUnit::Test* const, CppUnit::TestFailure*
>(
failure->failedTest(), failure
)
failure->failedTest(), failure
)
);
}
}
@ -266,7 +272,7 @@ XmlOutputter::addStatistics( Node *rootNode )
Node *statisticsNode = new Node( "Statistics" );
rootNode->addNode( statisticsNode );
statisticsNode->addNode( new Node( "Tests", m_result->runTests() ) );
statisticsNode->addNode( new Node( "FailuresTotal",
statisticsNode->addNode( new Node( "FailuresTotal",
m_result->testFailuresTotal() ) );
statisticsNode->addNode( new Node( "Errors", m_result->testErrors() ) );
statisticsNode->addNode( new Node( "Failures", m_result->testFailures() ) );
@ -280,12 +286,12 @@ XmlOutputter::addFailedTest( Test *test,
Node *testsNode )
{
Exception *thrownException = failure->thrownException();
Node *testNode = new Node( "FailedTest", thrownException->what() );
testsNode->addNode( testNode );
testNode->addAttribute( "id", testNumber );
testNode->addNode( new Node( "Name", test->getName() ) );
testNode->addNode( new Node( "FailureType",
testNode->addNode( new Node( "FailureType",
failure->isError() ? "Error" : "Assertion" ) );
if ( failure->sourceLine().isValid() )
@ -306,7 +312,7 @@ XmlOutputter::addFailureLocation( TestFailure *failure,
void
XmlOutputter::addSucessfulTest( Test *test,
XmlOutputter::addSucessfulTest( Test *test,
int testNumber,
Node *testsNode )
{