tests/src/TestException.cxx

   1 #include <tests/src/TestException.hxx>
   2 #include <tests/framework/CountingException.hxx>
   3 #include <tests/framework/UncloneableException.hxx>
   4
   5 #include <cstring>
   6 #include <sstream>
   7
   8 void TestException::testCopyingOfShortMessage()
   9 {
  10         char* const cstr = new char[80];
  11         strcpy(cstr, "TEST0001");
  12         libsex::Exception e(cstr);
  13         delete cstr;
  14
  15         std::string exp("TEST0001");
  16         std::string act(e.what());
  17         CPPUNIT_ASSERT_EQUAL(exp, act);
  18 }
  19
  20 void TestException::testWhetherLongMessageDoesNotOverflow()
  21 {
  22         size_t length = libsex::Exception::LENGTH;
  23         std::string str;
  24
  25         for (int i = 0; i < length; ++i) {
  26                 str += '.';
  27         }
  28         str += '!';
  29
  30         libsex::Exception e(str.c_str());
  31
  32         CPPUNIT_ASSERT_EQUAL(length, strlen(e.what()));
  33
  34         for (int i = 0; i < length; ++i) {
  35                 CPPUNIT_ASSERT_EQUAL('.', e.what()[i]);
  36         }
  37 }
  38
  39 void TestException::testWhetherPreviousExceptionIsCloned()
  40 {
  41         CPPUNIT_ASSERT_EQUAL(0, CountingException::instances);
  42         CountingException e1("e1");
  43         CPPUNIT_ASSERT_EQUAL(1, CountingException::instances);
  44         libsex::Exception e2("e2", e1);
  45         CPPUNIT_ASSERT_EQUAL(2, CountingException::instances);
  46 }
  47
  48 void TestException::testWhetherClonedExceptionIsDeleted()
  49 {
  50         CPPUNIT_ASSERT_EQUAL(0, CountingException::instances);
  51
  52         CountingException e1("e1");
  53         CPPUNIT_ASSERT_EQUAL(1, CountingException::instances);
  54         {
  55                 libsex::Exception e2("e2", e1);
  56                 CPPUNIT_ASSERT_EQUAL(2, CountingException::instances);
  57         }
  58         CPPUNIT_ASSERT_EQUAL(1, CountingException::instances);
  59 }
  60
  61 void TestException::testWhetherBadAllocOnCloneIsSwallowed()
  62 {
  63         UncloneableException e1;
  64         libsex::Exception e2("e2", e1);
  65 }
  66
  67 void TestException::testWhetherNoticeIsAppendedOnBadAlloc()
  68 {
  69         UncloneableException e1;
  70         libsex::Exception e2("e2", e1);
  71
  72         std::string exp
  73                 = "e2\nDOUBLE FAULT! "
  74                   "Caught std::bad_alloc in constructor "
  75                   "of an exception.";
  76         std::string act = e2.what();
  77         CPPUNIT_ASSERT_EQUAL(exp, act);
  78 }
  79
  80 void TestException::testWhetherNoticeDoesNotOverflowIfBufferTooSmall()
  81 {
  82         size_t length = libsex::Exception::LENGTH;
  83         std::string str;
  84
  85         for (int i = 0; i < length; ++i) {
  86                 str += '.';
  87         }
  88
  89         UncloneableException e1;
  90         libsex::Exception e2(str.c_str(), e1);
  91
  92         CPPUNIT_ASSERT_EQUAL(length, strlen(e2.what()));
  93         CPPUNIT_ASSERT_EQUAL(str, std::string(e2.what()));
  94 }
  95
  96 void TestException::testWritingToStream()
  97 {
  98         std::string exp("TestException");
  99         libsex::Exception e(exp.c_str());
 100
 101         std::stringstream act;
 102         e.write(act);
 103
 104         CPPUNIT_ASSERT_EQUAL(exp, act.str());
 105 }
 106
 107 void TestException::testBacktrace()
 108 {
 109         libsex::Exception cause("Failed to foo.");
 110         libsex::Exception e("Failed to bar.", cause);
 111
 112         std::stringstream act;
 113         e.backtrace(act);
 114
 115         CPPUNIT_ASSERT_EQUAL(
 116                 std::string("Failed to bar.\nFailed to foo."),
 117                 act.str());
 118 }