unittests/muleunit/test.h

   1 //
   2 // MuleUnit: A minimalistic C++ Unit testing framework based on EasyUnit.
   3 //
   4 // Copyright (c) 2005-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2004-2008 Barthelemy Dagenais ( barthelemy@prologique.com )
   6 //
   7 // This library is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU Lesser General Public
   9 // License as published by the Free Software Foundation; either
  10 // version 2.1 of the License, or (at your option) any later version.
  11 //
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // Lesser General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Lesser General Public
  18 // License along with this library; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  20 //
  21
  22 #ifndef TEST_H
  23 #define TEST_H
  24
  25 #include <exception>
  26
  27 #include <wx/string.h>
  28 #include <list>
  29
  30
  31
  32 /**
  33  * MuleUnit namespace.
  34  * This is the namespace containing all muleunit classes.
  35  */
  36 namespace muleunit
  37 {
  38
  39 class TestCase;
  40 class BTList;
  41
  42
  43 /** Returns the size of a static array. */
  44 template <typename T, size_t N>
  45 inline size_t ArraySize(T(&)[N])
  46 {
  47         return N;
  48 }
  49
  50
  51 /** Printf for wide-char strings. */
  52 inline void Printf(const wxChar *pszFormat, ...)
  53 {
  54         va_list argptr;
  55         va_start(argptr, pszFormat);
  56
  57         wxPuts(wxString::FormatV(pszFormat, argptr).c_str());
  58
  59         va_end(argptr);
  60 }
  61
  62
  63 /** This exception is raised if an ASSERT fails. */
  64 struct CTestFailureException : public std::exception
  65 {
  66         /** Constructor, takes a snapshot of the current context, and adds the given information. */
  67         CTestFailureException(const wxString& msg, const wxChar* file, long lineNumber);
  68
  69         ~CTestFailureException() throw();
  70
  71         /** Prints the context backtrace for the location where the exception was thrown. */
  72         void PrintBT() const;
  73
  74         virtual const char* what () const throw ();
  75 private:
  76         //! Pointer to struct containing a snapshot of the contexts
  77         //! taken at the time the exception was created.
  78         struct BTList* m_bt;
  79
  80         //! The message passed in the constructor.
  81         std::string m_message;
  82 };
  83
  84 /** This exception is raised if an wxASSERT fails. */
  85 struct CAssertFailureException : public CTestFailureException
  86 {
  87 public:
  88         CAssertFailureException(const wxString& msg, const wxChar* file, long lineNumber)
  89                 : CTestFailureException(msg, file, lineNumber)
  90         {
  91         }
  92 };
  93
  94
  95 /**
  96  * This class is used to produce informative backtraces
  97  *
  98  * This is done by specifying a "context" for a given scope, using
  99  * the CONTEXT macro, at which point a description is added to the
 100  * current list of contexts. At destruction, when the scope is exited,
 101  * the context is removed from the queue.
 102  *
 103  * The resulting "backtrace" can then be printed by calling the
 104  * PrintBT() function of an CTestFailureException.
 105  */
 106 class CContext
 107 {
 108 public:
 109         /** Adds a context with the specified information and description. */
 110         CContext(const wxChar* file, int line, const wxString& desc);
 111
 112         /** Removes the context addded by the constructor. */
 113         ~CContext();
 114 };
 115
 116
 117 //! Used to join the CContext instance name with the line-number.
 118 //! This is done to prevent shadowing.
 119 #define DO_CONTEXT(x, y, z) x y##z
 120
 121 //! Specifies the context of the current scope.
 122 #define CONTEXT(x) CContext wxCONCAT(context,__LINE__)(wxT(__FILE__), __LINE__, x)
 123
 124
 125 /**
 126  * This class disables assertions while it is in scope.
 127  */
 128 class CAssertOff
 129 {
 130 public:
 131         CAssertOff();
 132         ~CAssertOff();
 133 };
 134
 135
 136 /**
 137  * Test class containing all macros to do unit testing.
 138  * A test object represents a test that will be executed. Once it has been
 139  * executed, it reports all failures in the testPartResult linked list.
 140  *
 141  * A failure occurs when a test fails (condition is false).
 142  */
 143 class Test
 144 {
 145 public:
 146         /**
 147          * Main Test constructor. Used to create a test that will register itself
 148          * with TestRegistry and with its test case.
 149          * @param testCaseName Name of the test case this test belongs to
 150          * @param testName Name of this test
 151          */
 152         Test(const wxString& testCaseName, const wxString& testName);
 153
 154         /**
 155          * Main Test desctructor
 156          * Delete the testPartResult linked list. This is why the user should
 157          * only use the macro provided by muleunit to report a test result.
 158          */
 159         virtual ~Test();
 160
 161         /**
 162          * Fixtures that will be called after run().
 163          */
 164         virtual void tearDown();
 165
 166         /**
 167          * Fixtures that will be called before run().
 168          */
 169         virtual void setUp();
 170
 171         /**
 172          * Test code should be in this method.
 173          * run() will be called by the Test's TestCase, hence subclasses of Test
 174          * should override this method.
 175          */
 176         virtual void run();
 177
 178         /**
 179          * Get the name of the TestCase this test belongs to. The name of the
 180          * TestCase is the first parameter of the test declaration. For example,
 181          * if a test is declared as TEST(TESTCASE1, TEST1), this method will return
 182          * "TESTCASE1".
 183          *
 184          * @return The TestCase name of this test
 185          */
 186         const wxString& getTestCaseName() const;
 187
 188         /**
 189          * Get the name of this test. The name of the test is the second
 190          * parameter of the test declaration. For example,
 191          * if a test is declared as TEST(TESTCASE1, TEST1), this method will return
 192          * "TEST1".
 193          *
 194          * @return The name of this test.
 195          */
 196         const wxString& getTestName() const;
 197
 198         template <typename A, typename B>
 199         static void DoAssertEquals(const wxString& file, unsigned line, const A& a, const B& b)
 200         {
 201                 if (!(a == b)) {
 202                         wxString message = wxT("Expected '") + StringFrom(a) +
 203                                                                 wxT("' but got '") + StringFrom(b) + wxT("'");
 204
 205                         throw CTestFailureException(message, file, line);
 206                 }
 207         }
 208
 209 protected:
 210         wxString m_testCaseName;
 211         wxString m_testName;
 212         TestCase* m_testCase;
 213 };
 214
 215
 216 /**
 217  * Helperfunction that converts basic types to strings.
 218  */
 219 template <typename TYPE>
 220 wxString StringFrom(const TYPE& value)
 221 {
 222         return wxString() << value;
 223 }
 224
 225 inline wxString StringFrom(unsigned long long value)
 226 {
 227         return wxString::Format(wxT("%") wxLongLongFmtSpec wxT("u"), value);
 228 }
 229
 230 inline wxString StringFrom(signed long long value)
 231 {
 232         return wxString::Format(wxT("%") wxLongLongFmtSpec wxT("i"), value);
 233 }
 234
 235
 236 #define THROW_TEST_FAILURE(message) \
 237         throw CTestFailureException(message, wxT(__FILE__), __LINE__)
 238
 239
 240 /**
 241  * Asserts that a condition is true.
 242  * If the condition is not true, a failure is generated.
 243  * @param condition Condition to fullfill for the assertion to pass
 244  * @param message Message that will be displayed if this assertion fails
 245  */
 246 #define ASSERT_TRUE_M(condition, message) \
 247 { \
 248         if (!(condition)) { \
 249                 THROW_TEST_FAILURE(message); \
 250         } \
 251 }
 252
 253
 254 /**
 255  * Same as ASSERT_TRUE, but without an explicit message.
 256  */
 257 #define ASSERT_TRUE(condition) \
 258         ASSERT_TRUE_M(condition, wxString(wxT("Not true: ")) + wxT(#condition));
 259
 260
 261 /**
 262  * Same as ASSERT_TRUE, but without an explicit message and condition must be false.
 263  */
 264 #define ASSERT_FALSE(condition) \
 265         ASSERT_TRUE_M(!(condition), wxString(wxT("Not false: ")) + wxT(#condition));
 266
 267
 268 /**
 269  * Asserts that the two parameters are equals. Operator == must be defined.
 270  * If the two parameters are not equals, a failure is generated.
 271  * @param expected Expected value
 272  * @param actual Actual value to be compared
 273  * @param message Message that will be displayed if this assertion fails
 274  */
 275 #define ASSERT_EQUALS_M(expected,actual,message)\
 276 { \
 277         if (!(expected == actual)) { \
 278                 THROW_TEST_FAILURE(message); \
 279         } \
 280 }
 281
 282
 283 /**
 284  * Same as ASSERT_EQUALS_M, but without an explicit message.
 285  */
 286 #define ASSERT_EQUALS(expected, actual) \
 287         Test::DoAssertEquals(wxT(__FILE__), __LINE__, expected, actual)
 288
 289
 290 /**
 291  * Make a test fails with the given message.
 292  * @param text Failure message
 293  */
 294 #define FAIL_M(text) \
 295         THROW_TEST_FAILURE(text)
 296
 297 /**
 298  * Same as FAIL_M, but without an explicit message.
 299  */
 300 #define FAIL() FAIL_M(wxT("Test failed."))
 301
 302
 303 /**
 304  * Requires that an exception of a certain type is raised.
 305  */
 306 #define ASSERT_RAISES_M(type, call, message) \
 307         try { \
 308                 { call; }\
 309                 THROW_TEST_FAILURE(message); \
 310         } catch (const type&) { \
 311         } catch (const std::exception& e) { \
 312                 THROW_TEST_FAILURE(wxString::FromAscii(e.what())); \
 313         }
 314
 315
 316
 317 /**
 318  * Same as ASSERT_RAISES, but without an explicit message.
 319  */
 320 #define ASSERT_RAISES(type, call) \
 321         ASSERT_RAISES_M(type, (call), wxT("Exception of type ") wxT(#type) wxT(" not raised."))
 322
 323
 324
 325 /**
 326  * Define a test in a TestCase using test fixtures.
 327  * User should put his test code between brackets after using this macro.
 328  *
 329  * This macro should only be used if test fixtures were declared earlier in
 330  * this order: DECLARE, SETUP, TEARDOWN.
 331  * @param testCaseName TestCase name where the test belongs to. Should be
 332  * the same name of DECLARE, SETUP and TEARDOWN.
 333  * @param testName Unique test name.
 334  * @param testDisplayName This will be displayed when running the test.
 335  */
 336 #define TEST_M(testCaseName, testName, testDisplayName)                        \
 337     class testCaseName##testName##Test : public testCaseName##Declare##Test    \
 338     {                                                                          \
 339     public:                                                                    \
 340         testCaseName##testName##Test()                                         \
 341             : testCaseName##Declare##Test(wxT(#testCaseName), testDisplayName) \
 342         {                                                                      \
 343         }                                                                      \
 344                                                                                \
 345         void run();                                                            \
 346     } testCaseName##testName##Instance;                                        \
 347                                                                                \
 348     void testCaseName##testName##Test::run()
 349
 350 /**
 351  * Define a test in a TestCase using test fixtures.
 352  * User should put his test code between brackets after using this macro.
 353  *
 354  * This macro should only be used if test fixtures were declared earlier in
 355  * this order: DECLARE, SETUP, TEARDOWN.
 356  * @param testCaseName TestCase name where the test belongs to. Should be
 357  * the same name of DECLARE, SETUP and TEARDOWN.
 358  * @param testName Unique test name.
 359  */
 360 #define TEST(testCaseName, testName)    TEST_M(testCaseName, testName, wxT(#testName))
 361
 362 /**
 363  * Location to declare variables and objets.
 364  * This is where user should declare members accessible by TESTF,
 365  * SETUP and TEARDOWN.
 366  *
 367  * User should not use brackets after using this macro. User should
 368  * not initialize any members here.
 369  *
 370  * @param testCaseName TestCase name of the fixtures
 371  * @see END_DECLARE for more information.
 372  */
 373 #define DECLARE(testCaseName)\
 374         class testCaseName##Declare##Test : public Test \
 375         { \
 376         public: \
 377                 testCaseName##Declare##Test(const wxString& testCaseName, const wxString& testName) \
 378                         : Test (testCaseName, testName) {} \
 379                 virtual void run() = 0; \
 380
 381 /**
 382  * Ending macro used after DECLARE.
 383  *
 384  * User should use this macro after declaring members with
 385  * DECLARE macro.
 386  */
 387 #define END_DECLARE };
 388
 389
 390 /**
 391  * Macro for creating a fixture with no setup/teardown or member variables.
 392  */
 393 #define DECLARE_SIMPLE(testCaseName) \
 394         DECLARE(testCaseName) \
 395         END_DECLARE;
 396
 397 } // MuleUnit ns
 398 #endif // TEST_H
 399