ucx: test/buffer_tests.c@740fbd7bab71

     1 /*

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

     3  *

     4  * Copyright 2016 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 "buffer_tests.h"

    31 UCX_TEST(test_ucx_buffer_new) {

    32     UcxBuffer *b = ucx_buffer_new(NULL, 16, UCX_BUFFER_AUTOEXTEND);

    33     UcxBuffer *b2 = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT);

    34     UCX_TEST_BEGIN

    36     UCX_TEST_ASSERT(b->capacity==16, "wrong capacity");

    37     UCX_TEST_ASSERT(b2->capacity==32, "wrong capacity");

    39     UCX_TEST_ASSERT(b->size==0, "wrong size");

    40     UCX_TEST_ASSERT(b2->size==0, "wrong size");

    42     UCX_TEST_ASSERT(b->pos==0, "wrong position");

    43     UCX_TEST_ASSERT(b2->pos==0, "wrong position");

    45     UCX_TEST_ASSERT(b->flags==(UCX_BUFFER_AUTOEXTEND|UCX_BUFFER_AUTOFREE),

    46         "wrong flags for autoextending buffer");

    47     UCX_TEST_ASSERT(b2->flags==UCX_BUFFER_AUTOFREE,

    48         "wrong flags for default bufer");

    50     UCX_TEST_END

    51     ucx_buffer_free(b2);

    52     ucx_buffer_free(b);

    53 }

    55 UCX_TEST(test_ucx_buffer_new_prealloc) {

    56     char* test = (char*) malloc(16);

    57     UcxBuffer *b = ucx_buffer_new(test, 16, UCX_BUFFER_DEFAULT);

    58     UCX_TEST_BEGIN

    60     UCX_TEST_ASSERT(b->capacity==16, "wrong capacity");

    61     UCX_TEST_ASSERT(b->size==0, "wrong size");

    62     UCX_TEST_ASSERT(b->pos==0, "wrong position");

    64     UCX_TEST_ASSERT(b->flags==0, "wrong flags - all should be cleared");

    66     UCX_TEST_END

    67     free(test);

    68     ucx_buffer_free(b);

    69 }

    71 UCX_TEST(test_ucx_buffer_eof) {

    72     char *test = (char*)"0123456789ABCDEF";

    73     UcxBuffer *b = ucx_buffer_new(test, 16, UCX_BUFFER_DEFAULT);

    74     UCX_TEST_BEGIN

    75     b->pos = 9; b->size = 10;

    76     UCX_TEST_ASSERT(!ucx_buffer_eof(b), "false positive");

    77     b->pos = 10; b->size = 10;

    78     UCX_TEST_ASSERT(ucx_buffer_eof(b), "pos == size should be EOF");

    79     b->pos = 11; b->size = 10;

    80     UCX_TEST_ASSERT(ucx_buffer_eof(b), "false negative");

    81     UCX_TEST_END

    82     ucx_buffer_free(b);

    83 }

    85 UCX_TEST(test_ucx_buffer_seek_overflow) {

    86     UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT);

    87     b->size = 32;

    88     int r;

    90     UCX_TEST_BEGIN

    91     const size_t sizemax = (size_t)-1;

    92     size_t bigpos = sizemax - 5000;

    93     b->pos = bigpos;

    94     r = ucx_buffer_seek(b, 5016, SEEK_CUR);

    95     UCX_TEST_ASSERT(r != 0, "seek cur overflow");

    96     UCX_TEST_ASSERT(b->pos == bigpos,

    97             "failed seek shall leave pos unchanged");

    99     b->pos = 0;

   100     b->size = sizemax / 2 + 32;

   101     off_t bigoff = sizemax / 2 - 16;

   102     r = ucx_buffer_seek(b, -bigoff, SEEK_CUR);

   103     UCX_TEST_ASSERT(r != 0, "seek cur underflow");

   104     UCX_TEST_ASSERT(b->pos == 0,

   105             "failed seek shall leave pos unchanged");

   107     UCX_TEST_END

   109     ucx_buffer_free(b);

   110 }

   112 UCX_TEST(test_ucx_buffer_seek_invalid) {

   113     UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT);

   114     b->pos = 7;

   115     int r;

   117     UCX_TEST_BEGIN

   118     r = ucx_buffer_seek(b, 0, ~(SEEK_SET|SEEK_CUR|SEEK_END));

   119     UCX_TEST_ASSERT(r != 0, "invalid whence shall fail");

   120     UCX_TEST_ASSERT(b->pos == 7,

   121             "failed seek shall leave pos unchanged");

   122     UCX_TEST_END

   124     ucx_buffer_free(b);

   125 }

   127 UCX_TEST(test_ucx_buffer_seek_oob) {

   128     UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT);

   129     b->size = 16; // less than capacity

   130     b->pos = 7;

   131     int r;

   133     UCX_TEST_BEGIN

   135     r = ucx_buffer_seek(b, -1, SEEK_SET);

   136     UCX_TEST_ASSERT(r != 0, "seek SET below bounds shall fail");

   137     UCX_TEST_ASSERT(b->pos == 7,

   138             "failed seek shall leave pos unchanged");

   140     r = ucx_buffer_seek(b, 16, SEEK_SET);

   141     UCX_TEST_ASSERT(r != 0, "seek SET above bounds shall fail");

   142     UCX_TEST_ASSERT(b->pos == 7,

   143             "failed seek shall leave pos unchanged");

   145     r = ucx_buffer_seek(b, -8, SEEK_CUR);

   146     UCX_TEST_ASSERT(r != 0, "seek CUR below bounds shall fail");

   147     UCX_TEST_ASSERT(b->pos == 7,

   148             "failed seek shall leave pos unchanged");

   150     r = ucx_buffer_seek(b, 9, SEEK_CUR);

   151     UCX_TEST_ASSERT(r != 0, "seek CUR above bounds shall fail");

   152     UCX_TEST_ASSERT(b->pos == 7,

   153             "failed seek shall leave pos unchanged");

   155     r = ucx_buffer_seek(b, -17, SEEK_END);

   156     UCX_TEST_ASSERT(r != 0, "seek END below bounds shall fail");

   157     UCX_TEST_ASSERT(b->pos == 7,

   158             "failed seek shall leave pos unchanged");

   160     r = ucx_buffer_seek(b, 1, SEEK_END);

   161     UCX_TEST_ASSERT(r != 0, "seek END above bounds shall fail");

   162     UCX_TEST_ASSERT(b->pos == 7,

   163             "failed seek shall leave pos unchanged");

   165     UCX_TEST_END

   167     ucx_buffer_free(b);

   168 }

   170 UCX_TEST(test_ucx_buffer_seek_set) {

   171     UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT);

   172     b->size = 16;

   173     int r;

   175     UCX_TEST_BEGIN

   177     r = ucx_buffer_seek(b, 5, SEEK_SET);

   178     UCX_TEST_ASSERT(r == 0, "seek SET+5 failed");

   179     UCX_TEST_ASSERT(b->pos == 5, "seek SET+5 set wrong position");

   182     r = ucx_buffer_seek(b, 10, SEEK_SET);

   183     UCX_TEST_ASSERT(r == 0, "seek SET+10 failed");

   184     UCX_TEST_ASSERT(b->pos == 10, "seek SET+10 set wrong position");

   186     UCX_TEST_END

   188     ucx_buffer_free(b);

   189 }

   191 UCX_TEST(test_ucx_buffer_seek_cur) {

   192     UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT);

   193     b->size = 16;

   194     int r;

   196     UCX_TEST_BEGIN

   198     b->pos = 7;

   199     r = ucx_buffer_seek(b, 5, SEEK_CUR);

   200     UCX_TEST_ASSERT(r == 0, "seek CUR+5 failed");

   201     UCX_TEST_ASSERT(b->pos == 12, "seek CUR+5 set wrong position");

   203     UCX_TEST_END

   205     ucx_buffer_free(b);

   206 }

   208 UCX_TEST(test_ucx_buffer_seek_end) {

   209     UcxBuffer *b = ucx_buffer_new(NULL, 32, UCX_BUFFER_DEFAULT);

   210     b->size = 16;

   211     int r;

   213     UCX_TEST_BEGIN

   215     r = ucx_buffer_seek(b, -5, SEEK_END);

   216     UCX_TEST_ASSERT(r == 0, "seek END-5 failed");

   217     UCX_TEST_ASSERT(b->pos == 11, "seek END-5 set wrong position");

   220     UCX_TEST_END

   222     ucx_buffer_free(b);

   223 }

   225 UCX_TEST(test_ucx_buffer_putc) {

   226     char *buffer = (char*) malloc(16);

   227     memset(buffer, 32, 16);

   229     UcxBuffer *b = ucx_buffer_new(buffer, 16, UCX_BUFFER_DEFAULT);

   230     b->size = b->capacity;

   232     UCX_TEST_BEGIN

   234     ucx_buffer_seek(b, 0, SEEK_SET);

   235     UCX_TEST_ASSERT(ucx_buffer_putc(b, '0'|~0xFF) == '0',

   236             "putc shall return (arg & 0xFF)");

   237     ucx_buffer_putc(b, '0');

   238     ucx_buffer_putc(b, '0');

   240     UCX_TEST_ASSERT(b->pos == 3, "pos wrong after first 3 puts");

   241     ucx_buffer_seek(b, 10, SEEK_CUR);

   243     ucx_buffer_putc(b, '0');

   244     ucx_buffer_putc(b, '0');

   245     ucx_buffer_putc(b, '0');

   247     UCX_TEST_ASSERT(b->pos == 16, "pos wrong after last 3 puts");

   249     UCX_TEST_ASSERT(!memcmp(b->space, "000          000", 16),

   250             "buffer content wrong")

   251     UCX_TEST_END

   252     ucx_buffer_free(b);

   253     free(buffer);

   254 }

   256 UCX_TEST(test_ucx_buffer_putc_oob) {

   257     UcxBuffer *b = ucx_buffer_new(NULL, 2, UCX_BUFFER_DEFAULT);

   259     UCX_TEST_BEGIN

   260     b->pos = b->size = b->capacity = 1;

   261     b->space[1] = 'X';

   263     UCX_TEST_ASSERT(ucx_buffer_putc(b, 48) == EOF, "put shall return EOF "

   264             "when buffer is full and auto extend is disabled");

   265     UCX_TEST_ASSERT(!memcmp(b->space, "\0X", 2),

   266             "wrong buffer content after failed putc");

   268     UCX_TEST_END

   270     ucx_buffer_free(b);

   271 }

   274 UCX_TEST(test_ucx_buffer_putc_ae) {

   275     UcxBuffer *b = ucx_buffer_new(NULL, 2, UCX_BUFFER_AUTOEXTEND);

   276     ucx_buffer_putc(b, '0');

   277     ucx_buffer_putc(b, '1');

   279     UCX_TEST_BEGIN

   281     UCX_TEST_ASSERT(b->pos == 2, "pos wrong after first 2 puts");

   282     UCX_TEST_ASSERT(b->size == 2, "size wrong after first 2 puts");

   283     UCX_TEST_ASSERT(b->capacity == 2, "buffer erroneously extended");

   284     UCX_TEST_ASSERT(!memcmp(b->space,"01", 2), "wrong content");

   286     UCX_TEST_END

   288     ucx_buffer_free(b);

   289 }

   291 UCX_TEST(test_ucx_buffer_putc_oobae) {

   292     UcxBuffer *b = ucx_buffer_new(NULL, 2, UCX_BUFFER_AUTOEXTEND);

   293     ucx_buffer_putc(b, '0');

   294     ucx_buffer_putc(b, '1');

   296     UCX_TEST_BEGIN

   298     ucx_buffer_putc(b, 'a');

   300     UCX_TEST_ASSERT(b->pos == 3, "pos wrong after put");

   301     UCX_TEST_ASSERT(b->capacity == 4, "buffer not properly extended");

   302     UCX_TEST_ASSERT(b->size == 3, "wrong buffer size");

   304     UCX_TEST_ASSERT(!memcmp(b->space,"01a\0", 4), "wrong content");

   306     UCX_TEST_END

   308     ucx_buffer_free(b);

   309 }

   311 UCX_TEST(test_ucx_buffer_putc_size) {

   312     UcxBuffer *b = ucx_buffer_new(NULL, 4, UCX_BUFFER_DEFAULT);

   314     UCX_TEST_BEGIN

   316     UCX_TEST_ASSERT(b->size == 0, "wrong initial size");

   317     ucx_buffer_putc(b, 'a');

   318     ucx_buffer_putc(b, 'b');

   319     ucx_buffer_putc(b, 'c');

   320     UCX_TEST_ASSERT(b->size == 3, "size does not increase");

   321     ucx_buffer_seek(b, 1, SEEK_SET);

   322     ucx_buffer_putc(b, 'd');

   323     UCX_TEST_ASSERT(b->size == 3, "size shall not decrease");

   324     UCX_TEST_ASSERT(b->pos == 2, "wrong position after seek and putc");

   326     UCX_TEST_END

   328     ucx_buffer_free(b);

   329 }

   331 UCX_TEST(test_ucx_buffer_getc) {

   332     char *buffer = (char*) malloc(16);

   333     memset(buffer, 32, 8);

   334     for (int i = 8; i < 16 ; i++) {

   335         buffer[i] = 40+i;

   336     }

   338     UcxBuffer *b = ucx_buffer_new(buffer, 16, UCX_BUFFER_DEFAULT);

   339     b->size = b->capacity;

   341     UCX_TEST_BEGIN

   343     char rb[16];

   344     for (size_t i = 0 ; i < 16 ; i++) {

   345         UCX_TEST_ASSERT(b->pos == i, "wrong position");

   346         UCX_TEST_ASSERT(!ucx_buffer_eof(b), "EOF false positive");

   347         rb[i] = ucx_buffer_getc(b);

   348     }

   349     UCX_TEST_ASSERT(memcmp(rb, "        01234567", 16) == 0,

   350         "read data incorrect");

   352     UCX_TEST_ASSERT(ucx_buffer_eof(b), "EOF not set after last possible read");

   353     UCX_TEST_ASSERT(b->pos == 16, "wrong position after EOF");

   355     UCX_TEST_ASSERT(ucx_buffer_getc(b) == EOF,

   356         "out of bounds read does not return EOF");

   357     UCX_TEST_ASSERT(b->pos == 16, "wrong position after out of bounds read");

   359     UCX_TEST_END

   361     ucx_buffer_free(b);

   362     free(buffer);

   363 }

   365 UCX_TEST(test_ucx_buffer_write) {

   366     char *buffer = (char*) malloc(32);

   367     memset(buffer, 0, 32);

   369     memset(buffer, 32, 8);

   370     for (int i = 8; i < 16 ; i++) {

   371         buffer[i] = 40+i;

   372     }

   374     UcxBuffer *b = ucx_buffer_new(buffer, 32, UCX_BUFFER_DEFAULT);

   375     int r;

   377     UCX_TEST_BEGIN

   378     b->pos = 4;

   379     r = ucx_buffer_write("test string", 1, 11, b);

   380     UCX_TEST_ASSERT(r == 11, "returned incorrect number of written bytes");

   381     UCX_TEST_ASSERT(b->pos == 15, "incorrect position");

   382     UCX_TEST_ASSERT(memcmp(buffer, "    test string7\0\0", 18) == 0,

   383         "incorrect buffer content (test string)");

   385     r = ucx_buffer_write(".", 1, 1, b);

   386     UCX_TEST_ASSERT(r == 1, "returned incorrect number of written elements");

   387     UCX_TEST_ASSERT(b->pos == 16, "incorrect position");

   389     int32_t testarr[4] = {0x09abcdef, 0x05fedcba, 0x01abefcd, 0x3cd07ab};

   390     r = ucx_buffer_write(testarr, 4, 4, b);

   391     UCX_TEST_ASSERT(r = 4, "returned incorrect number of written elements");

   392     UCX_TEST_ASSERT(b->pos == 32, "incorrect position");

   394     char cmp[32];

   395     memset(cmp, 0, 32);

   396     memcpy(cmp, "    test string.", 16);

   397     int32_t *ptr = (int32_t*) (cmp+16);

   398     ptr[0] = testarr[0];

   399     ptr[1] = testarr[1];

   400     ptr[2] = testarr[2];

   401     ptr[3] = testarr[3];

   402     UCX_TEST_ASSERT(memcmp(buffer, cmp, 32) == 0,

   403         "incorrect buffer content (int array)");

   405     UCX_TEST_END

   407     ucx_buffer_free(b);

   408     free(buffer);

   409 }

   411 UCX_TEST(test_ucx_buffer_write_oob) {

   412     char *buffer = (char*) malloc(32);

   413     memset(buffer, 0, 32);

   415     UcxBuffer *b = ucx_buffer_new(buffer, 15, UCX_BUFFER_DEFAULT);

   416     int r;

   418     UCX_TEST_BEGIN

   419     r = ucx_buffer_write("a very long string", 1, 18, b);

   420     UCX_TEST_ASSERT(r == 15, "incorrect number of written bytes");

   421     UCX_TEST_ASSERT(memcmp(buffer, "a very long str\0\0\0", 18) == 0,

   422         "invalid buffer content (test string)");

   424     b->size = b->pos = 0;

   425     int32_t intarr[4] = {0,-1,0,-1};

   426     memset(buffer, 0, 32);

   428     r = ucx_buffer_write(intarr, 4, 4, b);

   429     UCX_TEST_ASSERT(r == 3, "incorrect number of written elements");

   430     UCX_TEST_ASSERT(memcmp(buffer,

   431         "\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0", 16) == 0,

   432         "invalid buffer content (test string)");

   434     UCX_TEST_END

   436     ucx_buffer_free(b);

   437     free(buffer);

   438 }

   440 UCX_TEST(test_ucx_buffer_write_ax) {

   441     char *buffer = (char*) malloc(16);

   442     memset(buffer, 0, 16);

   444     UcxBuffer *b = ucx_buffer_new(buffer, 16,

   445             UCX_BUFFER_AUTOEXTEND | UCX_BUFFER_AUTOFREE);

   446     int r;

   448     UCX_TEST_BEGIN

   450     const char* teststring = "this is way too much";

   451     r = ucx_buffer_write((void*)teststring, 1, 20, b);

   452     buffer = (char*) b->space; /*autoextend enabled, we MUST retrieve pointer*/

   453     UCX_TEST_ASSERT(r == 20, "not all characters written");

   454     UCX_TEST_ASSERT(b->capacity == 32, "buffer not properly extended");

   455     UCX_TEST_ASSERT(b->pos == 20, "position incorrect");

   456     UCX_TEST_ASSERT(memcmp(buffer,

   457             "this is way too much\0\0\0\0\0\0\0\0\0\0\0\0", 32) == 0,

   458             "incorrect buffer content");

   460     UCX_TEST_END

   462     ucx_buffer_free(b);

   463 }

   465 UCX_TEST(test_ucx_buffer_read) {

   466     UcxBuffer *b = ucx_buffer_new(NULL, 8, UCX_BUFFER_AUTOFREE);

   467     ucx_buffer_write("01234567", 1, 8, b);

   468     b->pos = 0;

   470     char buf[32];

   471     memset(buf, 'X', 32);

   472     int r;

   474     UCX_TEST_BEGIN

   476     ucx_buffer_seek(b, 2, SEEK_SET);

   477     r = ucx_buffer_read(buf, 1, 2, b);

   478     UCX_TEST_ASSERT(r == 2, "wrong number of bytes read (2 items)");

   479     UCX_TEST_ASSERT(buf[0] == '2' && buf[1] == '3' && buf[2] == 'X',

   480             "buffer incorrect after read");

   481     UCX_TEST_ASSERT(b->pos == 4, "wrong position after read (2 items)");

   483     UCX_TEST_END

   485     ucx_buffer_free(b);

   486 }

   488 UCX_TEST(test_ucx_buffer_read_oob) {

   489     UcxBuffer *b = ucx_buffer_new(NULL, 8, UCX_BUFFER_AUTOFREE);

   490     ucx_buffer_write("01234567", 1, 8, b);

   492     char buf[32];

   493     memset(buf, 'X', 32);

   494     int r;

   496     UCX_TEST_BEGIN

   498     b->pos = 2;

   499     r = ucx_buffer_read(buf + 2, 1, 8, b);

   500     UCX_TEST_ASSERT(r == 6, "wrong number of bytes read (8 items)");

   501     UCX_TEST_ASSERT(memcmp(buf, "XX234567XX", 10) == 0,

   502             "buffer incorrect after read");

   503     UCX_TEST_ASSERT(b->pos == 8,

   504         "wrong position after read (8 items out of bound)");

   506     b->pos = 0;

   507     memset(buf, 'X', 32);

   509     r = ucx_buffer_read(buf, 3, 3, b);

   511     UCX_TEST_ASSERT(r == 2, "wrong number of blocks read");

   512     UCX_TEST_ASSERT(memcmp(buf, "012345XX", 8) == 0,

   513             "buffer incorrect after block out of bounds read");

   515     r = ucx_buffer_read(buf+6, 1, 5, b);

   517     UCX_TEST_ASSERT(r == 2, "wrong number of remaining bytes read");

   518     UCX_TEST_ASSERT(memcmp(buf, "01234567XX", 10) == 0,

   519             "buffer incorrect after remaining byte read");

   521     UCX_TEST_END

   523     ucx_buffer_free(b);

   524 }

   526 UCX_TEST(test_ucx_buffer_extract) {

   527     char *buffer = (char*) malloc(16);

   528     strcpy(buffer, "this is a test!");

   530     UcxBuffer *src = ucx_buffer_new(buffer, 16, UCX_BUFFER_AUTOFREE);

   531     src->size = 16;

   532     UcxBuffer *dst = ucx_buffer_extract(src, 5, 5, UCX_BUFFER_AUTOEXTEND);

   534     UCX_TEST_BEGIN

   535     UCX_TEST_ASSERT(dst != NULL, "ucx_buffer_extract returned NULL");

   536     UCX_TEST_ASSERT(dst->flags == (UCX_BUFFER_AUTOEXTEND | UCX_BUFFER_AUTOFREE),

   537             "autofree flag shall be enforced");

   538     UCX_TEST_ASSERT(dst->size == 5, "wrong size for new buffer");

   539     UCX_TEST_ASSERT(dst->capacity == 5, "wrong capacity for new buffer");

   540     UCX_TEST_ASSERT(dst->pos == 0, "wrong position for new buffer");

   541     char rb[5];

   542     ucx_buffer_read(rb, 1, 5, dst);

   543     UCX_TEST_ASSERT(memcmp(rb, "is a ", 5) == 0,

   544             "new buffer has incorrect content");

   546     UCX_TEST_END

   548     ucx_buffer_free(dst);

   549     ucx_buffer_free(src);

   550 }

   552 UCX_TEST(test_ucx_buffer_extract_oob) {

   553     char *buffer = (char*) malloc(16);

   554     strcpy(buffer, "this is a test!");

   556     UcxBuffer *src = ucx_buffer_new(buffer, 16, UCX_BUFFER_AUTOFREE);

   557     src->size = 16;

   559     UCX_TEST_BEGIN

   561     UCX_TEST_ASSERT(ucx_buffer_extract(src, 5, 0, UCX_BUFFER_DEFAULT) == NULL,

   562             "extract shall fail on zero length");

   563     UCX_TEST_ASSERT(ucx_buffer_extract(src, 10, 10, UCX_BUFFER_DEFAULT) == NULL,

   564             "extract shall fail on invalid bounds (size exceeds limits)");

   565     UCX_TEST_ASSERT(ucx_buffer_extract(src, 20, -7, UCX_BUFFER_DEFAULT) == NULL,

   566             "extract shall fail on invalid bounds (start exceeds limits)");

   568     UCX_TEST_END

   570     ucx_buffer_free(src);

   571 }

   573 UCX_TEST(test_ucx_buffer_extract_overflow) {

   574     char *buffer = (char*) malloc(16);

   575     strcpy(buffer, "this is a test!");

   577     UcxBuffer *src = ucx_buffer_new(buffer, 16, UCX_BUFFER_AUTOFREE);

   578     src->size = 16;

   580     UCX_TEST_BEGIN

   582     UCX_TEST_ASSERT(ucx_buffer_extract(src, 5, (size_t)-4,

   583         UCX_BUFFER_DEFAULT) == NULL, "extract shall fail on integer overflow");

   585     UCX_TEST_END

   587     ucx_buffer_free(src);

   588 }

   590 UCX_TEST(test_ucx_buffer_extend) {

   592     UcxBuffer *b = ucx_buffer_new(NULL, 10, UCX_BUFFER_DEFAULT);

   594     UCX_TEST_BEGIN

   596     UCX_TEST_ASSERT(ucx_buffer_extend(b, 15) == 0, "shall return 0 on success");

   597     UCX_TEST_ASSERT(b->capacity = 40, "wrong capacity");

   598     UCX_TEST_ASSERT((b->size == 0 && b->pos == 0),

   599         "pos and size shall remain unchanged");

   601     UCX_TEST_ASSERT(ucx_buffer_extend(b, (size_t) - 61) != 0,

   602         "shall fail and return a non-zero value on overflow");

   604     UCX_TEST_END

   606     ucx_buffer_free(b);

   607 }

Mercurial > hg > ucx / file revision

test/buffer_tests.c@740fbd7bab71

test/buffer_tests.c