ucx: test/test_buffer.cpp@2ff6e9184468

     1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

     3  *

     4  * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.

     5  *

     6  * Redistribution and use in source and binary forms, with or without

     7  * modification, are permitted provided that the following conditions are met:

     8  *

     9  *   1. Redistributions of source code must retain the above copyright

    10  *      notice, this list of conditions and the following disclaimer.

    11  *

    12  *   2. Redistributions in binary form must reproduce the above copyright

    13  *      notice, this list of conditions and the following disclaimer in the

    14  *      documentation and/or other materials provided with the distribution.

    15  *

    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

    26  * POSSIBILITY OF SUCH DAMAGE.

    27  */

    29 #include "cx/buffer.h"

    31 #include <gtest/gtest.h>

    32 #include "util_allocator.h"

    34 TEST(BufferInit, WrapSpace) {

    35     CxTestingAllocator alloc;

    36     CxBuffer buf;

    37     void *space = cxMalloc(&alloc, 16);

    38     cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_DEFAULT);

    39     EXPECT_EQ(buf.space, space);

    40     EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);

    41     EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, 0);

    42     EXPECT_EQ(buf.pos, 0);

    43     EXPECT_EQ(buf.size, 0);

    44     EXPECT_EQ(buf.capacity, 16);

    45     EXPECT_EQ(buf.allocator, &alloc);

    46     cxBufferDestroy(&buf);

    47     EXPECT_FALSE(alloc.verify());

    48     cxFree(&alloc, space);

    49     EXPECT_TRUE(alloc.verify());

    50 }

    52 TEST(BufferInit, WrapSpaceAutoFree) {

    53     CxTestingAllocator alloc;

    54     CxBuffer buf;

    55     void *space = cxMalloc(&alloc, 16);

    56     cxBufferInit(&buf, space, 16, &alloc, CX_BUFFER_FREE_CONTENTS);

    57     EXPECT_EQ(buf.space, space);

    58     EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);

    59     EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS);

    60     EXPECT_EQ(buf.pos, 0);

    61     EXPECT_EQ(buf.size, 0);

    62     EXPECT_EQ(buf.capacity, 16);

    63     EXPECT_EQ(buf.allocator, &alloc);

    64     EXPECT_FALSE(alloc.verify());

    65     cxBufferDestroy(&buf);

    66     EXPECT_TRUE(alloc.verify());

    67 }

    69 TEST(BufferInit, FreshSpace) {

    70     CxTestingAllocator alloc;

    71     CxBuffer buf;

    72     cxBufferInit(&buf, nullptr, 8, &alloc, CX_BUFFER_DEFAULT);

    73     EXPECT_NE(buf.space, nullptr);

    74     EXPECT_EQ(buf.flags & CX_BUFFER_AUTO_EXTEND, 0);

    75     EXPECT_EQ(buf.flags & CX_BUFFER_FREE_CONTENTS, CX_BUFFER_FREE_CONTENTS);

    76     EXPECT_EQ(buf.pos, 0);

    77     EXPECT_EQ(buf.size, 0);

    78     EXPECT_EQ(buf.capacity, 8);

    79     EXPECT_EQ(buf.allocator, &alloc);

    80     EXPECT_FALSE(alloc.verify()); // space is still allocated

    81     cxBufferDestroy(&buf);

    82     EXPECT_TRUE(alloc.verify());

    83 }

    85 class BufferShiftFixture : public ::testing::Test {

    86 protected:

    87     void SetUp() override {

    88         ASSERT_TRUE(alloc.verify());

    89         cxBufferInit(&buf, nullptr, 16, &alloc, CX_BUFFER_DEFAULT);

    90         memcpy(buf.space, "test____________", 16);

    91         buf.capacity = 8; // purposely pretend that the buffer has less capacity s.t. we can test beyond the range

    92         buf.pos = 4;

    93         buf.size = 4;

    94     }

    96     void TearDown() override {

    97         cxBufferDestroy(&buf);

    98         EXPECT_TRUE(alloc.verify());

    99     }

   101     CxTestingAllocator alloc;

   102     CxBuffer buf{};

   103 };

   105 class BufferShiftLeft : public BufferShiftFixture {

   106 };

   108 TEST_F(BufferShiftLeft, Zero) {

   109     ASSERT_EQ(buf.pos, 4);

   110     ASSERT_EQ(buf.size, 4);

   111     int ret = cxBufferShiftLeft(&buf, 0);

   112     EXPECT_EQ(ret, 0);

   113     EXPECT_EQ(buf.pos, 4);

   114     EXPECT_EQ(buf.size, 4);

   115     EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);

   116 }

   118 TEST_F(BufferShiftLeft, Standard) {

   119     ASSERT_EQ(buf.pos, 4);

   120     ASSERT_EQ(buf.size, 4);

   121     int ret = cxBufferShiftLeft(&buf, 2);

   122     EXPECT_EQ(ret, 0);

   123     EXPECT_EQ(buf.pos, 2);

   124     EXPECT_EQ(buf.size, 2);

   125     EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0);

   126 }

   128 TEST_F(BufferShiftLeft, Overshift) {

   129     ASSERT_LT(buf.pos, 6);

   130     ASSERT_LT(buf.size, 6);

   131     int ret = cxBufferShiftLeft(&buf, 6);

   132     EXPECT_EQ(ret, 0);

   133     EXPECT_EQ(buf.pos, 0);

   134     EXPECT_EQ(buf.size, 0);

   135     EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);

   136 }

   138 TEST_F(BufferShiftLeft, OvershiftPosOnly) {

   139     buf.pos = 2;

   140     ASSERT_EQ(buf.size, 4);

   141     int ret = cxBufferShiftLeft(&buf, 3);

   142     EXPECT_EQ(ret, 0);

   143     EXPECT_EQ(buf.pos, 0);

   144     EXPECT_EQ(buf.size, 1);

   145     EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);

   146 }

   148 TEST_F(BufferShiftLeft, OffsetInterface) {

   149     buf.pos = 3;

   150     ASSERT_EQ(buf.size, 4);

   151     int ret = cxBufferShift(&buf, -2);

   152     EXPECT_EQ(ret, 0);

   153     EXPECT_EQ(buf.pos, 1);

   154     EXPECT_EQ(buf.size, 2);

   155     EXPECT_TRUE(memcmp(buf.space, "stst________", 8) == 0);

   156 }

   158 class BufferShiftRight : public BufferShiftFixture {

   159 };

   161 TEST_F(BufferShiftRight, Zero) {

   162     ASSERT_EQ(buf.pos, 4);

   163     ASSERT_EQ(buf.size, 4);

   164     int ret = cxBufferShiftRight(&buf, 0);

   165     EXPECT_EQ(ret, 0);

   166     EXPECT_EQ(buf.pos, 4);

   167     EXPECT_EQ(buf.size, 4);

   168     EXPECT_TRUE(memcmp(buf.space, "test________", 8) == 0);

   169 }

   171 TEST_F(BufferShiftRight, Standard) {

   172     ASSERT_EQ(buf.pos, 4);

   173     ASSERT_EQ(buf.size, 4);

   174     int ret = cxBufferShiftRight(&buf, 3);

   175     EXPECT_EQ(ret, 0);

   176     EXPECT_EQ(buf.pos, 7);

   177     EXPECT_EQ(buf.size, 7);

   178     EXPECT_TRUE(memcmp(buf.space, "testest_____", 8) == 0);

   179 }

   181 TEST_F(BufferShiftRight, OvershiftDiscard) {

   182     ASSERT_EQ(buf.pos, 4);

   183     ASSERT_EQ(buf.size, 4);

   184     ASSERT_EQ(buf.capacity, 8);

   185     int ret = cxBufferShiftRight(&buf, 6);

   186     EXPECT_EQ(ret, 0);

   187     EXPECT_EQ(buf.pos, 8);

   188     EXPECT_EQ(buf.size, 8);

   189     EXPECT_EQ(buf.capacity, 8);

   190     EXPECT_TRUE(memcmp(buf.space, "test__te____", 8) == 0);

   191 }

   193 TEST_F(BufferShiftRight, OvershiftExtend) {

   194     ASSERT_EQ(buf.pos, 4);

   195     ASSERT_EQ(buf.size, 4);

   196     ASSERT_EQ(buf.capacity, 8);

   197     buf.flags |= CX_BUFFER_AUTO_EXTEND;

   198     int ret = cxBufferShiftRight(&buf, 6);

   199     EXPECT_EQ(ret, 0);

   200     EXPECT_EQ(buf.pos, 10);

   201     EXPECT_EQ(buf.size, 10);

   202     EXPECT_GE(buf.capacity, 10);

   203     EXPECT_TRUE(memcmp(buf.space, "test__test__", 8) == 0);

   204 }

   206 TEST_F(BufferShiftRight, OffsetInterface) {

   207     buf.pos = 3;

   208     ASSERT_EQ(buf.size, 4);

   209     int ret = cxBufferShift(&buf, 2);

   210     EXPECT_EQ(ret, 0);

   211     EXPECT_EQ(buf.pos, 5);

   212     EXPECT_EQ(buf.size, 6);

   213     EXPECT_TRUE(memcmp(buf.space, "tetest______", 8) == 0);

   214 }

   216 TEST(BufferMinimumCapacity, Sufficient) {

   217     CxTestingAllocator alloc;

   218     auto space = cxMalloc(&alloc, 8);

   219     CxBuffer buf;

   220     cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS);

   221     memcpy(space, "Testing", 8);

   222     buf.size = 8;

   223     cxBufferMinimumCapacity(&buf, 6);

   224     EXPECT_EQ(buf.capacity, 8);

   225     EXPECT_EQ(buf.size, 8);

   226     EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0);

   227     cxBufferDestroy(&buf);

   228     EXPECT_TRUE(alloc.verify());

   229 }

   231 TEST(BufferMinimumCapacity, Extend) {

   232     CxTestingAllocator alloc;

   233     auto space = cxMalloc(&alloc, 8);

   234     CxBuffer buf;

   235     cxBufferInit(&buf, space, 8, &alloc, CX_BUFFER_FREE_CONTENTS); // NO auto extend!

   236     memcpy(space, "Testing", 8);

   237     buf.size = 8;

   238     cxBufferMinimumCapacity(&buf, 16);

   239     EXPECT_EQ(buf.capacity, 16);

   240     EXPECT_EQ(buf.size, 8);

   241     EXPECT_TRUE(memcmp(buf.space, "Testing", 8) == 0);

   242     cxBufferDestroy(&buf);

   243     EXPECT_TRUE(alloc.verify());

   244 }

Mercurial > hg > ucx / file revision

test/test_buffer.cpp@2ff6e9184468

test/test_buffer.cpp