tests/src/TestUtility.cxx

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