tests/src/UsageExamples.cxx

   1 /**
   2  * Shows how this framework is supposed to be used.
   3  */
   4
   5 // Needed for the tests in this file, not part of the
   6 // examples.
   7 #include <tests/src/UsageExamples.hxx>
   8 #include <sstream>
   9
  10 // Usage examples begin now.
  11
  12 // This is the way to _declare_ an exception class.
  13 // --- Start MyException.hxx ---
  14
  15 #ifndef MYEXCEPTION_HXX
  16 #define MYEXCEPTION_HXX
  17
  18 // Remember to adjust include path.
  19 #include <source/declare.hxx>
  20 #include <source/Exception.hxx>
  21
  22 // MyException inherits from libsex::Exception.
  23 LIBSEX_DECLARE(libsex::Exception, MyException)
  24
  25 #endif
  26
  27 // --- End MyException.hxx ---
  28
  29
  30
  31 // This is the way to _define_ an exception class.
  32 // --- Start MyException.cxx ---
  33
  34 #include <source/define.hxx>
  35 #include <source/Exception.hxx>
  36 // Remember to include the header file (MyException.hxx)!
  37
  38 // Define MyException and provide a message template (see
  39 // printf for a list and explanation of placeholders).
  40
  41 // If you want to localize your exceptions, you just have
  42 // to localize the following line.
  43
  44 LIBSEX_DEFINE(libsex::Exception, MyException, "%s is %d")
  45
  46 // --- End MyException.cxx ---
  47
  48
  49
  50 // Lets create an exception with a fixed message:
  51 LIBSEX_DECLARE(libsex::Exception, Error)
  52 LIBSEX_DEFINE(libsex::Exception, Error, "Error!")
  53
  54
  55 #include <source/throw.hxx> // THROW and CHAIN
  56
  57 /**
  58  * How to simply create an exception.
  59  */
  60 void UsageExamples::testSimpleConstruction()
  61 {
  62         // The error message.
  63         std::string msg("Someone has set us up the bomb!");
  64
  65         // Create an exception, do not throw it. Note we
  66         // can pass an arbitrary string as message --
  67         // the Exception subsystem itself does not depend
  68         // on message templates.
  69         MyException e(msg.c_str());
  70
  71         // Turn description into an instance of std::string
  72         // (needed for comparing).
  73         std::string what(e.what());
  74
  75
  76
  77         CPPUNIT_ASSERT_EQUAL(msg, what);
  78 }
  79
  80 /**
  81  * How to throw a single exception without placeholders in
  82  * its message template.
  83  */
  84 void UsageExamples::testSimpleThrowing()
  85 {
  86         bool success = false;
  87
  88         try {
  89                 // Create an instance and throw it. Note
  90                 // that THROW uses the message template, so
  91                 // we can not pass an arbitrary string.
  92                 // Since Error's message template does not
  93                 // expect any arguments, we can use
  94                 // THROW_ARGLESS.
  95                 THROW_ARGLESS(Error);
  96         } catch (Error& e) {
  97                 // Check whether result is as expected.
  98
  99                 std::string exp(__FILE__); exp += ":95: Error!";
 100                 std::string act(e.what());
 101
 102                 CPPUNIT_ASSERT_EQUAL(exp, act);
 103                 success = true;
 104         }
 105
 106         CPPUNIT_ASSERT(success);
 107 }
 108
 109 /**
 110  * How to throw a single exception.
 111  */
 112 void UsageExamples::testThrowing()
 113 {
 114         bool success = false;
 115
 116         try {
 117                 // Fill the parameters into the message
 118                 // template and throw an exception
 119                 // containing the resulting string.
 120                 THROW(MyException, "foobar", 42);
 121         } catch (MyException& e) {
 122                 // Check whether result is as expected.
 123
 124                 std::string exp(__FILE__); exp += ":120: foobar is 42";
 125                 std::string act(e.what());
 126
 127                 CPPUNIT_ASSERT_EQUAL(exp, act);
 128                 success = true;
 129         }
 130
 131         CPPUNIT_ASSERT(success);
 132 }
 133
 134 /**
 135  * How to chain exceptions.
 136  */
 137 void UsageExamples::testChaining()
 138 {
 139         bool success = false;
 140
 141         try {
 142                 try {
 143                         THROW(MyException, "foo", 21);
 144                 } catch (MyException& e) {
 145                         // Note that CHAIN expects the
 146                         // variable name of the previous
 147                         // exception to be "e"!
 148                         CHAIN(MyException, "bar", 42);
 149                 }
 150         } catch (MyException& e) {
 151                 // Check whether result is as expected.
 152
 153                 std::string exp(__FILE__);
 154                 exp += ":148: bar is 42\n";
 155                 exp += __FILE__;
 156                 exp += ":143: foo is 21";
 157
 158                 std::stringstream act;
 159                 e.backtrace(act);
 160
 161                 CPPUNIT_ASSERT_EQUAL(
 162                         exp,
 163                         act.str());
 164
 165                 success = true;
 166         }
 167
 168         CPPUNIT_ASSERT(success);
 169 }