Mercurial > hg > ucx / changeset

     1.1 --- a/test/test_buffer.cpp	Sun Apr 24 17:44:52 2022 +0200
     1.2 +++ b/test/test_buffer.cpp	Sun Apr 24 17:45:09 2022 +0200
     1.3 @@ -31,44 +31,214 @@
     1.4  #include <gtest/gtest.h>
     1.5  #include "util_allocator.h"
     1.6  
     1.7 -class Buffer : public ::testing::Test {
     1.8 -protected:
     1.9 -    void TearDown() override {
    1.10 -        EXPECT_TRUE(testingAllocator.verify());
    1.11 -    }
    1.12 -
    1.13 -    CxTestingAllocator testingAllocator;
    1.14 -};
    1.15 -
    1.16 -TEST_F(Buffer, WrapSpace) {
    1.17 +TEST(BufferInit, WrapSpace) {
    1.18 +    CxTestingAllocator alloc;
    1.19      CxBuffer buf;
    1.20 -    void *space = cxMalloc(&testingAllocator, 16);
    1.21 -    cxBufferInit(&buf, space, 16, &testingAllocator, CX_BUFFER_DEFAULT);
    1.22 +    void *space = cxMalloc(&alloc, 16);
    1.23 +    cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_DEFAULT);
    1.24      EXPECT_EQ(buf.space, space);
    1.25      EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);
    1.26      EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, 0);
    1.27      EXPECT_EQ(buf.pos, 0);
    1.28      EXPECT_EQ(buf.size, 0);
    1.29      EXPECT_EQ(buf.capacity, 16);
    1.30 -    EXPECT_EQ(buf.allocator, &testingAllocator);
    1.31 +    EXPECT_EQ(buf.allocator, &alloc);
    1.32      cxBufferDestroy(&buf);
    1.33 -    EXPECT_FALSE(testingAllocator.verify());
    1.34 -    cxFree(&testingAllocator, space);
    1.35 -    EXPECT_TRUE(testingAllocator.verify());
    1.36 +    EXPECT_FALSE(alloc.verify());
    1.37 +    cxFree(&alloc, space);
    1.38 +    EXPECT_TRUE(alloc.verify());
    1.39  }
    1.40  
    1.41 -TEST_F(Buffer, WrapSpaceAutoFree) {
    1.42 +TEST(BufferInit, WrapSpaceAutoFree) {
    1.43 +    CxTestingAllocator alloc;
    1.44      CxBuffer buf;
    1.45 -    void *space = cxMalloc(&testingAllocator, 16);
    1.46 -    cxBufferInit(&buf, space, 16, &testingAllocator, CX_BUFFER_FREE_CONTENTS);
    1.47 +    void *space = cxMalloc(&alloc, 16);
    1.48 +    cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_FREE_CONTENTS);
    1.49      EXPECT_EQ(buf.space, space);
    1.50      EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);
    1.51      EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS);
    1.52      EXPECT_EQ(buf.pos, 0);
    1.53      EXPECT_EQ(buf.size, 0);
    1.54      EXPECT_EQ(buf.capacity, 16);
    1.55 -    EXPECT_EQ(buf.allocator, &testingAllocator);
    1.56 -    EXPECT_FALSE(testingAllocator.verify());
    1.57 +    EXPECT_EQ(buf.allocator, &alloc);
    1.58 +    EXPECT_FALSE(alloc.verify());
    1.59      cxBufferDestroy(&buf);
    1.60 -    EXPECT_TRUE(testingAllocator.verify());
    1.61 +    EXPECT_TRUE(alloc.verify());
    1.62  }
    1.63 +
    1.64 +TEST(BufferInit, FreshSpace) {
    1.65 +    CxTestingAllocator alloc;
    1.66 +    CxBuffer buf;
    1.67 +    cxBufferInit(&buf, nullptr, 8, &alloc, CX_BUFFER_DEFAULT);
    1.68 +    EXPECT_NE(buf.space, nullptr);
    1.69 +    EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);
    1.70 +    EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS);
    1.71 +    EXPECT_EQ(buf.pos, 0);
    1.72 +    EXPECT_EQ(buf.size, 0);
    1.73 +    EXPECT_EQ(buf.capacity, 8);
    1.74 +    EXPECT_EQ(buf.allocator, &alloc);
    1.75 +    EXPECT_FALSE(alloc.verify()); // space is still allocated
    1.76 +    cxBufferDestroy(&buf);
    1.77 +    EXPECT_TRUE(alloc.verify());
    1.78 +}
    1.79 +
    1.80 +class BufferShiftFixture : public ::testing::Test {
    1.81 +protected:
    1.82 +    void SetUp() override {
    1.83 +        ASSERT_TRUE(alloc.verify());
    1.84 +        cxBufferInit(&buf, nullptr, 16, &alloc, CX_BUFFER_DEFAULT);
    1.85 +        memcpy(buf.space, "test____________", 16);
    1.86 +        buf.capacity = 8; // purposely pretend that the buffer has less capacity s.t. we can test beyond the range
    1.87 +        buf.pos = 4;
    1.88 +        buf.size = 4;
    1.89 +    }
    1.90 +
    1.91 +    void TearDown() override {
    1.92 +        cxBufferDestroy(&buf);
    1.93 +        EXPECT_TRUE(alloc.verify());
    1.94 +    }
    1.95 +
    1.96 +    CxTestingAllocator alloc;
    1.97 +    CxBuffer buf{};
    1.98 +};
    1.99 +
   1.100 +class BufferShiftLeft : public BufferShiftFixture {
   1.101 +};
   1.102 +
   1.103 +TEST_F(BufferShiftLeft, Zero) {
   1.104 +    ASSERT_EQ(buf.pos, 4);
   1.105 +    ASSERT_EQ(buf.size, 4);
   1.106 +    int ret = cxBufferShiftLeft(&buf, 0);
   1.107 +    EXPECT_EQ(ret, 0);
   1.108 +    EXPECT_EQ(buf.pos, 4);
   1.109 +    EXPECT_EQ(buf.size, 4);
   1.110 +    EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
   1.111 +}
   1.112 +
   1.113 +TEST_F(BufferShiftLeft, Standard) {
   1.114 +    ASSERT_EQ(buf.pos, 4);
   1.115 +    ASSERT_EQ(buf.size, 4);
   1.116 +    int ret = cxBufferShiftLeft(&buf, 2);
   1.117 +    EXPECT_EQ(ret, 0);
   1.118 +    EXPECT_EQ(buf.pos, 2);
   1.119 +    EXPECT_EQ(buf.size, 2);
   1.120 +    EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0);
   1.121 +}
   1.122 +
   1.123 +TEST_F(BufferShiftLeft, Overshift) {
   1.124 +    ASSERT_LT(buf.pos, 6);
   1.125 +    ASSERT_LT(buf.size, 6);
   1.126 +    int ret = cxBufferShiftLeft(&buf, 6);
   1.127 +    EXPECT_EQ(ret, 0);
   1.128 +    EXPECT_EQ(buf.pos, 0);
   1.129 +    EXPECT_EQ(buf.size, 0);
   1.130 +    EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
   1.131 +}
   1.132 +
   1.133 +TEST_F(BufferShiftLeft, OvershiftPosOnly) {
   1.134 +    buf.pos = 2;
   1.135 +    ASSERT_EQ(buf.size, 4);
   1.136 +    int ret = cxBufferShiftLeft(&buf, 3);
   1.137 +    EXPECT_EQ(ret, 0);
   1.138 +    EXPECT_EQ(buf.pos, 0);
   1.139 +    EXPECT_EQ(buf.size, 1);
   1.140 +    EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
   1.141 +}
   1.142 +
   1.143 +TEST_F(BufferShiftLeft, OffsetInterface) {
   1.144 +    buf.pos = 3;
   1.145 +    ASSERT_EQ(buf.size, 4);
   1.146 +    int ret = cxBufferShift(&buf, -2);
   1.147 +    EXPECT_EQ(ret, 0);
   1.148 +    EXPECT_EQ(buf.pos, 1);
   1.149 +    EXPECT_EQ(buf.size, 2);
   1.150 +    EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0);
   1.151 +}
   1.152 +
   1.153 +class BufferShiftRight : public BufferShiftFixture {
   1.154 +};
   1.155 +
   1.156 +TEST_F(BufferShiftRight, Zero) {
   1.157 +    ASSERT_EQ(buf.pos, 4);
   1.158 +    ASSERT_EQ(buf.size, 4);
   1.159 +    int ret = cxBufferShiftRight(&buf, 0);
   1.160 +    EXPECT_EQ(ret, 0);
   1.161 +    EXPECT_EQ(buf.pos, 4);
   1.162 +    EXPECT_EQ(buf.size, 4);
   1.163 +    EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);
   1.164 +}
   1.165 +
   1.166 +TEST_F(BufferShiftRight, Standard) {
   1.167 +    ASSERT_EQ(buf.pos, 4);
   1.168 +    ASSERT_EQ(buf.size, 4);
   1.169 +    int ret = cxBufferShiftRight(&buf, 3);
   1.170 +    EXPECT_EQ(ret, 0);
   1.171 +    EXPECT_EQ(buf.pos, 7);
   1.172 +    EXPECT_EQ(buf.size, 7);
   1.173 +    EXPECT_TRUE(memcmp(buf.space, "testest_____", 8) == 0);
   1.174 +}
   1.175 +
   1.176 +TEST_F(BufferShiftRight, OvershiftDiscard) {
   1.177 +    ASSERT_EQ(buf.pos, 4);
   1.178 +    ASSERT_EQ(buf.size, 4);
   1.179 +    ASSERT_EQ(buf.capacity, 8);
   1.180 +    int ret = cxBufferShiftRight(&buf, 6);
   1.181 +    EXPECT_EQ(ret, 0);
   1.182 +    EXPECT_EQ(buf.pos, 8);
   1.183 +    EXPECT_EQ(buf.size, 8);
   1.184 +    EXPECT_EQ(buf.capacity, 8);
   1.185 +    EXPECT_TRUE(memcmp(buf.space, "test__te____", 8) == 0);
   1.186 +}
   1.187 +
   1.188 +TEST_F(BufferShiftRight, OvershiftExtend) {
   1.189 +    ASSERT_EQ(buf.pos, 4);
   1.190 +    ASSERT_EQ(buf.size, 4);
   1.191 +    ASSERT_EQ(buf.capacity, 8);
   1.192 +    buf.flags |= CX_BUFFER_AUTO_EXTEND;
   1.193 +    int ret = cxBufferShiftRight(&buf, 6);
   1.194 +    EXPECT_EQ(ret, 0);
   1.195 +    EXPECT_EQ(buf.pos, 10);
   1.196 +    EXPECT_EQ(buf.size, 10);
   1.197 +    EXPECT_GE(buf.capacity, 10);
   1.198 +    EXPECT_TRUE(memcmp(buf.space, "test__test__", 8) == 0);
   1.199 +}
   1.200 +
   1.201 +TEST_F(BufferShiftRight, OffsetInterface) {
   1.202 +    buf.pos = 3;
   1.203 +    ASSERT_EQ(buf.size, 4);
   1.204 +    int ret = cxBufferShift(&buf, 2);
   1.205 +    EXPECT_EQ(ret, 0);
   1.206 +    EXPECT_EQ(buf.pos, 5);
   1.207 +    EXPECT_EQ(buf.size, 6);
   1.208 +    EXPECT_TRUE(memcmp(buf.space, "tetest______", 8) == 0);
   1.209 +}
   1.210 +
   1.211 +TEST(BufferMinimumCapacity, Sufficient) {
   1.212 +    CxTestingAllocator alloc;
   1.213 +    auto space = cxMalloc(&alloc, 8);
   1.214 +    CxBuffer buf;
   1.215 +    cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS);
   1.216 +    memcpy(space, "Testing", 8);
   1.217 +    buf.size = 8;
   1.218 +    cxBufferMinimumCapacity(&buf, 6);
   1.219 +    EXPECT_EQ(buf.capacity, 8);
   1.220 +    EXPECT_EQ(buf.size, 8);
   1.221 +    EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0);
   1.222 +    cxBufferDestroy(&buf);
   1.223 +    EXPECT_TRUE(alloc.verify());
   1.224 +}
   1.225 +
   1.226 +TEST(BufferMinimumCapacity, Extend) {
   1.227 +    CxTestingAllocator alloc;
   1.228 +    auto space = cxMalloc(&alloc, 8);
   1.229 +    CxBuffer buf;
   1.230 +    cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS); // NO auto extend!
   1.231 +    memcpy(space, "Testing", 8);
   1.232 +    buf.size = 8;
   1.233 +    cxBufferMinimumCapacity(&buf, 16);
   1.234 +    EXPECT_EQ(buf.capacity, 16);
   1.235 +    EXPECT_EQ(buf.size, 8);
   1.236 +    EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0);
   1.237 +    cxBufferDestroy(&buf);
   1.238 +    EXPECT_TRUE(alloc.verify());
   1.239 +}