2004-03-03 22:56:16 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Name: test.cpp
|
|
|
|
// Purpose: Test program for wxWidgets
|
|
|
|
// Author: Mike Wetherell
|
|
|
|
// RCS-ID: $Id$
|
|
|
|
// Copyright: (c) 2004 Mike Wetherell
|
|
|
|
// Licence: wxWidgets licence
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2004-11-22 05:00:19 +00:00
|
|
|
// For compilers that support precompilation, includes "wx/wx.h"
|
|
|
|
// and "wx/cppunit.h"
|
|
|
|
#include "testprec.h"
|
2004-03-03 22:56:16 +00:00
|
|
|
|
|
|
|
#ifdef __BORLANDC__
|
|
|
|
#pragma hdrstop
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// for all others, include the necessary headers
|
|
|
|
#ifndef WX_PRECOMP
|
|
|
|
#include "wx/wx.h"
|
|
|
|
#endif
|
|
|
|
|
2008-11-05 10:08:19 +00:00
|
|
|
#include "wx/beforestd.h"
|
2008-11-18 15:51:09 +00:00
|
|
|
#ifdef __VISUALC__
|
|
|
|
#pragma warning(disable:4100)
|
|
|
|
#endif
|
2008-11-05 10:08:19 +00:00
|
|
|
#include <cppunit/TestListener.h>
|
2008-11-18 15:51:09 +00:00
|
|
|
#ifdef __VISUALC__
|
|
|
|
#pragma warning(default:4100)
|
|
|
|
#endif
|
2009-03-25 10:42:11 +00:00
|
|
|
#include <cppunit/Protector.h>
|
2008-11-05 10:08:19 +00:00
|
|
|
#include <cppunit/Test.h>
|
|
|
|
#include <cppunit/TestResult.h>
|
2009-03-25 16:28:20 +00:00
|
|
|
#include <cppunit/TestFailure.h>
|
2008-11-05 10:08:19 +00:00
|
|
|
#include "wx/afterstd.h"
|
|
|
|
|
2004-03-03 22:56:16 +00:00
|
|
|
#include "wx/cmdline.h"
|
|
|
|
#include <iostream>
|
|
|
|
|
2009-03-25 10:42:11 +00:00
|
|
|
#ifdef __WXMSW__
|
|
|
|
#include "wx/msw/msvcrt.h"
|
|
|
|
#endif
|
|
|
|
|
2009-04-14 19:54:01 +00:00
|
|
|
#ifdef __WXOSX__
|
|
|
|
#include "wx/osx/private.h"
|
|
|
|
#endif
|
|
|
|
|
2009-03-25 10:42:11 +00:00
|
|
|
using namespace std;
|
|
|
|
|
2004-11-10 21:29:08 +00:00
|
|
|
using CppUnit::Test;
|
|
|
|
using CppUnit::TestSuite;
|
|
|
|
using CppUnit::TestFactoryRegistry;
|
|
|
|
|
2009-03-25 10:42:11 +00:00
|
|
|
// exception class for MSVC debug CRT assertion failures
|
|
|
|
#ifdef wxUSE_VC_CRTDBG
|
|
|
|
|
|
|
|
struct CrtAssertFailure
|
|
|
|
{
|
|
|
|
CrtAssertFailure(const char *message) : m_msg(message) { }
|
|
|
|
|
|
|
|
const wxString m_msg;
|
|
|
|
|
|
|
|
wxDECLARE_NO_ASSIGN_CLASS(CrtAssertFailure);
|
|
|
|
};
|
|
|
|
|
|
|
|
#endif // wxUSE_VC_CRTDBG
|
|
|
|
|
|
|
|
// this function should only be called from a catch clause
|
|
|
|
static string GetExceptionMessage()
|
|
|
|
{
|
|
|
|
wxString msg;
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
#if wxDEBUG_LEVEL
|
|
|
|
catch ( TestAssertFailure& e )
|
|
|
|
{
|
|
|
|
msg << "wxWidgets assert: " << e.m_cond << " failed "
|
|
|
|
"at " << e.m_file << ":" << e.m_line << " in " << e.m_func
|
|
|
|
<< " with message " << e.m_msg;
|
|
|
|
}
|
|
|
|
#endif // wxDEBUG_LEVEL
|
|
|
|
#ifdef wxUSE_VC_CRTDBG
|
|
|
|
catch ( CrtAssertFailure& e )
|
|
|
|
{
|
|
|
|
msg << "CRT assert failure: " << e.m_msg;
|
|
|
|
}
|
|
|
|
#endif // wxUSE_VC_CRTDBG
|
|
|
|
catch ( std::exception& e )
|
|
|
|
{
|
|
|
|
msg << "std::exception: " << e.what();
|
|
|
|
}
|
|
|
|
catch ( ... )
|
|
|
|
{
|
|
|
|
msg = "Unknown exception caught.";
|
|
|
|
}
|
|
|
|
|
|
|
|
return string(msg.mb_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Protector adding handling of wx-specific (this includes MSVC debug CRT in
|
|
|
|
// this context) exceptions
|
|
|
|
class wxUnitTestProtector : public CppUnit::Protector
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
virtual bool protect(const CppUnit::Functor &functor,
|
|
|
|
const CppUnit::ProtectorContext& context)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
return functor();
|
|
|
|
}
|
2009-03-26 13:46:22 +00:00
|
|
|
catch ( std::exception& )
|
2009-03-25 13:32:19 +00:00
|
|
|
{
|
|
|
|
// cppunit deals with the standard exceptions itself, let it do as
|
|
|
|
// it output more details (especially for std::exception-derived
|
|
|
|
// CppUnit::Exception) than we do
|
|
|
|
throw;
|
|
|
|
}
|
2009-03-25 10:42:11 +00:00
|
|
|
catch ( ... )
|
|
|
|
{
|
|
|
|
reportError(context, CppUnit::Message("Uncaught exception",
|
|
|
|
GetExceptionMessage()));
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
2008-11-05 10:08:19 +00:00
|
|
|
|
2008-11-18 15:51:09 +00:00
|
|
|
// Displays the test name before starting to execute it: this helps with
|
|
|
|
// diagnosing where exactly does a test crash or hang when/if it does.
|
2008-11-05 10:08:19 +00:00
|
|
|
class DetailListener : public CppUnit::TestListener
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
DetailListener(bool doTiming = false):
|
|
|
|
CppUnit::TestListener(),
|
|
|
|
m_timing(doTiming)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void startTest(CppUnit::Test *test)
|
|
|
|
{
|
2009-03-25 16:28:20 +00:00
|
|
|
wxPrintf(" %-60s ", test->getName());
|
|
|
|
m_result = RESULT_OK;
|
2008-11-05 10:08:19 +00:00
|
|
|
m_watch.Start();
|
|
|
|
}
|
|
|
|
|
2009-03-26 15:35:30 +00:00
|
|
|
virtual void addFailure(const CppUnit::TestFailure& failure)
|
|
|
|
{
|
2009-03-25 16:28:20 +00:00
|
|
|
m_result = failure.isError() ? RESULT_ERROR : RESULT_FAIL;
|
|
|
|
}
|
|
|
|
|
2008-11-05 10:08:19 +00:00
|
|
|
virtual void endTest(CppUnit::Test * WXUNUSED(test))
|
|
|
|
{
|
|
|
|
m_watch.Pause();
|
2009-03-25 16:28:20 +00:00
|
|
|
wxPrintf(GetResultStr(m_result));
|
|
|
|
if (m_timing)
|
|
|
|
wxPrintf(" %6d ms", m_watch.Time());
|
|
|
|
wxPrintf("\n");
|
2008-11-05 10:08:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
protected :
|
2009-03-26 15:35:30 +00:00
|
|
|
enum ResultType
|
|
|
|
{
|
2009-03-25 16:28:20 +00:00
|
|
|
RESULT_OK = 0,
|
|
|
|
RESULT_FAIL,
|
2009-03-26 15:35:30 +00:00
|
|
|
RESULT_ERROR,
|
|
|
|
RESULT_MAX
|
2009-03-25 16:28:20 +00:00
|
|
|
};
|
|
|
|
|
2009-03-26 15:35:30 +00:00
|
|
|
wxString GetResultStr(ResultType type) const
|
|
|
|
{
|
|
|
|
static const char *resultTypeNames[] =
|
|
|
|
{
|
|
|
|
" OK",
|
|
|
|
"FAIL",
|
|
|
|
" ERR"
|
2009-03-25 16:28:20 +00:00
|
|
|
};
|
2009-03-26 15:35:30 +00:00
|
|
|
|
|
|
|
wxCOMPILE_TIME_ASSERT( WXSIZEOF(resultTypeNames) == RESULT_MAX,
|
|
|
|
ResultTypeNamesMismatch );
|
|
|
|
|
|
|
|
return resultTypeNames[type];
|
2009-03-25 16:28:20 +00:00
|
|
|
}
|
|
|
|
|
2008-11-05 10:08:19 +00:00
|
|
|
bool m_timing;
|
|
|
|
wxStopWatch m_watch;
|
2009-03-25 16:28:20 +00:00
|
|
|
ResultType m_result;
|
2008-11-05 10:08:19 +00:00
|
|
|
};
|
|
|
|
|
2007-09-26 00:28:31 +00:00
|
|
|
#if wxUSE_GUI
|
|
|
|
typedef wxApp TestAppBase;
|
|
|
|
#else
|
|
|
|
typedef wxAppConsole TestAppBase;
|
|
|
|
#endif
|
|
|
|
|
2004-03-03 22:56:16 +00:00
|
|
|
// The application class
|
|
|
|
//
|
2007-09-26 00:28:31 +00:00
|
|
|
class TestApp : public TestAppBase
|
2004-03-03 22:56:16 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
TestApp();
|
|
|
|
|
|
|
|
// standard overrides
|
2007-09-26 00:28:31 +00:00
|
|
|
virtual void OnInitCmdLine(wxCmdLineParser& parser);
|
|
|
|
virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
|
|
|
|
virtual bool OnInit();
|
|
|
|
virtual int OnRun();
|
|
|
|
virtual int OnExit();
|
2004-03-03 22:56:16 +00:00
|
|
|
|
2009-01-16 16:21:50 +00:00
|
|
|
// used by events propagation test
|
|
|
|
virtual int FilterEvent(wxEvent& event);
|
|
|
|
virtual bool ProcessEvent(wxEvent& event);
|
|
|
|
|
|
|
|
void SetFilterEventFunc(FilterEventFunc f) { m_filterEventFunc = f; }
|
|
|
|
void SetProcessEventFunc(ProcessEventFunc f) { m_processEventFunc = f; }
|
|
|
|
|
2004-03-03 22:56:16 +00:00
|
|
|
private:
|
2004-04-18 20:04:30 +00:00
|
|
|
void List(Test *test, const string& parent = "") const;
|
2004-03-03 22:56:16 +00:00
|
|
|
|
2009-04-03 16:38:20 +00:00
|
|
|
// call List() if m_list or runner.addTest() otherwise
|
|
|
|
void AddTest(CppUnit::TestRunner& runner, Test *test)
|
|
|
|
{
|
|
|
|
if (m_list)
|
|
|
|
List(test);
|
|
|
|
else
|
|
|
|
runner.addTest(test);
|
|
|
|
}
|
|
|
|
|
2004-03-03 22:56:16 +00:00
|
|
|
// command lines options/parameters
|
|
|
|
bool m_list;
|
2004-04-01 11:51:09 +00:00
|
|
|
bool m_longlist;
|
2008-11-05 10:08:19 +00:00
|
|
|
bool m_detail;
|
|
|
|
bool m_timing;
|
2009-03-22 16:10:09 +00:00
|
|
|
wxArrayString m_registries;
|
2009-04-03 15:31:57 +00:00
|
|
|
wxLocale *m_locale;
|
2009-01-16 16:21:50 +00:00
|
|
|
|
|
|
|
// event handling hooks
|
|
|
|
FilterEventFunc m_filterEventFunc;
|
|
|
|
ProcessEventFunc m_processEventFunc;
|
2004-03-03 22:56:16 +00:00
|
|
|
};
|
|
|
|
|
2009-03-25 10:42:11 +00:00
|
|
|
IMPLEMENT_APP_NO_MAIN(TestApp)
|
|
|
|
|
|
|
|
#ifdef wxUSE_VC_CRTDBG
|
|
|
|
|
|
|
|
static int TestCrtReportHook(int reportType, char *message, int *)
|
|
|
|
{
|
|
|
|
if ( reportType != _CRT_ASSERT )
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
throw CrtAssertFailure(message);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // wxUSE_VC_CRTDBG
|
|
|
|
|
|
|
|
#if wxDEBUG_LEVEL
|
|
|
|
|
|
|
|
static void TestAssertHandler(const wxString& file,
|
|
|
|
int line,
|
|
|
|
const wxString& func,
|
|
|
|
const wxString& cond,
|
|
|
|
const wxString& msg)
|
|
|
|
{
|
|
|
|
throw TestAssertFailure(file, line, func, cond, msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // wxDEBUG_LEVEL
|
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
// tests can be ran non-interactively so make sure we don't show any assert
|
|
|
|
// dialog boxes -- neither our own nor from MSVC debug CRT -- which would
|
|
|
|
// prevent them from completing
|
|
|
|
|
|
|
|
#if wxDEBUG_LEVEL
|
|
|
|
wxSetAssertHandler(TestAssertHandler);
|
|
|
|
#endif // wxDEBUG_LEVEL
|
|
|
|
|
|
|
|
#ifdef wxUSE_VC_CRTDBG
|
|
|
|
_CrtSetReportHook(TestCrtReportHook);
|
|
|
|
#endif // wxUSE_VC_CRTDBG
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
return wxEntry(argc, argv);
|
|
|
|
}
|
|
|
|
catch ( ... )
|
|
|
|
{
|
|
|
|
cerr << "\n" << GetExceptionMessage() << endl;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
2004-03-03 22:56:16 +00:00
|
|
|
|
|
|
|
TestApp::TestApp()
|
2004-04-18 20:04:30 +00:00
|
|
|
: m_list(false),
|
|
|
|
m_longlist(false)
|
2004-03-03 22:56:16 +00:00
|
|
|
{
|
2009-01-16 16:21:50 +00:00
|
|
|
m_filterEventFunc = NULL;
|
|
|
|
m_processEventFunc = NULL;
|
2009-04-03 15:31:57 +00:00
|
|
|
|
|
|
|
m_locale = NULL;
|
2004-03-03 22:56:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Init
|
|
|
|
//
|
|
|
|
bool TestApp::OnInit()
|
|
|
|
{
|
2007-09-26 00:28:31 +00:00
|
|
|
if ( !TestAppBase::OnInit() )
|
|
|
|
return false;
|
|
|
|
|
2004-03-03 22:56:16 +00:00
|
|
|
cout << "Test program for wxWidgets\n"
|
2004-11-10 21:29:08 +00:00
|
|
|
<< "build: " << WX_BUILD_OPTIONS_SIGNATURE << std::endl;
|
2007-02-11 02:27:29 +00:00
|
|
|
|
2007-09-26 00:28:31 +00:00
|
|
|
#if wxUSE_GUI
|
|
|
|
// create a hidden parent window to be used as parent for the GUI controls
|
|
|
|
new wxFrame(NULL, wxID_ANY, "Hidden wx test frame");
|
|
|
|
#endif // wxUSE_GUI
|
|
|
|
|
|
|
|
return true;
|
2008-07-19 15:36:39 +00:00
|
|
|
}
|
2004-03-03 22:56:16 +00:00
|
|
|
|
|
|
|
// The table of command line options
|
|
|
|
//
|
|
|
|
void TestApp::OnInitCmdLine(wxCmdLineParser& parser)
|
|
|
|
{
|
2007-09-26 00:28:31 +00:00
|
|
|
TestAppBase::OnInitCmdLine(parser);
|
2004-03-03 22:56:16 +00:00
|
|
|
|
|
|
|
static const wxCmdLineEntryDesc cmdLineDesc[] = {
|
2007-09-14 23:26:06 +00:00
|
|
|
{ wxCMD_LINE_SWITCH, "l", "list",
|
|
|
|
"list the test suites, do not run them",
|
2004-04-01 11:51:09 +00:00
|
|
|
wxCMD_LINE_VAL_NONE, 0 },
|
2007-09-14 23:26:06 +00:00
|
|
|
{ wxCMD_LINE_SWITCH, "L", "longlist",
|
|
|
|
"list the test cases, do not run them",
|
2004-03-03 22:56:16 +00:00
|
|
|
wxCMD_LINE_VAL_NONE, 0 },
|
2008-11-05 10:08:19 +00:00
|
|
|
{ wxCMD_LINE_SWITCH, "d", "detail",
|
|
|
|
"print the test case names, run them",
|
|
|
|
wxCMD_LINE_VAL_NONE, 0 },
|
|
|
|
{ wxCMD_LINE_SWITCH, "t", "timing",
|
|
|
|
"print names and mesure running time of individual test, run them",
|
|
|
|
wxCMD_LINE_VAL_NONE, 0 },
|
2009-04-03 15:31:57 +00:00
|
|
|
{ wxCMD_LINE_OPTION, "", "locale",
|
|
|
|
"locale to use when running the program",
|
|
|
|
wxCMD_LINE_VAL_STRING, 0 },
|
2007-09-14 23:26:06 +00:00
|
|
|
{ wxCMD_LINE_PARAM, NULL, NULL, "REGISTRY", wxCMD_LINE_VAL_STRING,
|
2004-04-01 11:51:09 +00:00
|
|
|
wxCMD_LINE_PARAM_OPTIONAL | wxCMD_LINE_PARAM_MULTIPLE },
|
2007-09-14 23:26:06 +00:00
|
|
|
wxCMD_LINE_DESC_END
|
2004-03-03 22:56:16 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
parser.SetDesc(cmdLineDesc);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle command line options
|
|
|
|
//
|
|
|
|
bool TestApp::OnCmdLineParsed(wxCmdLineParser& parser)
|
|
|
|
{
|
2004-04-01 11:51:09 +00:00
|
|
|
if (parser.GetParamCount())
|
2009-04-03 15:31:57 +00:00
|
|
|
{
|
2004-04-01 11:51:09 +00:00
|
|
|
for (size_t i = 0; i < parser.GetParamCount(); i++)
|
2009-03-22 16:10:09 +00:00
|
|
|
m_registries.push_back(parser.GetParam(i));
|
2009-04-03 15:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
m_longlist = parser.Found("longlist");
|
|
|
|
m_list = m_longlist || parser.Found("list");
|
|
|
|
m_timing = parser.Found("timing");
|
|
|
|
m_detail = !m_timing && parser.Found("detail");
|
|
|
|
|
|
|
|
wxString loc;
|
|
|
|
if ( parser.Found("locale", &loc) )
|
|
|
|
{
|
|
|
|
const wxLanguageInfo * const info = wxLocale::FindLanguageInfo(loc);
|
|
|
|
if ( !info )
|
|
|
|
{
|
|
|
|
cerr << "Locale \"" << string(loc.mb_str()) << "\" is unknown.\n";
|
|
|
|
return false;
|
|
|
|
}
|
2004-11-10 21:29:08 +00:00
|
|
|
|
2009-04-03 15:31:57 +00:00
|
|
|
m_locale = new wxLocale(info->Language);
|
|
|
|
if ( !m_locale->IsOk() )
|
|
|
|
{
|
|
|
|
cerr << "Using locale \"" << string(loc.mb_str()) << "\" failed.\n";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2004-03-03 22:56:16 +00:00
|
|
|
|
2007-09-26 00:28:31 +00:00
|
|
|
return TestAppBase::OnCmdLineParsed(parser);
|
2004-03-03 22:56:16 +00:00
|
|
|
}
|
|
|
|
|
2009-01-16 16:21:50 +00:00
|
|
|
// Event handling
|
|
|
|
int TestApp::FilterEvent(wxEvent& event)
|
|
|
|
{
|
|
|
|
if ( m_filterEventFunc )
|
|
|
|
return (*m_filterEventFunc)(event);
|
|
|
|
|
|
|
|
return TestAppBase::FilterEvent(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TestApp::ProcessEvent(wxEvent& event)
|
|
|
|
{
|
|
|
|
if ( m_processEventFunc )
|
|
|
|
return (*m_processEventFunc)(event);
|
|
|
|
|
|
|
|
return TestAppBase::ProcessEvent(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern void SetFilterEventFunc(FilterEventFunc func)
|
|
|
|
{
|
|
|
|
wxGetApp().SetFilterEventFunc(func);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern void SetProcessEventFunc(ProcessEventFunc func)
|
|
|
|
{
|
|
|
|
wxGetApp().SetProcessEventFunc(func);
|
|
|
|
}
|
|
|
|
|
2009-03-30 22:18:24 +00:00
|
|
|
// helper of OnRun(): gets the test with the given name, returning NULL (and
|
|
|
|
// not an empty test suite) if there is no such test
|
|
|
|
static Test *GetTestByName(const wxString& name)
|
|
|
|
{
|
|
|
|
Test *
|
|
|
|
test = TestFactoryRegistry::getRegistry(string(name.mb_str())).makeTest();
|
|
|
|
if ( test )
|
|
|
|
{
|
|
|
|
TestSuite * const suite = dynamic_cast<TestSuite *>(test);
|
|
|
|
if ( !suite || !suite->countTestCases() )
|
|
|
|
{
|
|
|
|
// it's a bogus test, don't use it
|
|
|
|
delete test;
|
|
|
|
test = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return test;
|
|
|
|
}
|
|
|
|
|
2004-03-03 22:56:16 +00:00
|
|
|
// Run
|
|
|
|
//
|
|
|
|
int TestApp::OnRun()
|
|
|
|
{
|
2009-04-14 19:54:01 +00:00
|
|
|
#if wxUSE_GUI
|
|
|
|
#ifdef __WXOSX__
|
|
|
|
// make sure there's always an autorelease pool ready
|
|
|
|
wxMacAutoreleasePool autoreleasepool;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2009-03-26 15:31:54 +00:00
|
|
|
#if wxUSE_LOG
|
|
|
|
// Switch off logging unless --verbose
|
|
|
|
bool verbose = wxLog::GetVerbose();
|
|
|
|
wxLog::EnableLogging(verbose);
|
|
|
|
#else
|
|
|
|
bool verbose = false;
|
|
|
|
#endif
|
|
|
|
|
2008-08-27 20:37:44 +00:00
|
|
|
CppUnit::TextTestRunner runner;
|
2004-04-01 11:51:09 +00:00
|
|
|
|
2009-04-03 16:38:20 +00:00
|
|
|
if ( m_registries.empty() )
|
2009-03-21 00:06:32 +00:00
|
|
|
{
|
2009-04-03 16:38:20 +00:00
|
|
|
// run or list all tests
|
|
|
|
AddTest(runner, TestFactoryRegistry::getRegistry().makeTest());
|
|
|
|
}
|
|
|
|
else // run only the selected tests
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < m_registries.size(); i++)
|
2009-03-30 22:18:24 +00:00
|
|
|
{
|
2009-04-03 16:38:20 +00:00
|
|
|
const wxString reg = m_registries[i];
|
|
|
|
Test *test = GetTestByName(reg);
|
2009-03-30 22:18:24 +00:00
|
|
|
|
|
|
|
if ( !test && !reg.EndsWith("TestCase") )
|
|
|
|
{
|
|
|
|
test = GetTestByName(reg + "TestCase");
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !test )
|
|
|
|
{
|
|
|
|
cerr << "No such test suite: " << string(reg.mb_str()) << endl;
|
|
|
|
return 2;
|
|
|
|
}
|
2004-04-01 11:51:09 +00:00
|
|
|
|
2009-04-03 16:38:20 +00:00
|
|
|
AddTest(runner, test);
|
|
|
|
}
|
2004-03-03 22:56:16 +00:00
|
|
|
}
|
2004-04-01 11:51:09 +00:00
|
|
|
|
2008-08-27 20:37:44 +00:00
|
|
|
if ( m_list )
|
2009-03-21 12:28:52 +00:00
|
|
|
return EXIT_SUCCESS;
|
2008-08-27 20:37:44 +00:00
|
|
|
|
|
|
|
runner.setOutputter(new CppUnit::CompilerOutputter(&runner.result(), cout));
|
2005-05-01 20:04:47 +00:00
|
|
|
|
2008-08-27 20:37:44 +00:00
|
|
|
// there is a bug
|
|
|
|
// (http://sf.net/tracker/index.php?func=detail&aid=1649369&group_id=11795&atid=111795)
|
|
|
|
// in some versions of cppunit: they write progress dots to cout (and not
|
|
|
|
// cerr) and don't flush it so all the dots appear at once at the end which
|
|
|
|
// is not very useful so unbuffer cout to work around this
|
|
|
|
cout.setf(ios::unitbuf);
|
|
|
|
|
2008-11-05 10:08:19 +00:00
|
|
|
// add detail listener if needed
|
|
|
|
DetailListener detailListener(m_timing);
|
|
|
|
if ( m_detail || m_timing )
|
|
|
|
runner.eventManager().addListener(&detailListener);
|
|
|
|
|
2009-03-25 10:42:11 +00:00
|
|
|
// finally ensure that we report our own exceptions nicely instead of
|
|
|
|
// giving "uncaught exception of unknown type" messages
|
|
|
|
runner.eventManager().pushProtector(new wxUnitTestProtector);
|
|
|
|
|
2009-03-25 16:28:20 +00:00
|
|
|
bool printProgress = !(verbose || m_detail || m_timing);
|
|
|
|
return runner.run("", false, true, printProgress) ? EXIT_SUCCESS : EXIT_FAILURE;
|
2004-03-03 22:56:16 +00:00
|
|
|
}
|
|
|
|
|
2007-09-26 00:28:31 +00:00
|
|
|
int TestApp::OnExit()
|
|
|
|
{
|
2009-04-03 15:31:57 +00:00
|
|
|
delete m_locale;
|
|
|
|
|
2007-09-26 00:28:31 +00:00
|
|
|
#if wxUSE_GUI
|
|
|
|
delete GetTopWindow();
|
|
|
|
#endif // wxUSE_GUI
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-03-03 22:56:16 +00:00
|
|
|
// List the tests
|
|
|
|
//
|
2004-04-18 20:04:30 +00:00
|
|
|
void TestApp::List(Test *test, const string& parent /*=""*/) const
|
2004-03-03 22:56:16 +00:00
|
|
|
{
|
|
|
|
TestSuite *suite = dynamic_cast<TestSuite*>(test);
|
2004-04-18 20:04:30 +00:00
|
|
|
string name;
|
|
|
|
|
2004-04-21 20:17:18 +00:00
|
|
|
if (suite) {
|
2004-04-18 20:04:30 +00:00
|
|
|
// take the last component of the name and append to the parent
|
|
|
|
name = test->getName();
|
|
|
|
string::size_type i = name.find_last_of(".:");
|
2004-11-25 20:37:44 +00:00
|
|
|
if (i != string::npos)
|
|
|
|
name = name.substr(i + 1);
|
|
|
|
name = parent + "." + name;
|
2004-04-18 20:04:30 +00:00
|
|
|
|
|
|
|
// drop the 1st component from the display and indent
|
|
|
|
if (parent != "") {
|
|
|
|
string::size_type j = i = name.find('.', 1);
|
|
|
|
while ((j = name.find('.', j + 1)) != string::npos)
|
|
|
|
cout << " ";
|
|
|
|
cout << " " << name.substr(i + 1) << "\n";
|
|
|
|
}
|
2004-04-01 11:51:09 +00:00
|
|
|
|
2004-04-25 11:06:02 +00:00
|
|
|
typedef vector<Test*> Tests;
|
2004-03-03 22:56:16 +00:00
|
|
|
typedef Tests::const_iterator Iter;
|
|
|
|
|
2004-04-25 11:06:02 +00:00
|
|
|
const Tests& tests = suite->getTests();
|
2004-03-03 22:56:16 +00:00
|
|
|
|
|
|
|
for (Iter it = tests.begin(); it != tests.end(); ++it)
|
2004-04-18 20:04:30 +00:00
|
|
|
List(*it, name);
|
2004-03-03 22:56:16 +00:00
|
|
|
}
|
2004-04-21 20:17:18 +00:00
|
|
|
else if (m_longlist) {
|
|
|
|
string::size_type i = 0;
|
|
|
|
while ((i = parent.find('.', i + 1)) != string::npos)
|
|
|
|
cout << " ";
|
|
|
|
cout << " " << test->getName() << "\n";
|
|
|
|
}
|
2004-03-03 22:56:16 +00:00
|
|
|
}
|