testsuite/test-strbuf.c

   1 // SPDX-License-Identifier: LGPL-2.1-or-later
   2 /*
   3  * Copyright (C)  2014 Intel Corporation. All rights reserved.
   4  */
   5
   6 #include <stddef.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11
  12 #include <shared/strbuf.h>
  13 #include <shared/util.h>
  14
  15 #include "testsuite.h"
  16
  17 static const char *TEXT =
  18         "this is a very long test that is longer than the size we initially se in the strbuf";
  19
  20 static int test_strbuf_pushchar(void)
  21 {
  22         _cleanup_strbuf_ struct strbuf buf;
  23         const char *result;
  24         const char *c;
  25
  26         strbuf_init(&buf);
  27
  28         for (c = TEXT; *c != '\0'; c++)
  29                 strbuf_pushchar(&buf, *c);
  30
  31         result = strbuf_str(&buf);
  32         assert_return(result == buf.bytes, EXIT_FAILURE);
  33         assert_return(streq(result, TEXT), EXIT_FAILURE);
  34
  35         return 0;
  36 }
  37 DEFINE_TEST(test_strbuf_pushchar, .description = "test strbuf_{pushchar, str, steal}");
  38
  39 static int test_strbuf_pushchars(void)
  40 {
  41         _cleanup_strbuf_ struct strbuf buf;
  42         const char *result;
  43         char *saveptr = NULL, *str;
  44         const char *c;
  45         size_t lastwordlen = 0;
  46
  47         strbuf_init(&buf);
  48         str = strdup(TEXT);
  49         for (c = strtok_r(str, " ", &saveptr); c != NULL;
  50              c = strtok_r(NULL, " ", &saveptr)) {
  51                 strbuf_pushchars(&buf, c);
  52                 strbuf_pushchar(&buf, ' ');
  53                 lastwordlen = strlen(c);
  54         }
  55
  56         /*
  57          * Replace the last space char, which also guarantees there's at least 1 char
  58          * available for the '\0' added by strbuf_str() so result1 == buf.bytes should be
  59          * true
  60          */
  61         strbuf_popchar(&buf);
  62         result = strbuf_str(&buf);
  63         assert_return(result == buf.bytes, EXIT_FAILURE);
  64         assert_return(streq(result, TEXT), EXIT_FAILURE);
  65
  66         strbuf_popchars(&buf, lastwordlen);
  67         result = strbuf_str(&buf);
  68         assert_return(!streq(TEXT, result), EXIT_FAILURE);
  69         assert_return(strncmp(TEXT, result, strlen(TEXT) - lastwordlen) == 0,
  70                       EXIT_FAILURE);
  71         assert_return(result[strlen(TEXT) - lastwordlen] == '\0', EXIT_FAILURE);
  72
  73         free(str);
  74
  75         return 0;
  76 }
  77 DEFINE_TEST(test_strbuf_pushchars,
  78             .description = "test strbuf_{pushchars, popchar, popchars}");
  79
  80 static int test_strbuf_with_stack(void)
  81 {
  82         const char test[] = "test-something-small";
  83         const char *stack_buf;
  84         const char *p;
  85         DECLARE_STRBUF_WITH_STACK(buf, 256);
  86         DECLARE_STRBUF_WITH_STACK(buf2, sizeof(test) + 1);
  87         DECLARE_STRBUF_WITH_STACK(buf3, sizeof(test) + 1);
  88
  89         strbuf_pushchars(&buf, test);
  90         assert_return(streq(test, strbuf_str(&buf)), EXIT_FAILURE);
  91         p = strbuf_str(&buf);
  92         assert_return(streq(test, p), EXIT_FAILURE);
  93
  94         strbuf_pushchars(&buf2, test);
  95         assert_return(streq(test, strbuf_str(&buf2)), EXIT_FAILURE);
  96         /* It fits on stack, but when we steal, we get a copy on heap */
  97         p = strbuf_str(&buf2);
  98         assert_return(streq(test, p), EXIT_FAILURE);
  99
 100         /*
 101          * Check assumption about buffer being on stack vs heap is indeed valid.
 102          * Not to be done in real code.
 103          */
 104         strbuf_clear(&buf3);
 105         stack_buf = buf3.bytes;
 106         strbuf_pushchars(&buf3, test);
 107         assert_return(stack_buf == buf3.bytes, EXIT_FAILURE);
 108
 109         assert_return(streq(test, strbuf_str(&buf3)), EXIT_FAILURE);
 110         assert_return(stack_buf == buf3.bytes, EXIT_FAILURE);
 111
 112         strbuf_pushchars(&buf3, "-overflow");
 113         assert_return(stack_buf != buf3.bytes, EXIT_FAILURE);
 114
 115         return 0;
 116 }
 117 DEFINE_TEST(test_strbuf_with_stack, .description = "test strbuf with stack");
 118
 119 static int test_strbuf_with_heap(void)
 120 {
 121         DECLARE_STRBUF(heapbuf);
 122
 123         assert_return(heapbuf.bytes == NULL, EXIT_FAILURE);
 124         assert_return(heapbuf.size == 0, EXIT_FAILURE);
 125         assert_return(heapbuf.used == 0, EXIT_FAILURE);
 126         strbuf_pushchars(&heapbuf, "-overflow");
 127         assert_return(heapbuf.bytes != NULL, EXIT_FAILURE);
 128         assert_return(heapbuf.size != 0, EXIT_FAILURE);
 129         assert_return(heapbuf.used != 0, EXIT_FAILURE);
 130
 131         return 0;
 132 }
 133 DEFINE_TEST(test_strbuf_with_heap, .description = "test strbuf with heap only");
 134
 135 static int test_strbuf_pushmem(void)
 136 {
 137         _cleanup_strbuf_ struct strbuf buf;
 138
 139         strbuf_init(&buf);
 140         strbuf_pushmem(&buf, "", 0);
 141         strbuf_pushmem(&buf, TEXT, strlen(TEXT) + 1);
 142
 143         assert_return(streq(TEXT, strbuf_str(&buf)), EXIT_FAILURE);
 144
 145         return 0;
 146 }
 147 DEFINE_TEST(test_strbuf_pushmem, .description = "test strbuf_reserve");
 148
 149 static int test_strbuf_used(void)
 150 {
 151         _cleanup_strbuf_ struct strbuf buf;
 152
 153         strbuf_init(&buf);
 154         assert_return(strbuf_used(&buf) == 0, EXIT_FAILURE);
 155
 156         strbuf_pushchars(&buf, TEXT);
 157         assert_return(strbuf_used(&buf) == strlen(TEXT), EXIT_FAILURE);
 158
 159         strbuf_pushchar(&buf, 'a');
 160         strbuf_popchar(&buf);
 161         assert_return(strbuf_used(&buf) == strlen(TEXT), EXIT_FAILURE);
 162
 163         assert_return(streq(TEXT, strbuf_str(&buf)), EXIT_FAILURE);
 164         assert_return(strbuf_used(&buf) == strlen(TEXT), EXIT_FAILURE);
 165
 166         strbuf_pushchar(&buf, '\0');
 167         assert_return(streq(TEXT, strbuf_str(&buf)), EXIT_FAILURE);
 168         assert_return(strbuf_used(&buf) == strlen(TEXT) + 1, EXIT_FAILURE);
 169
 170         return 0;
 171 }
 172 DEFINE_TEST(test_strbuf_used, .description = "test strbuf_used");
 173
 174 static int test_strbuf_shrink_to(void)
 175 {
 176         _cleanup_strbuf_ struct strbuf buf;
 177
 178         strbuf_init(&buf);
 179         strbuf_shrink_to(&buf, 0);
 180         assert_return(strbuf_used(&buf) == 0, EXIT_FAILURE);
 181
 182         strbuf_pushchars(&buf, TEXT);
 183         strbuf_shrink_to(&buf, strlen(TEXT) - 1);
 184         assert_return(strbuf_used(&buf) == strlen(TEXT) - 1, EXIT_FAILURE);
 185
 186         return 0;
 187 }
 188 DEFINE_TEST(test_strbuf_shrink_to, .description = "test strbuf_shrink_to");
 189
 190 static int xfail_strbuf_shrink_to(void)
 191 {
 192         _cleanup_strbuf_ struct strbuf buf;
 193
 194         strbuf_init(&buf);
 195         strbuf_pushchar(&buf, '/');
 196
 197         /* This should crash on assert */
 198         strbuf_shrink_to(&buf, 2);
 199
 200         return 0;
 201 }
 202 DEFINE_TEST(xfail_strbuf_shrink_to, .description = "xfail strbuf_shrink_to",
 203             .expected_fail = true);
 204
 205 TESTSUITE_MAIN();