tests/log/logtest.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/log/logtest.cpp
   3 // Purpose:     wxLog unit test
   4 // Author:      Vadim Zeitlin
   5 // Created:     2009-07-07
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 // ----------------------------------------------------------------------------
  11 // headers
  12 // ----------------------------------------------------------------------------
  13
  14 #include "testprec.h"
  15
  16 #ifdef __BORLANDC__
  17     #pragma hdrstop
  18 #endif
  19
  20 #ifndef WX_PRECOMP
  21     #include "wx/log.h"
  22 #endif // WX_PRECOMP
  23
  24 #include "wx/scopeguard.h"
  25
  26 #if WXWIN_COMPATIBILITY_2_8
  27     // we override deprecated DoLog() and DoLogString() in this test, suppress
  28     // warnings about it
  29     #if wxCHECK_VISUALC_VERSION(7)
  30         #pragma warning(disable: 4996)
  31     #endif // VC++ 7+
  32 #endif // WXWIN_COMPATIBILITY_2_8
  33
  34 // all calls to wxLogXXX() functions from this file will use this log component
  35 #define wxLOG_COMPONENT "test"
  36
  37 // ----------------------------------------------------------------------------
  38 // test loggers
  39 // ----------------------------------------------------------------------------
  40
  41 // base class for all test loggers which simply store all logged messages for
  42 // future examination in the test code
  43 class TestLogBase : public wxLog
  44 {
  45 public:
  46     TestLogBase() { }
  47
  48     const wxString& GetLog(wxLogLevel level) const
  49     {
  50         return m_logs[level];
  51     }
  52
  53     const wxLogRecordInfo& GetInfo(wxLogLevel level) const
  54     {
  55         return m_logsInfo[level];
  56     }
  57
  58     void Clear()
  59     {
  60         for ( unsigned n = 0; n < WXSIZEOF(m_logs); n++ )
  61         {
  62             m_logs[n].clear();
  63             m_logsInfo[n] = wxLogRecordInfo();
  64         }
  65     }
  66
  67 protected:
  68     wxString m_logs[wxLOG_Trace + 1];
  69     wxLogRecordInfo m_logsInfo[wxLOG_Trace + 1];
  70
  71     wxDECLARE_NO_COPY_CLASS(TestLogBase);
  72 };
  73
  74 // simple log sink which just stores the messages logged for each level
  75 class TestLog : public TestLogBase
  76 {
  77 public:
  78     TestLog() { }
  79
  80 protected:
  81     virtual void DoLogRecord(wxLogLevel level,
  82                              const wxString& msg,
  83                              const wxLogRecordInfo& info)
  84     {
  85         m_logs[level] = msg;
  86         m_logsInfo[level] = info;
  87     }
  88
  89 private:
  90     wxDECLARE_NO_COPY_CLASS(TestLog);
  91 };
  92
  93 #if WXWIN_COMPATIBILITY_2_8
  94
  95 // log sink overriding the old DoLogXXX() functions should still work too
  96
  97 // this one overrides DoLog(char*)
  98 class CompatTestLog : public TestLogBase
  99 {
 100 public:
 101     CompatTestLog() { }
 102
 103 protected:
 104     virtual void DoLog(wxLogLevel level, const char *str, time_t WXUNUSED(t))
 105     {
 106         m_logs[level] = str;
 107     }
 108
 109     // get rid of the warning about hiding the other overload
 110     virtual void DoLog(wxLogLevel WXUNUSED(level),
 111                        const wchar_t *WXUNUSED(str),
 112                        time_t WXUNUSED(t))
 113     {
 114     }
 115
 116 private:
 117     wxDECLARE_NO_COPY_CLASS(CompatTestLog);
 118 };
 119
 120 // and this one overload DoLogString(wchar_t*)
 121 class CompatTestLog2 : public wxLog
 122 {
 123 public:
 124     CompatTestLog2() { }
 125
 126     const wxString& Get() const { return m_msg; }
 127
 128 protected:
 129     virtual void DoLogString(const wchar_t *msg, time_t WXUNUSED(t))
 130     {
 131         m_msg = msg;
 132     }
 133
 134     // get rid of the warning
 135     virtual void DoLogString(const char *WXUNUSED(msg), time_t WXUNUSED(t))
 136     {
 137     }
 138
 139 private:
 140     wxString m_msg;
 141
 142     wxDECLARE_NO_COPY_CLASS(CompatTestLog2);
 143 };
 144
 145 #endif // WXWIN_COMPATIBILITY_2_8
 146
 147 // ----------------------------------------------------------------------------
 148 // test class
 149 // ----------------------------------------------------------------------------
 150
 151 class LogTestCase : public CppUnit::TestCase
 152 {
 153 public:
 154     LogTestCase() { }
 155
 156     virtual void setUp();
 157     virtual void tearDown();
 158
 159 private:
 160     CPPUNIT_TEST_SUITE( LogTestCase );
 161         CPPUNIT_TEST( Functions );
 162         CPPUNIT_TEST( Null );
 163         CPPUNIT_TEST( Component );
 164 #if wxDEBUG_LEVEL
 165         CPPUNIT_TEST( Trace );
 166 #endif // wxDEBUG_LEVEL
 167 #if WXWIN_COMPATIBILITY_2_8
 168         CPPUNIT_TEST( CompatLogger );
 169         CPPUNIT_TEST( CompatLogger2 );
 170 #endif // WXWIN_COMPATIBILITY_2_8
 171     CPPUNIT_TEST_SUITE_END();
 172
 173     void Functions();
 174     void Null();
 175     void Component();
 176 #if wxDEBUG_LEVEL
 177     void Trace();
 178 #endif // wxDEBUG_LEVEL
 179 #if WXWIN_COMPATIBILITY_2_8
 180     void CompatLogger();
 181     void CompatLogger2();
 182 #endif // WXWIN_COMPATIBILITY_2_8
 183
 184     TestLog *m_log;
 185     wxLog *m_logOld;
 186     bool m_logWasEnabled;
 187
 188     wxDECLARE_NO_COPY_CLASS(LogTestCase);
 189 };
 190
 191 // register in the unnamed registry so that these tests are run by default
 192 CPPUNIT_TEST_SUITE_REGISTRATION( LogTestCase );
 193
 194 // also include in it's own registry so that these tests can be run alone
 195 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( LogTestCase, "LogTestCase" );
 196
 197 void LogTestCase::setUp()
 198 {
 199     m_logOld = wxLog::SetActiveTarget(m_log = new TestLog);
 200     m_logWasEnabled = wxLog::EnableLogging();
 201 }
 202
 203 void LogTestCase::tearDown()
 204 {
 205     delete wxLog::SetActiveTarget(m_logOld);
 206     wxLog::EnableLogging(m_logWasEnabled);
 207 }
 208
 209 void LogTestCase::Functions()
 210 {
 211     wxLogMessage("Message");
 212     CPPUNIT_ASSERT_EQUAL( "Message", m_log->GetLog(wxLOG_Message) );
 213
 214     wxLogError("Error %d", 17);
 215     CPPUNIT_ASSERT_EQUAL( "Error 17", m_log->GetLog(wxLOG_Error) );
 216
 217     wxLogDebug("Debug");
 218 #if wxDEBUG_LEVEL
 219     CPPUNIT_ASSERT_EQUAL( "Debug", m_log->GetLog(wxLOG_Debug) );
 220 #else
 221     CPPUNIT_ASSERT_EQUAL( "", m_log->GetLog(wxLOG_Debug) );
 222 #endif
 223 }
 224
 225 void LogTestCase::Null()
 226 {
 227     {
 228         wxLogNull noLog;
 229         wxLogWarning("%s warning", "Not important");
 230
 231         CPPUNIT_ASSERT_EQUAL( "", m_log->GetLog(wxLOG_Warning) );
 232     }
 233
 234     wxLogWarning("%s warning", "Important");
 235     CPPUNIT_ASSERT_EQUAL( "Important warning", m_log->GetLog(wxLOG_Warning) );
 236 }
 237
 238 void LogTestCase::Component()
 239 {
 240     wxLogMessage("Message");
 241     CPPUNIT_ASSERT_EQUAL( wxLOG_COMPONENT,
 242                           m_log->GetInfo(wxLOG_Message).component );
 243
 244     // completely disable logging for this component
 245     wxLog::SetComponentLevel("test/ignore", wxLOG_FatalError);
 246
 247     // but enable it for one of its subcomponents
 248     wxLog::SetComponentLevel("test/ignore/not", wxLOG_Max);
 249
 250     #undef wxLOG_COMPONENT
 251     #define wxLOG_COMPONENT "test/ignore"
 252
 253     // this shouldn't be output as this component is ignored
 254     wxLogError("Error");
 255     CPPUNIT_ASSERT_EQUAL( "", m_log->GetLog(wxLOG_Error) );
 256
 257     // and so are its subcomponents
 258     #undef wxLOG_COMPONENT
 259     #define wxLOG_COMPONENT "test/ignore/sub/subsub"
 260     wxLogError("Error");
 261     CPPUNIT_ASSERT_EQUAL( "", m_log->GetLog(wxLOG_Error) );
 262
 263     // but one subcomponent is not
 264     #undef wxLOG_COMPONENT
 265     #define wxLOG_COMPONENT "test/ignore/not"
 266     wxLogError("Error");
 267     CPPUNIT_ASSERT_EQUAL( "Error", m_log->GetLog(wxLOG_Error) );
 268
 269     // restore the original value
 270     #undef wxLOG_COMPONENT
 271     #define wxLOG_COMPONENT "test"
 272 }
 273
 274 #if wxDEBUG_LEVEL
 275
 276 namespace
 277 {
 278
 279 const char *TEST_MASK = "test";
 280
 281 // this is a test vararg function (a real one, not a variadic-template-like as
 282 // wxVLogTrace(), so care should be taken with its arguments)
 283 void TraceTest(const char *format, ...)
 284 {
 285     va_list argptr;
 286     va_start(argptr, format);
 287     wxVLogTrace(TEST_MASK, format, argptr);
 288     va_end(argptr);
 289 }
 290
 291 } // anonymous namespace
 292
 293 void LogTestCase::Trace()
 294 {
 295     // we use wxLogTrace() or wxVLogTrace() from inside TraceTest()
 296     // interchangeably here, it shouldn't make any difference
 297
 298     wxLogTrace(TEST_MASK, "Not shown");
 299     CPPUNIT_ASSERT_EQUAL( "", m_log->GetLog(wxLOG_Trace) );
 300
 301     wxLog::AddTraceMask(TEST_MASK);
 302     TraceTest("Shown");
 303     CPPUNIT_ASSERT_EQUAL( wxString::Format("(%s) Shown", TEST_MASK),
 304                           m_log->GetLog(wxLOG_Trace) );
 305
 306     wxLog::RemoveTraceMask(TEST_MASK);
 307     m_log->Clear();
 308
 309     TraceTest("Not shown again");
 310     CPPUNIT_ASSERT_EQUAL( "", m_log->GetLog(wxLOG_Trace) );
 311 }
 312
 313 #endif // wxDEBUG_LEVEL
 314
 315 #if WXWIN_COMPATIBILITY_2_8
 316
 317 void LogTestCase::CompatLogger()
 318 {
 319     CompatTestLog log;
 320     wxLog * const logOld = wxLog::SetActiveTarget(&log);
 321     wxON_BLOCK_EXIT1( wxLog::SetActiveTarget, logOld );
 322
 323     wxLogError("Old error");
 324     CPPUNIT_ASSERT_EQUAL( "Old error", log.GetLog(wxLOG_Error) );
 325 }
 326
 327 void LogTestCase::CompatLogger2()
 328 {
 329     CompatTestLog2 log;
 330     wxLog * const logOld = wxLog::SetActiveTarget(&log);
 331     wxON_BLOCK_EXIT1( wxLog::SetActiveTarget, logOld );
 332
 333     wxLogWarning("Old warning");
 334     CPPUNIT_ASSERT_EQUAL( "Old warning", log.Get() );
 335 }
 336
 337 #endif // WXWIN_COMPATIBILITY_2_8