ucx: test/buffer_tests.c@9c1591b3c4a4

     1 /*

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

     3  *

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

    30 #include <stdint.h>

    32 UCX_TEST(test_ucx_buffer_new) {

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

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

    35     UCX_TEST_BEGIN

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

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

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

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

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

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

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

    47         "wrong flags for autoextending buffer");

    48     UCX_TEST_ASSERT(b2->flags==UCX_BUFFER_AUTOFREE,

    49         "wrong flags for default bufer");

    51     UCX_TEST_END

    52     ucx_buffer_free(b2);

    53     ucx_buffer_free(b);

    54 }

    56 UCX_TEST(test_ucx_buffer_new_prealloc) {

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

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

    59     UCX_TEST_BEGIN

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

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

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

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

    67     UCX_TEST_END

    68     free(test);

    69     ucx_buffer_free(b);

    70 }

    72 UCX_TEST(test_ucx_buffer_eof) {

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

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

    75     UCX_TEST_BEGIN

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

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

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

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

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

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

    82     UCX_TEST_END

    83     ucx_buffer_free(b);

    84 }

    86 UCX_TEST(test_ucx_buffer_seek_overflow) {

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

    88     b->size = 32;

    89     int r;

    91     UCX_TEST_BEGIN

    92     const size_t sizemax = (size_t)-1;

    93     size_t bigpos = sizemax - 5000;

    94     b->pos = bigpos;

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

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

    97     UCX_TEST_ASSERT(b->pos == bigpos,

    98             "failed seek shall leave pos unchanged");

   100     b->pos = 0;

   101     b->size = (sizemax >> 1) + 32;

   103     // we don't want to risk overflows in implicit constant casts

   104     const size_t bigoff_comp = (sizemax >> 1) - 16;

   105     off_t bigoff = (off_t)bigoff_comp;

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

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

   109     UCX_TEST_ASSERT(b->pos == 0,

   110             "failed seek shall leave pos unchanged");

   112     UCX_TEST_END

   114     ucx_buffer_free(b);

   115 }

   117 UCX_TEST(test_ucx_buffer_seek_invalid) {

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

   119     b->pos = 7;

   120     int r;

   122     UCX_TEST_BEGIN

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

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

   125     UCX_TEST_ASSERT(b->pos == 7,

   126             "failed seek shall leave pos unchanged");

   127     UCX_TEST_END

   129     ucx_buffer_free(b);

   130 }

   132 UCX_TEST(test_ucx_buffer_seek_oob) {

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

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

   135     b->pos = 7;

   136     int r;

   138     UCX_TEST_BEGIN

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

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

   142     UCX_TEST_ASSERT(b->pos == 7,

   143             "failed seek shall leave pos unchanged");

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

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

   147     UCX_TEST_ASSERT(b->pos == 7,

   148             "failed seek shall leave pos unchanged");

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

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

   152     UCX_TEST_ASSERT(b->pos == 7,

   153             "failed seek shall leave pos unchanged");

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

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

   157     UCX_TEST_ASSERT(b->pos == 7,

   158             "failed seek shall leave pos unchanged");

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

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

   162     UCX_TEST_ASSERT(b->pos == 7,

   163             "failed seek shall leave pos unchanged");

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

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

   167     UCX_TEST_ASSERT(b->pos == 7,

   168             "failed seek shall leave pos unchanged");

   170     UCX_TEST_END

   172     ucx_buffer_free(b);

   173 }

   175 UCX_TEST(test_ucx_buffer_seek_set) {

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

   177     b->size = 16;

   178     int r;

   180     UCX_TEST_BEGIN

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

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

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

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

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

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

   191     UCX_TEST_END

   193     ucx_buffer_free(b);

   194 }

   196 UCX_TEST(test_ucx_buffer_seek_cur) {

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

   198     b->size = 16;

   199     int r;

   201     UCX_TEST_BEGIN

   203     b->pos = 7;

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

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

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

   208     UCX_TEST_END

   210     ucx_buffer_free(b);

   211 }

   213 UCX_TEST(test_ucx_buffer_seek_end) {

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

   215     b->size = 16;

   216     int r;

   218     UCX_TEST_BEGIN

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

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

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

   225     UCX_TEST_END

   227     ucx_buffer_free(b);

   228 }

   230 UCX_TEST(test_ucx_buffer_putc) {

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

   232     memset(buffer, 32, 16);

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

   235     b->size = b->capacity;

   237     UCX_TEST_BEGIN

   239     ucx_buffer_seek(b, 0, SEEK_SET);

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

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

   242     ucx_buffer_putc(b, '0');

   243     ucx_buffer_putc(b, '0');

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

   246     ucx_buffer_seek(b, 10, SEEK_CUR);

   248     ucx_buffer_putc(b, '0');

   249     ucx_buffer_putc(b, '0');

   250     ucx_buffer_putc(b, '0');

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

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

   255             "buffer content wrong")

   256     UCX_TEST_END

   257     ucx_buffer_free(b);

   258     free(buffer);

   259 }

   261 UCX_TEST(test_ucx_buffer_putc_oob) {

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

   264     UCX_TEST_BEGIN

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

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

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

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

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

   271             "wrong buffer content after failed putc");

   273     UCX_TEST_END

   275     ucx_buffer_free(b);

   276 }

   279 UCX_TEST(test_ucx_buffer_putc_ae) {

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

   281     ucx_buffer_putc(b, '0');

   282     ucx_buffer_putc(b, '1');

   284     UCX_TEST_BEGIN

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

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

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

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

   291     UCX_TEST_END

   293     ucx_buffer_free(b);

   294 }

   296 UCX_TEST(test_ucx_buffer_putc_oobae) {

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

   298     ucx_buffer_putc(b, '0');

   299     ucx_buffer_putc(b, '1');

   301     UCX_TEST_BEGIN

   303     ucx_buffer_putc(b, 'a');

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

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

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

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

   311     UCX_TEST_END

   313     ucx_buffer_free(b);

   314 }

   316 UCX_TEST(test_ucx_buffer_putc_size) {

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

   319     UCX_TEST_BEGIN

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

   322     ucx_buffer_putc(b, 'a');

   323     ucx_buffer_putc(b, 'b');

   324     ucx_buffer_putc(b, 'c');

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

   326     ucx_buffer_seek(b, 1, SEEK_SET);

   327     ucx_buffer_putc(b, 'd');

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

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

   331     UCX_TEST_END

   333     ucx_buffer_free(b);

   334 }

   336 UCX_TEST(test_ucx_buffer_getc) {

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

   338     memset(buffer, 32, 8);

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

   340         buffer[i] = 40+i;

   341     }

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

   344     b->size = b->capacity;

   346     unsigned char ubuffer[] = {127, 128, 129, 130};

   347     UcxBuffer *ub = ucx_buffer_new(ubuffer, 4, UCX_BUFFER_DEFAULT);

   348     ub->size = 4;

   350     UCX_TEST_BEGIN

   352     char rb[16];

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

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

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

   356         rb[i] = ucx_buffer_getc(b);

   357     }

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

   359         "read data incorrect");

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

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

   364     UCX_TEST_ASSERT(ucx_buffer_getc(b) == EOF,

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

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

   368     int uc[5];

   369     for(int i=0;i<5;i++) {

   370         uc[i] = ucx_buffer_getc(ub);

   371     }

   372     UCX_TEST_ASSERT(uc[0] == 127, "wrong unsigned value(0)");

   373     UCX_TEST_ASSERT(uc[1] == 128, "wrong unsigned value(0)");

   374     UCX_TEST_ASSERT(uc[2] == 129, "wrong unsigned value(0)");

   375     UCX_TEST_ASSERT(uc[3] == 130, "wrong unsigned value(0)");

   376     UCX_TEST_ASSERT(uc[4] == EOF, "EOF not set after last ub read");

   378     UCX_TEST_END

   380     ucx_buffer_free(b);

   381     ucx_buffer_free(ub);

   382     free(buffer);

   383 }

   385 UCX_TEST(test_ucx_buffer_write) {

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

   387     memset(buffer, 0, 32);

   389     memset(buffer, 32, 8);

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

   391         buffer[i] = 40+i;

   392     }

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

   395     int r;

   397     UCX_TEST_BEGIN

   398     b->pos = 4;

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

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

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

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

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

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

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

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

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

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

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

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

   414     char cmp[32];

   415     memset(cmp, 0, 32);

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

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

   418     ptr[0] = testarr[0];

   419     ptr[1] = testarr[1];

   420     ptr[2] = testarr[2];

   421     ptr[3] = testarr[3];

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

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

   425     UCX_TEST_END

   427     ucx_buffer_free(b);

   428     free(buffer);

   429 }

   431 UCX_TEST(test_ucx_buffer_write_oob) {

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

   433     memset(buffer, 0, 32);

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

   436     int r;

   438     UCX_TEST_BEGIN

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

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

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

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

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

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

   446     memset(buffer, 0, 32);

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

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

   450     UCX_TEST_ASSERT(memcmp(buffer,

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

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

   454     UCX_TEST_END

   456     ucx_buffer_free(b);

   457     free(buffer);

   458 }

   460 UCX_TEST(test_ucx_buffer_write_ax) {

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

   462     memset(buffer, 0, 16);

   464     UcxBuffer *b = ucx_buffer_new(buffer, 16,

   465             UCX_BUFFER_AUTOEXTEND | UCX_BUFFER_AUTOFREE);

   466     int r;

   468     UCX_TEST_BEGIN

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

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

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

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

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

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

   476     UCX_TEST_ASSERT(memcmp(buffer,

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

   478             "incorrect buffer content");

   480     UCX_TEST_END

   482     ucx_buffer_free(b);

   483 }

   485 UCX_TEST(test_ucx_buffer_read) {

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

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

   488     b->pos = 0;

   490     char buf[32];

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

   492     int r;

   494     UCX_TEST_BEGIN

   496     ucx_buffer_seek(b, 2, SEEK_SET);

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

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

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

   500             "buffer incorrect after read");

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

   503     UCX_TEST_END

   505     ucx_buffer_free(b);

   506 }

   508 UCX_TEST(test_ucx_buffer_read_oob) {

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

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

   512     char buf[32];

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

   514     int r;

   516     UCX_TEST_BEGIN

   518     b->pos = 2;

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

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

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

   522             "buffer incorrect after read");

   523     UCX_TEST_ASSERT(b->pos == 8,

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

   526     b->pos = 0;

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

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

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

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

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

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

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

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

   539             "buffer incorrect after remaining byte read");

   541     UCX_TEST_END

   543     ucx_buffer_free(b);

   544 }

   546 UCX_TEST(test_ucx_buffer_extract) {

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

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

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

   551     src->size = 16;

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

   554     UCX_TEST_BEGIN

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

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

   557             "autofree flag shall be enforced");

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

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

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

   561     char rb[5];

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

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

   564             "new buffer has incorrect content");

   566     UCX_TEST_END

   568     ucx_buffer_free(dst);

   569     ucx_buffer_free(src);

   570 }

   572 UCX_TEST(test_ucx_buffer_extract_oob) {

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

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

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

   577     src->size = 16;

   579     UCX_TEST_BEGIN

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

   582             "extract shall fail on zero length");

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

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

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

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

   588     UCX_TEST_END

   590     ucx_buffer_free(src);

   591 }

   593 UCX_TEST(test_ucx_buffer_extract_overflow) {

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

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

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

   598     src->size = 16;

   600     UCX_TEST_BEGIN

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

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

   605     UCX_TEST_END

   607     ucx_buffer_free(src);

   608 }

   610 UCX_TEST(test_ucx_buffer_extend) {

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

   614     UCX_TEST_BEGIN

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

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

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

   619         "pos and size shall remain unchanged");

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

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

   624     UCX_TEST_END

   626     ucx_buffer_free(b);

   627 }

Mercurial > hg > ucx / file revision

test/buffer_tests.c@9c1591b3c4a4

test/buffer_tests.c