tests/test.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        test.cpp
   3 // Purpose:     Test program for wxWidgets
   4 // Author:      Mike Wetherell
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 2004 Mike Wetherell
   7 // Licence:     wxWidgets licence
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx/wx.h"
  11 // and "wx/cppunit.h"
  12 #include "testprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 // for all others, include the necessary headers
  19 #ifndef WX_PRECOMP
  20     #include "wx/wx.h"
  21 #endif
  22
  23 #include "wx/beforestd.h"
  24 #ifdef __VISUALC__
  25     #pragma warning(disable:4100)
  26 #endif
  27 #include <cppunit/TestListener.h>
  28 #ifdef __VISUALC__
  29     #pragma warning(default:4100)
  30 #endif
  31 #include <cppunit/Protector.h>
  32 #include <cppunit/Test.h>
  33 #include <cppunit/TestResult.h>
  34 #include <cppunit/TestFailure.h>
  35 #include "wx/afterstd.h"
  36
  37 #include "wx/cmdline.h"
  38 #include <iostream>
  39
  40 #ifdef __WXMSW__
  41     #include "wx/msw/msvcrt.h"
  42 #endif
  43
  44 using namespace std;
  45
  46 using CppUnit::Test;
  47 using CppUnit::TestSuite;
  48 using CppUnit::TestFactoryRegistry;
  49
  50 // exception class for MSVC debug CRT assertion failures
  51 #ifdef wxUSE_VC_CRTDBG
  52
  53 struct CrtAssertFailure
  54 {
  55     CrtAssertFailure(const char *message) : m_msg(message) { }
  56
  57     const wxString m_msg;
  58
  59     wxDECLARE_NO_ASSIGN_CLASS(CrtAssertFailure);
  60 };
  61
  62 #endif // wxUSE_VC_CRTDBG
  63
  64 // this function should only be called from a catch clause
  65 static string GetExceptionMessage()
  66 {
  67     wxString msg;
  68
  69     try
  70     {
  71         throw;
  72     }
  73 #if wxDEBUG_LEVEL
  74     catch ( TestAssertFailure& e )
  75     {
  76         msg << "wxWidgets assert: " << e.m_cond << " failed "
  77                "at " << e.m_file << ":" << e.m_line << " in " << e.m_func
  78             << " with message " << e.m_msg;
  79     }
  80 #endif // wxDEBUG_LEVEL
  81 #ifdef wxUSE_VC_CRTDBG
  82     catch ( CrtAssertFailure& e )
  83     {
  84         msg << "CRT assert failure: " << e.m_msg;
  85     }
  86 #endif // wxUSE_VC_CRTDBG
  87     catch ( std::exception& e )
  88     {
  89         msg << "std::exception: " << e.what();
  90     }
  91     catch ( ... )
  92     {
  93         msg = "Unknown exception caught.";
  94     }
  95
  96     return string(msg.mb_str());
  97 }
  98
  99 // Protector adding handling of wx-specific (this includes MSVC debug CRT in
 100 // this context) exceptions
 101 class wxUnitTestProtector : public CppUnit::Protector
 102 {
 103 public:
 104     virtual bool protect(const CppUnit::Functor &functor,
 105                          const CppUnit::ProtectorContext& context)
 106     {
 107         try
 108         {
 109             return functor();
 110         }
 111         catch ( std::exception& )
 112         {
 113             // cppunit deals with the standard exceptions itself, let it do as
 114             // it output more details (especially for std::exception-derived
 115             // CppUnit::Exception) than we do
 116             throw;
 117         }
 118         catch ( ... )
 119         {
 120             reportError(context, CppUnit::Message("Uncaught exception",
 121                                                   GetExceptionMessage()));
 122         }
 123
 124         return false;
 125     }
 126 };
 127
 128 // Displays the test name before starting to execute it: this helps with
 129 // diagnosing where exactly does a test crash or hang when/if it does.
 130 class DetailListener : public CppUnit::TestListener
 131 {
 132 public:
 133     DetailListener(bool doTiming = false):
 134         CppUnit::TestListener(),
 135         m_timing(doTiming)
 136     {
 137     }
 138
 139     virtual void startTest(CppUnit::Test *test)
 140     {
 141         wxPrintf("  %-60s  ", test->getName());
 142         m_result = RESULT_OK;
 143         m_watch.Start();
 144     }
 145
 146     virtual void addFailure(const CppUnit::TestFailure& failure)
 147     {
 148         m_result = failure.isError() ? RESULT_ERROR : RESULT_FAIL;
 149     }
 150
 151     virtual void endTest(CppUnit::Test * WXUNUSED(test))
 152     {
 153         m_watch.Pause();
 154         wxPrintf(GetResultStr(m_result));
 155         if (m_timing)
 156             wxPrintf("  %6d ms", m_watch.Time());
 157         wxPrintf("\n");
 158     }
 159
 160 protected :
 161     enum ResultType
 162     {
 163         RESULT_OK = 0,
 164         RESULT_FAIL,
 165         RESULT_ERROR,
 166         RESULT_MAX
 167     };
 168
 169     wxString GetResultStr(ResultType type) const
 170     {
 171         static const char *resultTypeNames[] =
 172         {
 173             "  OK",
 174             "FAIL",
 175             " ERR"
 176         };
 177
 178         wxCOMPILE_TIME_ASSERT( WXSIZEOF(resultTypeNames) == RESULT_MAX,
 179                                ResultTypeNamesMismatch );
 180
 181         return resultTypeNames[type];
 182     }
 183
 184     bool m_timing;
 185     wxStopWatch m_watch;
 186     ResultType m_result;
 187 };
 188
 189 #if wxUSE_GUI
 190     typedef wxApp TestAppBase;
 191 #else
 192     typedef wxAppConsole TestAppBase;
 193 #endif
 194
 195 // The application class
 196 //
 197 class TestApp : public TestAppBase
 198 {
 199 public:
 200     TestApp();
 201
 202     // standard overrides
 203     virtual void OnInitCmdLine(wxCmdLineParser& parser);
 204     virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
 205     virtual bool OnInit();
 206     virtual int  OnRun();
 207     virtual int  OnExit();
 208
 209     // used by events propagation test
 210     virtual int FilterEvent(wxEvent& event);
 211     virtual bool ProcessEvent(wxEvent& event);
 212
 213     void SetFilterEventFunc(FilterEventFunc f) { m_filterEventFunc = f; }
 214     void SetProcessEventFunc(ProcessEventFunc f) { m_processEventFunc = f; }
 215
 216 private:
 217     void List(Test *test, const string& parent = "") const;
 218
 219     // command lines options/parameters
 220     bool m_list;
 221     bool m_longlist;
 222     bool m_detail;
 223     bool m_timing;
 224     wxArrayString m_registries;
 225
 226     // event handling hooks
 227     FilterEventFunc m_filterEventFunc;
 228     ProcessEventFunc m_processEventFunc;
 229 };
 230
 231 IMPLEMENT_APP_NO_MAIN(TestApp)
 232
 233 #ifdef wxUSE_VC_CRTDBG
 234
 235 static int TestCrtReportHook(int reportType, char *message, int *)
 236 {
 237     if ( reportType != _CRT_ASSERT )
 238         return FALSE;
 239
 240     throw CrtAssertFailure(message);
 241 }
 242
 243 #endif // wxUSE_VC_CRTDBG
 244
 245 #if wxDEBUG_LEVEL
 246
 247 static void TestAssertHandler(const wxString& file,
 248                               int line,
 249                               const wxString& func,
 250                               const wxString& cond,
 251                               const wxString& msg)
 252 {
 253     throw TestAssertFailure(file, line, func, cond, msg);
 254 }
 255
 256 #endif // wxDEBUG_LEVEL
 257
 258 int main(int argc, char **argv)
 259 {
 260     // tests can be ran non-interactively so make sure we don't show any assert
 261     // dialog boxes -- neither our own nor from MSVC debug CRT -- which would
 262     // prevent them from completing
 263
 264 #if wxDEBUG_LEVEL
 265     wxSetAssertHandler(TestAssertHandler);
 266 #endif // wxDEBUG_LEVEL
 267
 268 #ifdef wxUSE_VC_CRTDBG
 269     _CrtSetReportHook(TestCrtReportHook);
 270 #endif // wxUSE_VC_CRTDBG
 271
 272     try
 273     {
 274         return wxEntry(argc, argv);
 275     }
 276     catch ( ... )
 277     {
 278         cerr << "\n" << GetExceptionMessage() << endl;
 279     }
 280
 281     return -1;
 282 }
 283
 284 TestApp::TestApp()
 285   : m_list(false),
 286     m_longlist(false)
 287 {
 288     m_filterEventFunc = NULL;
 289     m_processEventFunc = NULL;
 290 }
 291
 292 // Init
 293 //
 294 bool TestApp::OnInit()
 295 {
 296     if ( !TestAppBase::OnInit() )
 297         return false;
 298
 299     cout << "Test program for wxWidgets\n"
 300          << "build: " << WX_BUILD_OPTIONS_SIGNATURE << std::endl;
 301
 302 #if wxUSE_GUI
 303     // create a hidden parent window to be used as parent for the GUI controls
 304     new wxFrame(NULL, wxID_ANY, "Hidden wx test frame");
 305 #endif // wxUSE_GUI
 306
 307     return true;
 308 }
 309
 310 // The table of command line options
 311 //
 312 void TestApp::OnInitCmdLine(wxCmdLineParser& parser)
 313 {
 314     TestAppBase::OnInitCmdLine(parser);
 315
 316     static const wxCmdLineEntryDesc cmdLineDesc[] = {
 317         { wxCMD_LINE_SWITCH, "l", "list",
 318             "list the test suites, do not run them",
 319             wxCMD_LINE_VAL_NONE, 0 },
 320         { wxCMD_LINE_SWITCH, "L", "longlist",
 321             "list the test cases, do not run them",
 322             wxCMD_LINE_VAL_NONE, 0 },
 323         { wxCMD_LINE_SWITCH, "d", "detail",
 324             "print the test case names, run them",
 325             wxCMD_LINE_VAL_NONE, 0 },
 326         { wxCMD_LINE_SWITCH, "t", "timing",
 327             "print names and mesure running time of individual test, run them",
 328             wxCMD_LINE_VAL_NONE, 0 },
 329         { wxCMD_LINE_PARAM, NULL, NULL, "REGISTRY", wxCMD_LINE_VAL_STRING,
 330             wxCMD_LINE_PARAM_OPTIONAL | wxCMD_LINE_PARAM_MULTIPLE },
 331         wxCMD_LINE_DESC_END
 332     };
 333
 334     parser.SetDesc(cmdLineDesc);
 335 }
 336
 337 // Handle command line options
 338 //
 339 bool TestApp::OnCmdLineParsed(wxCmdLineParser& parser)
 340 {
 341     if (parser.GetParamCount())
 342         for (size_t i = 0; i < parser.GetParamCount(); i++)
 343             m_registries.push_back(parser.GetParam(i));
 344     else
 345         m_registries.push_back("");
 346
 347     m_longlist = parser.Found(_T("longlist"));
 348     m_list = m_longlist || parser.Found(_T("list"));
 349     m_timing = parser.Found(_T("timing"));
 350     m_detail = !m_timing && parser.Found(_T("detail"));
 351
 352     return TestAppBase::OnCmdLineParsed(parser);
 353 }
 354
 355 // Event handling
 356 int TestApp::FilterEvent(wxEvent& event)
 357 {
 358     if ( m_filterEventFunc )
 359         return (*m_filterEventFunc)(event);
 360
 361     return TestAppBase::FilterEvent(event);
 362 }
 363
 364 bool TestApp::ProcessEvent(wxEvent& event)
 365 {
 366     if ( m_processEventFunc )
 367         return (*m_processEventFunc)(event);
 368
 369     return TestAppBase::ProcessEvent(event);
 370 }
 371
 372 extern void SetFilterEventFunc(FilterEventFunc func)
 373 {
 374     wxGetApp().SetFilterEventFunc(func);
 375 }
 376
 377 extern void SetProcessEventFunc(ProcessEventFunc func)
 378 {
 379     wxGetApp().SetProcessEventFunc(func);
 380 }
 381
 382 // helper of OnRun(): gets the test with the given name, returning NULL (and
 383 // not an empty test suite) if there is no such test
 384 static Test *GetTestByName(const wxString& name)
 385 {
 386     Test *
 387       test = TestFactoryRegistry::getRegistry(string(name.mb_str())).makeTest();
 388     if ( test )
 389     {
 390         TestSuite * const suite = dynamic_cast<TestSuite *>(test);
 391         if ( !suite || !suite->countTestCases() )
 392         {
 393             // it's a bogus test, don't use it
 394             delete test;
 395             test = NULL;
 396         }
 397     }
 398
 399     return test;
 400 }
 401
 402 // Run
 403 //
 404 int TestApp::OnRun()
 405 {
 406 #if wxUSE_LOG
 407     // Switch off logging unless --verbose
 408     bool verbose = wxLog::GetVerbose();
 409     wxLog::EnableLogging(verbose);
 410 #else
 411     bool verbose = false;
 412 #endif
 413
 414     CppUnit::TextTestRunner runner;
 415
 416     for (size_t i = 0; i < m_registries.size(); i++)
 417     {
 418         Test *test;
 419
 420         wxString reg = m_registries[i];
 421         if ( reg.empty() )
 422         {
 423             // no test name, run all the tests
 424             test = TestFactoryRegistry::getRegistry().makeTest();
 425         }
 426         else // test name specified, run just this test
 427         {
 428             test = GetTestByName(reg);
 429
 430             if ( !test && !reg.EndsWith("TestCase") )
 431             {
 432                 test = GetTestByName(reg + "TestCase");
 433             }
 434
 435             if ( !test )
 436             {
 437                 cerr << "No such test suite: " << string(reg.mb_str()) << endl;
 438                 return 2;
 439             }
 440         }
 441
 442         if (m_list)
 443             List(test);
 444         else
 445             runner.addTest(test);
 446     }
 447
 448     if ( m_list )
 449         return EXIT_SUCCESS;
 450
 451     runner.setOutputter(new CppUnit::CompilerOutputter(&runner.result(), cout));
 452
 453     // there is a bug
 454     // (http://sf.net/tracker/index.php?func=detail&aid=1649369&group_id=11795&atid=111795)
 455     // in some versions of cppunit: they write progress dots to cout (and not
 456     // cerr) and don't flush it so all the dots appear at once at the end which
 457     // is not very useful so unbuffer cout to work around this
 458     cout.setf(ios::unitbuf);
 459
 460     // add detail listener if needed
 461     DetailListener detailListener(m_timing);
 462     if ( m_detail || m_timing )
 463         runner.eventManager().addListener(&detailListener);
 464
 465     // finally ensure that we report our own exceptions nicely instead of
 466     // giving "uncaught exception of unknown type" messages
 467     runner.eventManager().pushProtector(new wxUnitTestProtector);
 468
 469     bool printProgress = !(verbose || m_detail || m_timing);
 470     return runner.run("", false, true, printProgress) ? EXIT_SUCCESS : EXIT_FAILURE;
 471 }
 472
 473 int TestApp::OnExit()
 474 {
 475 #if wxUSE_GUI
 476     delete GetTopWindow();
 477 #endif // wxUSE_GUI
 478
 479     return 0;
 480 }
 481
 482 // List the tests
 483 //
 484 void TestApp::List(Test *test, const string& parent /*=""*/) const
 485 {
 486     TestSuite *suite = dynamic_cast<TestSuite*>(test);
 487     string name;
 488
 489     if (suite) {
 490         // take the last component of the name and append to the parent
 491         name = test->getName();
 492         string::size_type i = name.find_last_of(".:");
 493         if (i != string::npos)
 494             name = name.substr(i + 1);
 495         name = parent + "." + name;
 496
 497         // drop the 1st component from the display and indent
 498         if (parent != "") {
 499             string::size_type j = i = name.find('.', 1);
 500             while ((j = name.find('.', j + 1)) != string::npos)
 501                 cout << "  ";
 502             cout << "  " << name.substr(i + 1) << "\n";
 503         }
 504
 505         typedef vector<Test*> Tests;
 506         typedef Tests::const_iterator Iter;
 507
 508         const Tests& tests = suite->getTests();
 509
 510         for (Iter it = tests.begin(); it != tests.end(); ++it)
 511             List(*it, name);
 512     }
 513     else if (m_longlist) {
 514         string::size_type i = 0;
 515         while ((i = parent.find('.', i + 1)) != string::npos)
 516             cout << "  ";
 517         cout << "  " << test->getName() << "\n";
 518     }
 519 }