tests/UsageExamples.cxx

   1 /**
   2  * @file
   3  *
   4  * Shows how this framework is supposed to be used.
   5  */
   6
   7 // Needed for the tests in this file, not part of the examples.
   8 #include <tests/UsageExamples.hxx>
   9 #include <sstream>
  10
  11 // Usage examples begin now.
  12
  13 #include <source/throw.hxx>
  14 #include <tests/framework/ExampleException1.hxx>
  15 #include <tests/framework/ExampleException2.hxx>
  16
  17 /**
  18  * How to simply create an exception.
  19  */
  20 void tests::UsageExamples::testSimpleConstruction()
  21 {
  22         // The error message.
  23         std::string msg("Someone has set us up the bomb!");
  24
  25         // Create an exception, do not throw it. Note we
  26         // can pass an arbitrary string as message --
  27         // the Exception subsystem itself does not depend
  28         // on message templates.
  29         ExampleException2 e(msg.c_str());
  30
  31         // Turn description into an instance of std::string
  32         // (needed for comparing).
  33         std::string what(e.what());
  34
  35
  36
  37         CPPUNIT_ASSERT_EQUAL(msg, what);
  38 }
  39
  40 /**
  41  * How to throw a single exception without placeholders in
  42  * its message template.
  43  */
  44 void tests::UsageExamples::testSimpleThrowing()
  45 {
  46         bool success = false;
  47
  48         try {
  49                 // Create an instance and throw it. Note
  50                 // that THROW uses the message template, so
  51                 // we can not pass an arbitrary string.
  52                 // Since ExampleException1's message
  53                 // template does not expect any arguments,
  54                 // we can use THROW_ARGLESS.
  55                 THROW_ARGLESS(ExampleException1);
  56         } catch (ExampleException1& e) {
  57                 // Check whether result is as expected.
  58
  59                 std::string exp(__FILE__);
  60                 exp += ":55: Error!";
  61                 std::string act(e.what());
  62
  63                 CPPUNIT_ASSERT_EQUAL(exp, act);
  64                 success = true;
  65         }
  66
  67         CPPUNIT_ASSERT(success);
  68 }
  69
  70 /**
  71  * How to throw a single exception.
  72  */
  73 void tests::UsageExamples::testThrowing()
  74 {
  75         bool success = false;
  76
  77         try {
  78                 // Fill the parameters into the message
  79                 // template and throw an exception
  80                 // containing the resulting string.
  81                 THROW(ExampleException2, "foobar", 42);
  82         } catch (ExampleException2& e) {
  83                 // Check whether result is as expected.
  84
  85                 std::string exp(__FILE__);
  86                 exp += ":81: foobar is 42";
  87                 std::string act(e.what());
  88
  89                 CPPUNIT_ASSERT_EQUAL(exp, act);
  90                 success = true;
  91         }
  92
  93         CPPUNIT_ASSERT(success);
  94 }
  95
  96 /**
  97  * How to chain exceptions.
  98  */
  99 void tests::UsageExamples::testChaining()
 100 {
 101         bool success = false;
 102
 103         try {
 104                 try {
 105                         THROW(ExampleException2, "foo", 21);
 106                 } catch (ExampleException2& e) {
 107                         // Note that CHAIN expects the
 108                         // variable name of the previous
 109                         // exception to be "e"!
 110                         CHAIN(ExampleException2, "bar", 42);
 111                 }
 112         } catch (ExampleException2& e) {
 113                 // Check whether result is as expected.
 114
 115                 std::string exp(__FILE__);
 116                 exp += ":110: bar is 42\n";
 117                 exp += __FILE__;
 118                 exp += ":105: foo is 21";
 119
 120                 std::stringstream act;
 121                 e.backtrace(act);
 122
 123                 CPPUNIT_ASSERT_EQUAL(
 124                         exp,
 125                         act.str());
 126
 127                 success = true;
 128         }
 129
 130         CPPUNIT_ASSERT(success);
 131 }