tests/src/TestUtility.cxx

   1 #include <tests/src/TestUtility.hxx>
   2 #include <tests/framework/MockException.hxx>
   3
   4 #include <source/utility.hxx>
   5
   6 #include <sstream>
   7
   8 void TestUtility::testShortTemplateWithoutFormatting()
   9 {
  10         char buf[100] = { 0 };
  11
  12         CPPUNIT_ASSERT(
  13                 libsex::format(
  14                         buf, 100,
  15                         "foobar.cxx", 42,
  16                         "Message template."));
  17
  18         std::string exp("foobar.cxx:42: Message template.");
  19         CPPUNIT_ASSERT_EQUAL(exp, std::string(buf));
  20 }
  21
  22 void TestUtility::testWhetherFalseIsReturnedWhenHeaderFillsBuffer()
  23 {
  24         char buf[100] = { 0 };
  25
  26         CPPUNIT_ASSERT(
  27                 !libsex::format(
  28                         buf, 16,
  29                         "foobar.cxx", 42,
  30                         "Message template."));
  31
  32         std::string exp("foobar.cxx:42: ");
  33         CPPUNIT_ASSERT_EQUAL(exp, std::string(buf));
  34 }
  35
  36 void TestUtility::testWhetherTrueIsReturnedOnExactFit()
  37 {
  38         char buf[100] = { 0 };
  39
  40         CPPUNIT_ASSERT(
  41                 libsex::format(
  42                         buf, 33,
  43                         "foobar.cxx", 42,
  44                         "Message template."));
  45
  46         std::string exp("foobar.cxx:42: Message template.");
  47         CPPUNIT_ASSERT_EQUAL(exp, std::string(buf));
  48 }
  49
  50 void TestUtility::testWhetherUnformattedOverflowsArePrevented()
  51 {
  52         // Array should be large enough to not really get
  53         // overwritten. Just adjust the parameter 'length'
  54         // to libsex::format().
  55         char buf[100] = { 0 };
  56
  57         CPPUNIT_ASSERT(
  58                 !libsex::format(
  59                         buf, 10,
  60                         "foobar.cxx", 42,
  61                         "Message template."));
  62
  63         assertBoundary(buf, 10, 100);
  64 }
  65
  66 void TestUtility::testWhetherSimpleFormattingWorks()
  67 {
  68         char buf[100] = { 0 };
  69
  70         CPPUNIT_ASSERT(
  71                 libsex::format(
  72                         buf, 100,
  73                         "foobar.cxx", 42,
  74                         "String: '%s'.", "STRING"));
  75
  76         std::string exp("foobar.cxx:42: String: 'STRING'.");
  77         CPPUNIT_ASSERT_EQUAL(exp, std::string(buf));
  78 }
  79
  80 void TestUtility::testWhetherFormattedOverflowsArePreventedBeforeFormatstring()
  81 {
  82         // Array should be large enough to not really get
  83         // overwritten. Just adjust the parameter 'length'
  84         // to libsex::format().
  85         char buf[100] = { 0 };
  86
  87         CPPUNIT_ASSERT(
  88                 !libsex::format(
  89                         buf, 10,
  90                         "foobar.cxx", 42,
  91                         "String: '%s'.", "STRING"));
  92
  93         assertBoundary(buf, 10, 100);
  94 }
  95
  96 void TestUtility::testWhetherFormattedOverflowsArePreventedInFormatstring()
  97 {
  98         // Array should be large enough to not really get
  99         // overwritten. Just adjust the parameter 'length'
 100         // to libsex::format().
 101         char buf[100] = { 0 };
 102
 103         CPPUNIT_ASSERT(
 104                 !libsex::format(
 105                         buf, 28,
 106                         "foobar.cxx", 42,
 107                         "String: '%s'.", "STRING"));
 108
 109         assertBoundary(buf, 28, 100);
 110 }
 111
 112 void TestUtility::testMultipleFormatParameters()
 113 {
 114         char buf[100] = { 0 };
 115
 116         CPPUNIT_ASSERT(
 117                 libsex::format(
 118                         buf, 100,
 119                         "foobar.cxx", 42,
 120                         "%s=%d", "var", 42));
 121
 122         std::string exp("foobar.cxx:42: var=42");
 123         CPPUNIT_ASSERT_EQUAL(exp, std::string(buf));
 124 }
 125
 126 void TestUtility::testWhetherMultipleParametersDontOverflowBeforeFormatstring()
 127 {
 128         char buf[100] = { 0 };
 129
 130         CPPUNIT_ASSERT(
 131                 !libsex::format(
 132                         buf, 10,
 133                         "foobar.cxx", 42,
 134                         "%s=%d", "var", 42));
 135
 136         assertBoundary(buf, 10, 100);
 137 }
 138
 139 void TestUtility::testWhetherMultipleParametersDontOverflowInFormatstring()
 140 {
 141         char buf[100] = { 0 };
 142
 143         CPPUNIT_ASSERT(
 144                 !libsex::format(
 145                         buf, 18,
 146                         "foobar.cxx", 42,
 147                         "%s=%d", "var", 42));
 148
 149         assertBoundary(buf, 18, 100);
 150 }
 151
 152 void TestUtility::testTemplateFactory()
 153 {
 154         MockException e
 155                 = libsex::formatted<MockException>(
 156                         "foobar.cxx", 42,
 157                         "VAR", 42);
 158
 159         CPPUNIT_ASSERT_EQUAL(
 160                 std::string("foobar.cxx:42: VAR=42"),
 161                 std::string(e.what()));
 162 }
 163
 164 void TestUtility::testChainedTemplateFactory()
 165 {
 166         MockException e1
 167                 = libsex::formatted<MockException>(
 168                         "foobar.cxx", 42,
 169                         "VAR", 42);
 170
 171         MockException e = libsex::formatted<MockException>(
 172                 e1,
 173                 "foobar.cxx", 84,
 174                 "#exceptions", 1);
 175
 176         std::stringstream act;
 177         e.backtrace(act);
 178
 179         CPPUNIT_ASSERT_EQUAL(
 180                 std::string("foobar.cxx:84: #exceptions=1\n"
 181                             "foobar.cxx:42: VAR=42"),
 182                 act.str());
 183 }
 184
 185 void TestUtility::assertBoundary(
 186         const char* const buffer,
 187         size_t boundary,
 188         size_t length)
 189 {
 190         for (size_t i = boundary; i < length; ++i) {
 191                 CPPUNIT_ASSERT_EQUAL('\0', buffer[i]);
 192         }
 193 }