Mercurial > hg > ucx / changeset

     1.1 --- a/tests/test_buffer.c	Tue Jan 02 23:31:00 2024 +0100
     1.2 +++ b/tests/test_buffer.c	Wed Jan 03 22:17:40 2024 +0100
     1.3 @@ -389,6 +389,202 @@
     1.4      cxBufferDestroy(&buf);
     1.5  }
     1.6  
     1.7 +CX_TEST(test_buffer_eof_reached) {
     1.8 +    CxBuffer buf;
     1.9 +    cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
    1.10 +    buf.size = buf.pos = 3;
    1.11 +    CX_TEST_DO {
    1.12 +        CX_TEST_ASSERT(cxBufferEof(&buf));
    1.13 +        buf.pos = buf.size - 1;
    1.14 +        CX_TEST_ASSERT(!cxBufferEof(&buf));
    1.15 +        cxBufferPut(&buf, 'a');
    1.16 +        CX_TEST_ASSERT(cxBufferEof(&buf));
    1.17 +    }
    1.18 +    cxBufferDestroy(&buf);
    1.19 +}
    1.20 +
    1.21 +CX_TEST(test_buffer_eof_not_reached) {
    1.22 +    CxBuffer buf;
    1.23 +    cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
    1.24 +    buf.size = 6;
    1.25 +    CX_TEST_DO {
    1.26 +        buf.pos = buf.size - 1;
    1.27 +        CX_TEST_ASSERT(!cxBufferEof(&buf));
    1.28 +        buf.pos = 0;
    1.29 +        cxBufferWrite("test", 1, 5, &buf);
    1.30 +        CX_TEST_ASSERT(!cxBufferEof(&buf));
    1.31 +    }
    1.32 +    cxBufferDestroy(&buf);
    1.33 +}
    1.34 +
    1.35 +#define TEST_BUFFER_SHIFT_SETUP(buf) \
    1.36 +    CxTestingAllocator talloc; \
    1.37 +    cx_testing_allocator_init(&talloc); \
    1.38 +    CxAllocator *alloc = &talloc.base; \
    1.39 +    CxBuffer buf; \
    1.40 +    cxBufferInit(&buf, NULL, 16, alloc, CX_BUFFER_DEFAULT); \
    1.41 +    memcpy(buf.space, "test____XXXXXXXX", 16); \
    1.42 +    buf.capacity = 8; \
    1.43 +    buf.pos = 4; \
    1.44 +    buf.size = 4
    1.45 +#define TEST_BUFFER_SHIFT_TEARDOWN(buf) \
    1.46 +    cxBufferDestroy(&buf); \
    1.47 +    CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc)); \
    1.48 +    cx_testing_allocator_destroy(&talloc);
    1.49 +
    1.50 +
    1.51 +CX_TEST(test_buffer_shift_left_zero) {
    1.52 +    TEST_BUFFER_SHIFT_SETUP(buf);
    1.53 +    CX_TEST_DO {
    1.54 +        int ret = cxBufferShiftLeft(&buf, 0);
    1.55 +        CX_TEST_ASSERT(ret == 0);
    1.56 +        CX_TEST_ASSERT(buf.pos == 4);
    1.57 +        CX_TEST_ASSERT(buf.size == 4);
    1.58 +        CX_TEST_ASSERT(memcmp(buf.space, "test____XXXXXXXX", 16) == 0);
    1.59 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
    1.60 +    }
    1.61 +}
    1.62 +
    1.63 +CX_TEST(test_buffer_shift_left_zero_offset_interface) {
    1.64 +    TEST_BUFFER_SHIFT_SETUP(buf);
    1.65 +    CX_TEST_DO {
    1.66 +        int ret = cxBufferShift(&buf, -0);
    1.67 +        CX_TEST_ASSERT(ret == 0);
    1.68 +        CX_TEST_ASSERT(buf.pos == 4);
    1.69 +        CX_TEST_ASSERT(buf.size == 4);
    1.70 +        CX_TEST_ASSERT(memcmp(buf.space, "test____XXXXXXXX", 16) == 0);
    1.71 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
    1.72 +    }
    1.73 +}
    1.74 +
    1.75 +CX_TEST(test_buffer_shift_left_standard) {
    1.76 +    TEST_BUFFER_SHIFT_SETUP(buf);
    1.77 +    CX_TEST_DO {
    1.78 +        int ret = cxBufferShiftLeft(&buf, 2);
    1.79 +        CX_TEST_ASSERT(ret == 0);
    1.80 +        CX_TEST_ASSERT(buf.pos == 2);
    1.81 +        CX_TEST_ASSERT(buf.size == 2);
    1.82 +        CX_TEST_ASSERT(memcmp(buf.space, "stst____XXXXXXXX", 16) == 0);
    1.83 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
    1.84 +    }
    1.85 +}
    1.86 +
    1.87 +CX_TEST(test_buffer_shift_left_overshift) {
    1.88 +    TEST_BUFFER_SHIFT_SETUP(buf);
    1.89 +    CX_TEST_DO {
    1.90 +        int ret = cxBufferShiftLeft(&buf, 6);
    1.91 +        CX_TEST_ASSERT(ret == 0);
    1.92 +        CX_TEST_ASSERT(buf.pos == 0);
    1.93 +        CX_TEST_ASSERT(buf.size == 0);
    1.94 +        CX_TEST_ASSERT(memcmp(buf.space, "test____XXXXXXXX", 16) == 0);
    1.95 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
    1.96 +    }
    1.97 +}
    1.98 +
    1.99 +CX_TEST(test_buffer_shift_left_overshift_pos_only) {
   1.100 +    TEST_BUFFER_SHIFT_SETUP(buf);
   1.101 +    buf.pos = 2;
   1.102 +    CX_TEST_DO {
   1.103 +        int ret = cxBufferShiftLeft(&buf, 3);
   1.104 +        CX_TEST_ASSERT(ret == 0);
   1.105 +        CX_TEST_ASSERT(buf.pos == 0);
   1.106 +        CX_TEST_ASSERT(buf.size == 1);
   1.107 +        CX_TEST_ASSERT(memcmp(buf.space, "test____XXXXXXXX", 16) == 0);
   1.108 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
   1.109 +    }
   1.110 +}
   1.111 +
   1.112 +CX_TEST(test_buffer_shift_left_offset_interface) {
   1.113 +    TEST_BUFFER_SHIFT_SETUP(buf);
   1.114 +    buf.pos = 3;
   1.115 +    CX_TEST_DO {
   1.116 +        int ret = cxBufferShift(&buf, -2);
   1.117 +        CX_TEST_ASSERT(ret == 0);
   1.118 +        CX_TEST_ASSERT(buf.pos == 1);
   1.119 +        CX_TEST_ASSERT(buf.size == 2);
   1.120 +        CX_TEST_ASSERT(memcmp(buf.space, "stst____XXXXXXXX", 16) == 0);
   1.121 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
   1.122 +    }
   1.123 +}
   1.124 +
   1.125 +CX_TEST(test_buffer_shift_right_zero) {
   1.126 +    TEST_BUFFER_SHIFT_SETUP(buf);
   1.127 +    CX_TEST_DO {
   1.128 +        int ret = cxBufferShiftRight(&buf, 0);
   1.129 +        CX_TEST_ASSERT(ret == 0);
   1.130 +        CX_TEST_ASSERT(buf.pos == 4);
   1.131 +        CX_TEST_ASSERT(buf.size == 4);
   1.132 +        CX_TEST_ASSERT(memcmp(buf.space, "test____XXXXXXXX", 16) == 0);
   1.133 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
   1.134 +    }
   1.135 +}
   1.136 +
   1.137 +CX_TEST(test_buffer_shift_right_zero_offset_interface) {
   1.138 +    TEST_BUFFER_SHIFT_SETUP(buf);
   1.139 +    CX_TEST_DO {
   1.140 +        int ret = cxBufferShift(&buf, +0);
   1.141 +        CX_TEST_ASSERT(ret == 0);
   1.142 +        CX_TEST_ASSERT(buf.pos == 4);
   1.143 +        CX_TEST_ASSERT(buf.size == 4);
   1.144 +        CX_TEST_ASSERT(memcmp(buf.space, "test____XXXXXXXX", 16) == 0);
   1.145 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
   1.146 +    }
   1.147 +}
   1.148 +
   1.149 +CX_TEST(test_buffer_shift_right_standard) {
   1.150 +    TEST_BUFFER_SHIFT_SETUP(buf);
   1.151 +    CX_TEST_DO {
   1.152 +        int ret = cxBufferShiftRight(&buf, 3);
   1.153 +        CX_TEST_ASSERT(ret == 0);
   1.154 +        CX_TEST_ASSERT(buf.pos == 7);
   1.155 +        CX_TEST_ASSERT(buf.size == 7);
   1.156 +        CX_TEST_ASSERT(memcmp(buf.space, "testest_XXXXXXXX", 16) == 0);
   1.157 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
   1.158 +    }
   1.159 +}
   1.160 +
   1.161 +CX_TEST(test_buffer_shift_right_overshift_discard) {
   1.162 +    TEST_BUFFER_SHIFT_SETUP(buf);
   1.163 +    CX_TEST_DO {
   1.164 +        int ret = cxBufferShiftRight(&buf, 6);
   1.165 +        CX_TEST_ASSERT(ret == 0);
   1.166 +        CX_TEST_ASSERT(buf.pos == 8);
   1.167 +        CX_TEST_ASSERT(buf.size == 8);
   1.168 +        CX_TEST_ASSERT(buf.capacity == 8);
   1.169 +        CX_TEST_ASSERT(memcmp(buf.space, "test__teXXXXXXXX", 16) == 0);
   1.170 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
   1.171 +    }
   1.172 +}
   1.173 +
   1.174 +CX_TEST(test_buffer_shift_right_overshift_extend) {
   1.175 +    TEST_BUFFER_SHIFT_SETUP(buf);
   1.176 +    buf.flags |= CX_BUFFER_AUTO_EXTEND;
   1.177 +    CX_TEST_DO {
   1.178 +        int ret = cxBufferShiftRight(&buf, 6);
   1.179 +        CX_TEST_ASSERT(ret == 0);
   1.180 +        CX_TEST_ASSERT(buf.pos == 10);
   1.181 +        CX_TEST_ASSERT(buf.size == 10);
   1.182 +        CX_TEST_ASSERT(buf.capacity >= 10);
   1.183 +        // cannot assert more than 10 bytes because
   1.184 +        // the buffer was required to reallocate the space
   1.185 +        CX_TEST_ASSERT(memcmp(buf.space, "test__test", 10) == 0);
   1.186 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
   1.187 +    }
   1.188 +}
   1.189 +
   1.190 +CX_TEST(test_buffer_shift_right_offset_interface) {
   1.191 +    TEST_BUFFER_SHIFT_SETUP(buf);
   1.192 +    buf.pos = 3;
   1.193 +    CX_TEST_DO {
   1.194 +        int ret = cxBufferShift(&buf, 2);
   1.195 +        CX_TEST_ASSERT(ret == 0);
   1.196 +        CX_TEST_ASSERT(buf.pos == 5);
   1.197 +        CX_TEST_ASSERT(buf.size == 6);
   1.198 +        CX_TEST_ASSERT(memcmp(buf.space, "tetest__XXXXXXXX", 16) == 0);
   1.199 +        TEST_BUFFER_SHIFT_TEARDOWN(buf);
   1.200 +    }
   1.201 +}
   1.202 +
   1.203  CxTestSuite *cx_test_suite_buffer(void) {
   1.204      CxTestSuite *suite = cx_test_suite_new("buffer");
   1.205  
   1.206 @@ -413,6 +609,20 @@
   1.207      cx_test_register(suite, test_buffer_seek_end_valid);
   1.208      cx_test_register(suite, test_buffer_seek_end_invalid);
   1.209      cx_test_register(suite, test_buffer_seek_whence_invalid);
   1.210 +    cx_test_register(suite, test_buffer_eof_reached);
   1.211 +    cx_test_register(suite, test_buffer_eof_not_reached);
   1.212 +    cx_test_register(suite, test_buffer_shift_left_zero);
   1.213 +    cx_test_register(suite, test_buffer_shift_left_zero_offset_interface);
   1.214 +    cx_test_register(suite, test_buffer_shift_left_standard);
   1.215 +    cx_test_register(suite, test_buffer_shift_left_overshift);
   1.216 +    cx_test_register(suite, test_buffer_shift_left_overshift_pos_only);
   1.217 +    cx_test_register(suite, test_buffer_shift_left_offset_interface);
   1.218 +    cx_test_register(suite, test_buffer_shift_right_zero);
   1.219 +    cx_test_register(suite, test_buffer_shift_right_zero_offset_interface);
   1.220 +    cx_test_register(suite, test_buffer_shift_right_standard);
   1.221 +    cx_test_register(suite, test_buffer_shift_right_overshift_discard);
   1.222 +    cx_test_register(suite, test_buffer_shift_right_overshift_extend);
   1.223 +    cx_test_register(suite, test_buffer_shift_right_offset_interface);
   1.224      
   1.225      return suite;
   1.226  }

     2.1 --- a/tests/test_buffer.cpp	Tue Jan 02 23:31:00 2024 +0100
     2.2 +++ b/tests/test_buffer.cpp	Wed Jan 03 22:17:40 2024 +0100
     2.3 @@ -31,169 +31,6 @@
     2.4  #include <gtest/gtest.h>
     2.5  #include "util_allocator.h"
     2.6  
     2.7 -class BufferFixture : public ::testing::Test {
     2.8 -protected:
     2.9 -    void SetUp() override {
    2.10 -        cxBufferInit(&buf, NULL, 16, cxDefaultAllocator, CX_BUFFER_DEFAULT);
    2.11 -        buf.size = 6;
    2.12 -        buf.pos = 3;
    2.13 -    }
    2.14 -
    2.15 -    void TearDown() override {
    2.16 -        cxBufferDestroy(&buf);
    2.17 -    }
    2.18 -
    2.19 -    CxBuffer buf{};
    2.20 -};
    2.21 -
    2.22 -class BufferShiftFixture : public ::testing::Test {
    2.23 -protected:
    2.24 -    void SetUp() override {
    2.25 -        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    2.26 -        cxBufferInit(&buf, NULL, 16, &alloc, CX_BUFFER_DEFAULT);
    2.27 -        memcpy(buf.space, "test____________", 16);
    2.28 -        buf.capacity = 8; // purposely pretend that the buffer has less capacity s.t. we can test beyond the range
    2.29 -        buf.pos = 4;
    2.30 -        buf.size = 4;
    2.31 -    }
    2.32 -
    2.33 -    void TearDown() override {
    2.34 -        cxBufferDestroy(&buf);
    2.35 -        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    2.36 -    }
    2.37 -
    2.38 -    CxTestingAllocator alloc;
    2.39 -    CxBuffer buf{};
    2.40 -};
    2.41 -
    2.42 -class BufferShiftLeft : public BufferShiftFixture {
    2.43 -};
    2.44 -
    2.45 -TEST_F(BufferShiftLeft, Zero) {
    2.46 -    CX_TEST_ASSERT(buf.pos == 4);
    2.47 -    CX_TEST_ASSERT(buf.size == 4);
    2.48 -    int ret = cxBufferShiftLeft(&buf, 0);
    2.49 -    CX_TEST_ASSERT(ret == 0);
    2.50 -    CX_TEST_ASSERT(buf.pos == 4);
    2.51 -    CX_TEST_ASSERT(buf.size == 4);
    2.52 -    CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
    2.53 -}
    2.54 -
    2.55 -TEST_F(BufferShiftLeft, ZeroOffsetInterface) {
    2.56 -    CX_TEST_ASSERT(buf.pos == 4);
    2.57 -    CX_TEST_ASSERT(buf.size == 4);
    2.58 -    int ret = cxBufferShift(&buf, -0);
    2.59 -    CX_TEST_ASSERT(ret == 0);
    2.60 -    CX_TEST_ASSERT(buf.pos == 4);
    2.61 -    CX_TEST_ASSERT(buf.size == 4);
    2.62 -    CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
    2.63 -}
    2.64 -
    2.65 -TEST_F(BufferShiftLeft, Standard) {
    2.66 -    CX_TEST_ASSERT(buf.pos == 4);
    2.67 -    CX_TEST_ASSERT(buf.size == 4);
    2.68 -    int ret = cxBufferShiftLeft(&buf, 2);
    2.69 -    CX_TEST_ASSERT(ret == 0);
    2.70 -    CX_TEST_ASSERT(buf.pos == 2);
    2.71 -    CX_TEST_ASSERT(buf.size == 2);
    2.72 -    CX_TEST_ASSERT(memcmp(buf.space, "stst________", 8) == 0);
    2.73 -}
    2.74 -
    2.75 -TEST_F(BufferShiftLeft, Overshift) {
    2.76 -    ASSERT_LT(buf.pos, 6);
    2.77 -    ASSERT_LT(buf.size, 6);
    2.78 -    int ret = cxBufferShiftLeft(&buf, 6);
    2.79 -    CX_TEST_ASSERT(ret == 0);
    2.80 -    CX_TEST_ASSERT(buf.pos == 0);
    2.81 -    CX_TEST_ASSERT(buf.size == 0);
    2.82 -    CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
    2.83 -}
    2.84 -
    2.85 -TEST_F(BufferShiftLeft, OvershiftPosOnly) {
    2.86 -    buf.pos = 2;
    2.87 -    CX_TEST_ASSERT(buf.size == 4);
    2.88 -    int ret = cxBufferShiftLeft(&buf, 3);
    2.89 -    CX_TEST_ASSERT(ret == 0);
    2.90 -    CX_TEST_ASSERT(buf.pos == 0);
    2.91 -    CX_TEST_ASSERT(buf.size == 1);
    2.92 -    CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
    2.93 -}
    2.94 -
    2.95 -TEST_F(BufferShiftLeft, OffsetInterface) {
    2.96 -    buf.pos = 3;
    2.97 -    CX_TEST_ASSERT(buf.size == 4);
    2.98 -    int ret = cxBufferShift(&buf, -2);
    2.99 -    CX_TEST_ASSERT(ret == 0);
   2.100 -    CX_TEST_ASSERT(buf.pos == 1);
   2.101 -    CX_TEST_ASSERT(buf.size == 2);
   2.102 -    CX_TEST_ASSERT(memcmp(buf.space, "stst________", 8) == 0);
   2.103 -}
   2.104 -
   2.105 -TEST_F(BufferShiftRight, Zero) {
   2.106 -    CX_TEST_ASSERT(buf.pos == 4);
   2.107 -    CX_TEST_ASSERT(buf.size == 4);
   2.108 -    int ret = cxBufferShiftRight(&buf, 0);
   2.109 -    CX_TEST_ASSERT(ret == 0);
   2.110 -    CX_TEST_ASSERT(buf.pos == 4);
   2.111 -    CX_TEST_ASSERT(buf.size == 4);
   2.112 -    CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
   2.113 -}
   2.114 -
   2.115 -TEST_F(BufferShiftRight, ZeroOffsetInterface) {
   2.116 -    CX_TEST_ASSERT(buf.pos == 4);
   2.117 -    CX_TEST_ASSERT(buf.size == 4);
   2.118 -    int ret = cxBufferShift(&buf, +0);
   2.119 -    CX_TEST_ASSERT(ret == 0);
   2.120 -    CX_TEST_ASSERT(buf.pos == 4);
   2.121 -    CX_TEST_ASSERT(buf.size == 4);
   2.122 -    CX_TEST_ASSERT(memcmp(buf.space, "test________", 8) == 0);
   2.123 -}
   2.124 -
   2.125 -TEST_F(BufferShiftRight, Standard) {
   2.126 -    CX_TEST_ASSERT(buf.pos == 4);
   2.127 -    CX_TEST_ASSERT(buf.size == 4);
   2.128 -    int ret = cxBufferShiftRight(&buf, 3);
   2.129 -    CX_TEST_ASSERT(ret == 0);
   2.130 -    CX_TEST_ASSERT(buf.pos == 7);
   2.131 -    CX_TEST_ASSERT(buf.size == 7);
   2.132 -    CX_TEST_ASSERT(memcmp(buf.space, "testest_____", 8) == 0);
   2.133 -}
   2.134 -
   2.135 -TEST_F(BufferShiftRight, OvershiftDiscard) {
   2.136 -    CX_TEST_ASSERT(buf.pos == 4);
   2.137 -    CX_TEST_ASSERT(buf.size == 4);
   2.138 -    CX_TEST_ASSERT(buf.capacity == 8);
   2.139 -    int ret = cxBufferShiftRight(&buf, 6);
   2.140 -    CX_TEST_ASSERT(ret == 0);
   2.141 -    CX_TEST_ASSERT(buf.pos == 8);
   2.142 -    CX_TEST_ASSERT(buf.size == 8);
   2.143 -    CX_TEST_ASSERT(buf.capacity == 8);
   2.144 -    CX_TEST_ASSERT(memcmp(buf.space, "test__te____", 8) == 0);
   2.145 -}
   2.146 -
   2.147 -TEST_F(BufferShiftRight, OvershiftExtend) {
   2.148 -    CX_TEST_ASSERT(buf.pos == 4);
   2.149 -    CX_TEST_ASSERT(buf.size == 4);
   2.150 -    CX_TEST_ASSERT(buf.capacity == 8);
   2.151 -    buf.flags |= CX_BUFFER_AUTO_EXTEND;
   2.152 -    int ret = cxBufferShiftRight(&buf, 6);
   2.153 -    CX_TEST_ASSERT(ret == 0);
   2.154 -    CX_TEST_ASSERT(buf.pos == 10);
   2.155 -    CX_TEST_ASSERT(buf.size == 10);
   2.156 -    EXPECT_GE(buf.capacity, 10);
   2.157 -    CX_TEST_ASSERT(memcmp(buf.space, "test__test__", 8) == 0);
   2.158 -}
   2.159 -
   2.160 -TEST_F(BufferShiftRight, OffsetInterface) {
   2.161 -    buf.pos = 3;
   2.162 -    CX_TEST_ASSERT(buf.size == 4);
   2.163 -    int ret = cxBufferShift(&buf, 2);
   2.164 -    CX_TEST_ASSERT(ret == 0);
   2.165 -    CX_TEST_ASSERT(buf.pos == 5);
   2.166 -    CX_TEST_ASSERT(buf.size == 6);
   2.167 -    CX_TEST_ASSERT(memcmp(buf.space, "tetest______", 8) == 0);
   2.168 -}
   2.169 -
   2.170  class BufferWrite : public ::testing::Test {
   2.171  protected:
   2.172      CxBuffer buf{}, target{};
   2.173 @@ -507,24 +344,6 @@
   2.174      EXPECT_EQ(memcmp(target.space, "prepfoohello,", 13), 0);
   2.175  }
   2.176  
   2.177 -
   2.178 -TEST_F(BufferEof, Reached) {
   2.179 -    buf.pos = buf.size;
   2.180 -    CX_TEST_ASSERT(cxBufferEof(&buf));
   2.181 -    buf.pos = buf.size - 1;
   2.182 -    CX_TEST_ASSERT(!cxBufferEof(&buf));
   2.183 -    cxBufferPut(&buf, 'a');
   2.184 -    CX_TEST_ASSERT(cxBufferEof(&buf));
   2.185 -}
   2.186 -
   2.187 -TEST_F(BufferEof, NotReached) {
   2.188 -    buf.pos = buf.size - 1;
   2.189 -    CX_TEST_ASSERT(!cxBufferEof(&buf));
   2.190 -    buf.pos = 0;
   2.191 -    cxBufferWrite("test", 1, 5, &buf);
   2.192 -    CX_TEST_ASSERT(!cxBufferEof(&buf));
   2.193 -}
   2.194 -
   2.195  class BufferRead : public ::testing::Test {
   2.196  protected:
   2.197      CxBuffer buf{};