tests/Exception.cxx

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