ucx: test/mpool_tests.c@c7af4ec56e19

     1 /*

     2  *

     3  */

     5 #include <inttypes.h>

     7 #include "mpool_tests.h"

     9 UCX_TEST_BEGIN(test_ucx_mempool_new) {

    10     UcxMempool *pool = ucx_mempool_new(16);

    12     UCX_TEST_ASSERT(pool->size == 16, "wrong size")

    13     UCX_TEST_ASSERT(pool->ndata == 0, "uninitialized counter")

    14     UCX_TEST_ASSERT(pool->data != NULL, "no memory addressed")

    16     ucx_mempool_free(pool);

    18     UCX_TEST_END

    19 }

    21 UCX_TEST_BEGIN(test_ucx_mempool_malloc) {

    23     UcxMempool *pool = ucx_mempool_new(1);

    25     intptr_t *test = (intptr_t*) ucx_mempool_malloc(pool, sizeof(intptr_t));

    27     UCX_TEST_ASSERT(pool->ndata == 1, "counter not incremented")

    28     UCX_TEST_ASSERT(pool->size == 1, "chcap called")

    30     intptr_t *pooladdr =

    31             (intptr_t*)((char*)pool->data[0] + sizeof(ucx_destructor));

    32     *pooladdr = 5;

    34     UCX_TEST_ASSERT(*test == 5, "wrong pointer")

    36     ucx_mempool_free(pool);

    38     UCX_TEST_END

    39 }

    41 UCX_TEST_BEGIN(test_ucx_mempool_malloc_with_chcap) {

    43     UcxMempool *pool = ucx_mempool_new(1);

    45     ucx_mempool_malloc(pool, sizeof(int));

    46     intptr_t *test = (intptr_t*) ucx_mempool_malloc(pool, sizeof(intptr_t));

    48     UCX_TEST_ASSERT(pool->ndata == 2, "counter not incremented")

    49     UCX_TEST_ASSERT(pool->size == 17, "chcap not called")

    51     intptr_t *pooladdr =

    52             (intptr_t*)((char*)pool->data[1] + sizeof(ucx_destructor));

    53     *pooladdr = 5;

    55     UCX_TEST_ASSERT(*test == 5, "wrong pointer")

    57     ucx_mempool_free(pool);

    59     UCX_TEST_END

    60 }

    62 UCX_TEST_BEGIN(test_ucx_mempool_calloc) {

    64     UcxMempool *pool = ucx_mempool_new(1);

    66     intptr_t *test = (intptr_t*) ucx_mempool_calloc(pool, 2, sizeof(intptr_t));

    68     UCX_TEST_ASSERT(test != NULL, "no memory for test data")

    69     UCX_TEST_ASSERT(test[0] == 0 && test[1] == 0, "failed")

    71     ucx_mempool_free(pool);

    73     UCX_TEST_END

    74 }

    76 void test_setdestr(void* elem) {

    77     intptr_t *cb = (intptr_t*) ((intptr_t*) elem)[1];

    78     *cb = 42;

    79 }

    81 UCX_TEST_BEGIN(test_ucx_mempool_set_destr) {

    83     UcxMempool *pool = ucx_mempool_new(2);

    85     ucx_mempool_malloc(pool, sizeof(intptr_t));

    86     intptr_t *test = (intptr_t*) ucx_mempool_calloc(pool, 2, sizeof(intptr_t));

    88     intptr_t *cb = (intptr_t*) malloc(sizeof(intptr_t));

    89     UCX_TEST_ASSERT(cb != NULL && test != NULL, "no memory for test data")

    91     test[0] = 5; test[1] = (intptr_t) cb;

    92     *cb = 13;

    94     ucx_mempool_set_destr(test, test_setdestr);

    95     UCX_TEST_ASSERT(

    96             *(ucx_destructor*)(pool->data[1]) == test_setdestr, "failed")

    97     UCX_TEST_ASSERT(

    98             test[0] == 5 && test[1] == (intptr_t) cb, "setdestr destroyed data")

   100     ucx_mempool_free(pool);

   102     UCX_TEST_ASSERT(*cb == 42, "destructor not called")

   104     free(cb);

   106     UCX_TEST_END

   107 }

   110 UCX_TEST_BEGIN(test_ucx_mempool_reg_destr) {

   112     UcxMempool *pool = ucx_mempool_new(1);

   114     intptr_t *test = (intptr_t*) calloc(2, sizeof(intptr_t));

   116     intptr_t *cb = (intptr_t*) malloc(sizeof(intptr_t));

   117     UCX_TEST_ASSERT(cb != NULL && test != NULL, "no memory for test data")

   119     test[0] = 5; test[1] = (intptr_t) cb;

   120     *cb = 13;

   122     ucx_mempool_reg_destr(pool, test, test_setdestr);

   124     ucx_destructor *pooladdr = (ucx_destructor*)

   125             ((char*)pool->data[0] + sizeof(ucx_destructor));

   127     UCX_TEST_ASSERT(*pooladdr == test_setdestr, "failed")

   129     ucx_mempool_free(pool);

   130     free(test);

   132     UCX_TEST_ASSERT(*cb == 42, "destructor not called")

   134     free(cb);

   136     UCX_TEST_END

   137 }

   139 UCX_TEST_BEGIN(test_ucx_mempool_realloc) {

   141     UcxMempool *pool = ucx_mempool_new(2);

   143     ucx_mempool_malloc(pool, sizeof(intptr_t));

   144     intptr_t *test = (intptr_t*) ucx_mempool_calloc(pool, 2, sizeof(intptr_t));

   146     intptr_t *cb = (intptr_t*) malloc(sizeof(intptr_t));

   147     UCX_TEST_ASSERT(cb != NULL && test != NULL, "no memory for test data")

   149     test[0] = 5; test[1] = (intptr_t) cb;

   150     *cb = 13;

   152     ucx_mempool_set_destr(test, test_setdestr);

   154     int *rtest, n = 2;

   155     do {

   156         n *= 2;

   157         UCX_TEST_ASSERT(n < 65536, "test corrupt - no movement for realloc")

   158         rtest = ucx_mempool_realloc(pool, test, n*sizeof(intptr_t));

   159     } while (rtest == test);

   160     test = rtest;

   162     UCX_TEST_ASSERT(*(ucx_destructor*)(pool->data[1]) == test_setdestr,

   163             "realloc killed destructor")

   164     UCX_TEST_ASSERT(

   165             test[0] == 5 && test[1] == (intptr_t) cb, "realloc destroyed data")

   167     ucx_mempool_free(pool);

   169     UCX_TEST_ASSERT(*cb == 42, "destructor not called")

   171     free(cb);

   173     UCX_TEST_END

   174 }

Mercurial > hg > ucx / file revision