src/lib/support/tests/TestBufferWriter.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2020-2021 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17 #include <support/BufferWriter.h>
  18 #include <support/UnitTestRegistration.h>
  19
  20 #include <nlunit-test.h>
  21
  22 namespace {
  23
  24 template <class Base>
  25 class BWTest : public Base
  26 {
  27 public:
  28     static constexpr size_t kLen    = 64;
  29     static constexpr uint8_t kGuard = 0xfe;
  30
  31     uint8_t mBuf[kLen];
  32     size_t mLen;
  33
  34     BWTest(size_t len) : Base(mBuf + 1, len), mLen(len) { memset(mBuf, kGuard, kLen); }
  35
  36     bool expect(const void * val, size_t needed, size_t available)
  37     {
  38         // check guards
  39         for (size_t i = mLen + 1; i < sizeof(mBuf); i++)
  40         {
  41             if (mBuf[i] != kGuard)
  42             {
  43                 printf("Guards failure at index %d\n", static_cast<int>(i));
  44                 return false;
  45             }
  46         }
  47         if (mBuf[0] != kGuard)
  48         {
  49             printf("Guards failure at index 0: buffer underflow\n");
  50             return false;
  51         }
  52
  53         size_t written = 0xcafebabe;
  54         bool fit       = Base::Fit(written);
  55         if (written == 0xcafebabe)
  56         {
  57             printf("Fit(written) didn't set written\n");
  58             return false;
  59         }
  60         if ((fit && (mLen < needed || written != needed)) || (!fit && (mLen >= needed || written != mLen)))
  61         {
  62             printf("Fit(written) is wrong: mLen == %zu, needed == %zu, written == %zu, Fit() == %s\n", mLen, needed, written,
  63                    fit ? "true" : "false");
  64             return false;
  65         }
  66
  67         // check everything else
  68         if (memcmp(mBuf + 1, val, needed < mLen ? needed : mLen) != 0)
  69         {
  70             printf("Memory comparison failed.\n");
  71             return false;
  72         }
  73
  74         return Base::Available() == available && Base::Needed() == needed;
  75     }
  76 };
  77
  78 using namespace chip::Encoding;
  79
  80 void TestStringWrite(nlTestSuite * inSuite, void * inContext)
  81 {
  82     {
  83         BWTest<BufferWriter> bb(2);
  84         bb.Put("hi");
  85         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
  86     }
  87     {
  88         BWTest<BufferWriter> bb(1);
  89         bb.Put("hi");
  90         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
  91     }
  92
  93     {
  94         BWTest<LittleEndian::BufferWriter> bb(2);
  95         bb.Put("hi");
  96         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
  97     }
  98     {
  99         BWTest<LittleEndian::BufferWriter> bb(1);
 100         bb.Put("hi");
 101         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 102     }
 103
 104     {
 105         BWTest<BigEndian::BufferWriter> bb(2);
 106         bb.Put("hi");
 107         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 108     }
 109     {
 110         BWTest<BigEndian::BufferWriter> bb(1);
 111         bb.Put("hi");
 112         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 113     }
 114 }
 115
 116 void TestBufferWrite(nlTestSuite * inSuite, void * inContext)
 117 {
 118     {
 119         BWTest<BufferWriter> bb(2);
 120         bb.Put("hithere", 2);
 121         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 122     }
 123     {
 124         BWTest<BufferWriter> bb(1);
 125         bb.Put("hithere", 2);
 126         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 127     }
 128
 129     {
 130         BWTest<LittleEndian::BufferWriter> bb(2);
 131         bb.Put("hithere", 2);
 132         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 133     }
 134     {
 135         BWTest<LittleEndian::BufferWriter> bb(1);
 136         bb.Put("hithere", 2);
 137         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 138     }
 139
 140     {
 141         BWTest<BigEndian::BufferWriter> bb(2);
 142         bb.Put("hithere", 2);
 143         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 144     }
 145     {
 146         BWTest<BigEndian::BufferWriter> bb(1);
 147         bb.Put("hithere", 2);
 148         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 149     }
 150 }
 151
 152 void TestPutLittleEndian(nlTestSuite * inSuite, void * inContext)
 153 {
 154     {
 155         BWTest<LittleEndian::BufferWriter> bb(2);
 156         bb.Put16('h' + 'i' * 256);
 157         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 158     }
 159     {
 160         BWTest<LittleEndian::BufferWriter> bb(4);
 161         bb.Put32(0x01020304);
 162         NL_TEST_ASSERT(inSuite, bb.expect("\x04\x03\x02\x01", 4, 0));
 163     }
 164
 165     {
 166         BWTest<LittleEndian::BufferWriter> bb(8);
 167         bb.Put64(0x0102030405060708);
 168         NL_TEST_ASSERT(inSuite, bb.expect("\x08\x07\x06\x05\x04\x03\x02\x01", 8, 0));
 169     }
 170
 171     {
 172         BWTest<LittleEndian::BufferWriter> bb(3);
 173         bb.EndianPut(0x0102030405060708u, 3);
 174         NL_TEST_ASSERT(inSuite, bb.expect("\x08\x07\x06", 3, 0));
 175     }
 176 }
 177
 178 void TestPutBigEndian(nlTestSuite * inSuite, void * inContext)
 179 {
 180     {
 181         BWTest<BigEndian::BufferWriter> bb(2);
 182         bb.Put16('i' + 'h' * 256);
 183         NL_TEST_ASSERT(inSuite, bb.expect("hi", 2, 0));
 184     }
 185
 186     {
 187         BWTest<BigEndian::BufferWriter> bb(4);
 188         bb.Put32(0x01020304);
 189         NL_TEST_ASSERT(inSuite, bb.expect("\x01\x02\x03\x04", 4, 0));
 190     }
 191
 192     {
 193         BWTest<BigEndian::BufferWriter> bb(8);
 194         bb.Put64(0x0102030405060708);
 195         NL_TEST_ASSERT(inSuite, bb.expect("\x01\x02\x03\x04\x05\x06\x07\x08", 8, 0));
 196     }
 197
 198     {
 199         BWTest<BigEndian::BufferWriter> bb(3);
 200         bb.EndianPut(0x0102030405060708u, 3);
 201         NL_TEST_ASSERT(inSuite, bb.expect("\x06\x07\x08", 3, 0));
 202     }
 203 }
 204
 205 const nlTest sTests[] = {
 206     NL_TEST_DEF("TestStringWrite", TestStringWrite),         //
 207     NL_TEST_DEF("TestBufferWrite", TestBufferWrite),         //
 208     NL_TEST_DEF("TestPutLittleEndian", TestPutLittleEndian), //
 209     NL_TEST_DEF("TestPutBigEndian", TestPutBigEndian),       //
 210     NL_TEST_SENTINEL()                                       //
 211 };
 212
 213 } // namespace
 214
 215 int TestBufferWriter(void)
 216 {
 217     nlTestSuite theSuite = { "BufferWriter", sTests, nullptr, nullptr };
 218     nlTestRunner(&theSuite, nullptr);
 219     return nlTestRunnerStats(&theSuite);
 220 }
 221
 222 CHIP_REGISTER_TEST_SUITE(TestBufferWriter)