ucx: test/buffer_tests.c@1d3500806565

     1 /*

     2  *

     3  */

     5 #include "buffer_tests.h"

     7 UCX_TEST_IMPLEMENT(test_ucx_buffer_seektell) {

     8     char *buffer = malloc(16);

     9     memset(buffer, 32, 7);

    10     buffer[7] = 0;

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

    13     int r;

    15     UCX_TEST_BEGIN

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

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

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

    21     r = ucx_buffer_seek(b, 20, SEEK_SET);

    22     UCX_TEST_ASSERT(r != 0, "seek beyond bounds shall fail");

    23     UCX_TEST_ASSERT(b->pos == 5,

    24             "failed seek shall leave pos unchanged");

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

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

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

    30     r = ucx_buffer_seek(b, 10, SEEK_CUR);

    31     UCX_TEST_ASSERT(r != 0, "seek CUR beyond bounds shall fail");

    32     UCX_TEST_ASSERT(b->pos == 10,

    33             "failed seek shall leave pos unchanged");

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

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

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

    39     r = ucx_buffer_seek(b, -10, SEEK_END);

    40     UCX_TEST_ASSERT(r != 0, "seek END beyond bounds shall fail");

    41     UCX_TEST_ASSERT(b->pos == 2,

    42             "failed seek shall leave pos unchanged");

    44     UCX_TEST_END

    46     ucx_buffer_free(b);

    47     free(buffer);

    48 }

    50 UCX_TEST_IMPLEMENT(test_ucx_buffer_putc) {

    51     char *buffer = malloc(16);

    52     memset(buffer, 32, 16);

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

    55     int r;

    57     UCX_TEST_BEGIN

    59     ucx_buffer_putc(b, 48); ucx_buffer_putc(b, 48); ucx_buffer_putc(b, 48);

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

    61     ucx_buffer_seek(b, 10, SEEK_CUR);

    62     ucx_buffer_putc(b, 48); ucx_buffer_putc(b, 48); ucx_buffer_putc(b, 48);

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

    64     UCX_TEST_ASSERT(ucx_buffer_eof(b), "eof not set");

    65     UCX_TEST_ASSERT(ucx_buffer_putc(b, 48) == EOF,

    66             "put shall return EOF when buffer is full");

    67     UCX_TEST_ASSERT(memcmp(buffer, "000          000", 16) == 0,

    68             "buffer contains incorrect content");

    70     UCX_TEST_END

    72     ucx_buffer_free(b);

    73     free(buffer);

    74 }

    76 UCX_TEST_IMPLEMENT(test_ucx_buffer_getc) {

    77     char *buffer = malloc(16);

    78     memset(buffer, 32, 8);

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

    80         buffer[i] = 40+i;

    81     }

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

    84     int r;

    86     UCX_TEST_BEGIN

    88     char rb[16];

    89     for (int i = 0 ; i < 16 ; i++) {

    90         UCX_TEST_ASSERT(b->pos == i, "pos wrong during read loop");

    91         UCX_TEST_ASSERT(!ucx_buffer_eof(b),

    92                 "EOF shall not be set during read loop");

    93         rb[i] = ucx_buffer_getc(b);

    94     }

    95     UCX_TEST_ASSERT(b->pos == 16, "pos wrong after read loop");

    96     UCX_TEST_ASSERT(ucx_buffer_eof(b), "EOF not set");

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

    98             "read data incorrect");

   100     UCX_TEST_END

   102     ucx_buffer_free(b);

   103     free(buffer);

   104 }

   106 UCX_TEST_IMPLEMENT(test_ucx_buffer_write) {

   107     char *buffer = malloc(16);

   108     memset(buffer, 32, 8);

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

   110         buffer[i] = 40+i;

   111     }

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

   114     int r;

   116     UCX_TEST_BEGIN

   118     char* teststring = "this is way too much";

   119     r = ucx_buffer_write(teststring, 1, 20, b);

   120     UCX_TEST_ASSERT(r == 16, "string not correctly trimed");

   121     UCX_TEST_ASSERT(memcmp(buffer, teststring, 16) == 0,

   122             "buffer data incorrect");

   123     UCX_TEST_ASSERT(ucx_buffer_eof(b), "eof shall be set");

   125     ucx_buffer_seek(b, 8, SEEK_SET);

   126     r = ucx_buffer_write("not", 1, 3, b);

   127     UCX_TEST_ASSERT(r == 3, "three bytes should be replace");

   128     UCX_TEST_ASSERT(memcmp(buffer, "this is not too much", 16) == 0,

   129             "modified buffer is incorrect");

   131     char* threebytestring = "  t  h  r  e  e   ";

   132     memset(buffer, 49, 16);

   133     ucx_buffer_seek(b, 0, SEEK_SET);

   134     r = ucx_buffer_write(threebytestring, 3, 6, b);

   135     UCX_TEST_ASSERT(r == 15, "three byte string not correctly trimed");

   136     UCX_TEST_ASSERT(b->pos == 15,

   137             "position after write of three byte string incorrect");

   138     UCX_TEST_ASSERT(!ucx_buffer_eof(b), "eof shall not be set");

   139     UCX_TEST_ASSERT(memcmp(buffer, "  t  h  r  e  e1", 16) == 0,

   140                 "bufer is incorrect after three byte string has been written");

   142     UCX_TEST_END

   144     ucx_buffer_free(b);

   145     free(buffer);

   146 }

   148 UCX_TEST_IMPLEMENT(test_ucx_buffer_read) {

   149     char *buffer = malloc(16);

   150     memset(buffer, 56, 8);

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

   152         buffer[i] = 40+i;

   153     }

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

   156     int r;

   158     UCX_TEST_BEGIN

   160     char rb[16];

   161     memset(rb, 32, 16);

   163     ucx_buffer_seek(b, 8, SEEK_SET);

   164     r = ucx_buffer_read(rb, 1, 16, b);

   165     UCX_TEST_ASSERT(r == 8, "read did not stop at buffer end");

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

   167             "buffer incorrect after first read");

   168     UCX_TEST_ASSERT(ucx_buffer_eof(b), "eof shall be set");

   170     ucx_buffer_seek(b, 0, SEEK_SET);

   171     r = ucx_buffer_read(rb+8, 1, 8, b);

   172     UCX_TEST_ASSERT(r == 8, "read did not read the specified amount of bytes");

   173     UCX_TEST_ASSERT(memcmp(rb, "0123456788888888", 16) == 0,

   174                 "buffer incorrect after second read");

   176     ucx_buffer_seek(b, 0, SEEK_SET);

   177     r = ucx_buffer_read(rb, 3, 6, b);

   178     UCX_TEST_ASSERT(r == 15,

   179             "three byte read did not read the desired amount of bytes");

   180     UCX_TEST_ASSERT(memcmp(rb, "8888888801234568", 16) == 0,

   181                     "buffer incorrect after three byte read");

   183     UCX_TEST_END

   185     ucx_buffer_free(b);

   186     free(buffer);

   187 }

   189 UCX_TEST_IMPLEMENT(test_ucx_buffer_extract) {

   190     char *buffer = malloc(16);

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

   193     UcxBuffer *src = ucx_buffer_new(buffer, 16, UCX_BUFFER_AUTOFREE),

   194             *dst = ucx_buffer_extract(src, 5, 5, UCX_BUFFER_DEFAULT);

   196     UCX_TEST_BEGIN

   197     UCX_TEST_ASSERT((dst->flags & UCX_BUFFER_AUTOFREE) == UCX_BUFFER_AUTOFREE,

   198             "autofree flag shall be enforced");

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

   200     char rb[5];

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

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

   203             "new buffer has incorrect content");

   205     UCX_TEST_ASSERT(ucx_buffer_extract(dst, 3, 3, UCX_BUFFER_DEFAULT) == NULL,

   206             "extract shall fail on invalid bounds");

   208     UCX_TEST_END

   210     ucx_buffer_free(dst);

   211     ucx_buffer_free(src);

   212 }

Mercurial > hg > ucx / file revision