ucx: test/test_allocator.cpp@6f9d97a53d67

     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/allocator.h"

    30 #include <gtest/gtest.h>

    32 TEST(Allocator, DefaultAllocator) {

    33     cx_allocator_class *clazz = cxDefaultAllocator->cl;

    34     ASSERT_NE(clazz, nullptr);

    35 }

    37 TEST(Allocator, DefaultMalloc) {

    38     void *test = cxMalloc(cxDefaultAllocator, 16);

    39     ASSERT_NE(test, nullptr);

    40     free(test);

    41 }

    43 TEST(Allocator, DefaultRealloc) {

    44     void *test = calloc(8, 1);

    45     memcpy(test, "Test", 5);

    46     test = cxRealloc(cxDefaultAllocator, test, 16);

    47     ASSERT_NE(test, nullptr);

    48     EXPECT_STREQ(reinterpret_cast<char *>(test), "Test");

    49     free(test);

    50 }

    52 TEST(Allocator, Reallocate) {

    53     void *test = calloc(8, 1);

    54     memcpy(test, "Test", 5);

    55     int ret = cxReallocate(cxDefaultAllocator, &test, 16);

    56     EXPECT_EQ(ret, 0);

    57     ASSERT_NE(test, nullptr);

    58     EXPECT_STREQ(reinterpret_cast<char *>(test), "Test");

    59     free(test);

    60 }

    62 TEST(Allocator, DefaultCalloc) {

    63     char *test = reinterpret_cast<char *>(cxCalloc(cxDefaultAllocator, 8, 2));

    64     ASSERT_NE(test, nullptr);

    65     for (int i = 0; i < 16; i++) ASSERT_EQ(test[i], 0);

    66     free(test);

    67 }

    69 TEST(Allocator, DefaultFree) {

    70     void *test = malloc(16);

    71     EXPECT_NO_FATAL_FAILURE(

    72             cxFree(cxDefaultAllocator, test);

    73     );

    74 }

    76 TEST(Allocator, FailingReallocate) {

    77     // Mock an allocator that always returns nullptr on realloc

    78     cx_allocator_class mock_cl;

    79     mock_cl.realloc = [](void* p, void* d, size_t n) -> void* { return nullptr; };

    80     cx_allocator_s mock{&mock_cl, nullptr};

    82     void *test = calloc(8, 1);

    83     memcpy(test, "Test", 5);

    84     void *original = test;

    85     int ret = cxReallocate(&mock, &test, 16);

    86     // non-zero return code because of the failure

    87     EXPECT_NE(ret, 0);

    88     // the test pointer was not changed and still points to the same memory

    89     EXPECT_EQ(test, original);

    90     EXPECT_STREQ(reinterpret_cast<char *>(test), "Test");

    91     free(test);

    92 }

Mercurial > hg > ucx / file revision