testsuite: fold test-strbuf into test-shared

Arguably improves things by providing some grouping and clarity on the
origin, structure and coverage of the tests.

Signed-off-by: Emil Velikov <emil.l.velikov@gmail.com>
Link: https://github.com/kmod-project/kmod/pull/450
Signed-off-by: Lucas De Marchi <ldemarchi@kernel.org>

diff --git a/testsuite/meson.build b/testsuite/meson.build
index 9f1cdbd9768307927764875f21fd9ee162f0ec49..731d6c24260e09179352b4ba9eccc6ad02641e66 100644 (file)
--- a/testsuite/meson.build
+++ b/testsuite/meson.build
@@ -90,7 +90,6 @@ _testsuite = [
   'test-new-module',
   'test-remove',
   'test-shared',
-  'test-strbuf',
   'test-testsuite',
   'test-util',
   'test-weakdep',

diff --git a/testsuite/test-shared.c b/testsuite/test-shared.c
index c68c9d5dfb61b69432b798a4e2a31d5b002602c6..1dc3ed035da5ea061a1cbc38efc7cca7cdc14a11 100644 (file)
--- a/testsuite/test-shared.c
+++ b/testsuite/test-shared.c
@@ -12,6 +12,7 @@
 
 #include <shared/array.h>
 #include <shared/hash.h>
+#include <shared/strbuf.h>
 #include <shared/util.h>
 
 #include "testsuite.h"
@@ -460,4 +461,193 @@ static int test_hash_massive_add_del(void)
 DEFINE_TEST(test_hash_massive_add_del,
            .description = "test multiple adds followed by multiple dels");
 
+/* strbuf sub-group */
+
+static const char *TEXT =
+       "this is a very long test that is longer than the size we initially se in the strbuf";
+
+static int test_strbuf_pushchar(void)
+{
+       _cleanup_strbuf_ struct strbuf buf;
+       const char *result;
+       const char *c;
+
+       strbuf_init(&buf);
+
+       for (c = TEXT; *c != '\0'; c++)
+               strbuf_pushchar(&buf, *c);
+
+       result = strbuf_str(&buf);
+       TS_ASSERT(result == buf.bytes);
+       TS_ASSERT(streq(result, TEXT));
+
+       return 0;
+}
+DEFINE_TEST(test_strbuf_pushchar, .description = "test strbuf_{pushchar, str, steal}");
+
+static int test_strbuf_pushchars(void)
+{
+       _cleanup_strbuf_ struct strbuf buf;
+       const char *result;
+       char *saveptr = NULL, *str;
+       const char *c;
+       size_t lastwordlen = 0;
+
+       strbuf_init(&buf);
+       str = strdup(TEXT);
+       for (c = strtok_r(str, " ", &saveptr); c != NULL;
+            c = strtok_r(NULL, " ", &saveptr)) {
+               strbuf_pushchars(&buf, c);
+               strbuf_pushchar(&buf, ' ');
+               lastwordlen = strlen(c);
+       }
+
+       /*
+        * Replace the last space char, which also guarantees there's at least 1 char
+        * available for the '\0' added by strbuf_str() so result1 == buf.bytes should be
+        * true
+        */
+       strbuf_popchar(&buf);
+       result = strbuf_str(&buf);
+       TS_ASSERT(result == buf.bytes);
+       TS_ASSERT(streq(result, TEXT));
+
+       strbuf_popchars(&buf, lastwordlen);
+       result = strbuf_str(&buf);
+       TS_ASSERT(!streq(TEXT, result));
+       TS_ASSERT(strncmp(TEXT, result, strlen(TEXT) - lastwordlen) == 0);
+       TS_ASSERT(result[strlen(TEXT) - lastwordlen] == '\0');
+
+       free(str);
+
+       return 0;
+}
+DEFINE_TEST(test_strbuf_pushchars,
+           .description = "test strbuf_{pushchars, popchar, popchars}");
+
+static int test_strbuf_with_stack(void)
+{
+       const char test[] = "test-something-small";
+       const char *stack_buf;
+       const char *p;
+       DECLARE_STRBUF_WITH_STACK(buf, 256);
+       DECLARE_STRBUF_WITH_STACK(buf2, sizeof(test) + 1);
+       DECLARE_STRBUF_WITH_STACK(buf3, sizeof(test) + 1);
+
+       strbuf_pushchars(&buf, test);
+       TS_ASSERT(streq(test, strbuf_str(&buf)));
+       p = strbuf_str(&buf);
+       TS_ASSERT(streq(test, p));
+
+       strbuf_pushchars(&buf2, test);
+       TS_ASSERT(streq(test, strbuf_str(&buf2)));
+       /* It fits on stack, but when we steal, we get a copy on heap */
+       p = strbuf_str(&buf2);
+       TS_ASSERT(streq(test, p));
+
+       /*
+        * Check assumption about buffer being on stack vs heap is indeed valid.
+        * Not to be done in real code.
+        */
+       strbuf_clear(&buf3);
+       stack_buf = buf3.bytes;
+       strbuf_pushchars(&buf3, test);
+       TS_ASSERT(stack_buf == buf3.bytes);
+
+       TS_ASSERT(streq(test, strbuf_str(&buf3)));
+       TS_ASSERT(stack_buf == buf3.bytes);
+
+       strbuf_pushchars(&buf3, "-overflow");
+       TS_ASSERT(stack_buf != buf3.bytes);
+
+       return 0;
+}
+DEFINE_TEST(test_strbuf_with_stack, .description = "test strbuf with stack");
+
+static int test_strbuf_with_heap(void)
+{
+       DECLARE_STRBUF(heapbuf);
+
+       TS_ASSERT(heapbuf.bytes == NULL);
+       TS_ASSERT(heapbuf.size == 0);
+       TS_ASSERT(heapbuf.used == 0);
+       strbuf_pushchars(&heapbuf, "-overflow");
+       TS_ASSERT(heapbuf.bytes != NULL);
+       TS_ASSERT(heapbuf.size != 0);
+       TS_ASSERT(heapbuf.used != 0);
+
+       return 0;
+}
+DEFINE_TEST(test_strbuf_with_heap, .description = "test strbuf with heap only");
+
+static int test_strbuf_pushmem(void)
+{
+       _cleanup_strbuf_ struct strbuf buf;
+
+       strbuf_init(&buf);
+       strbuf_pushmem(&buf, "", 0);
+       strbuf_pushmem(&buf, TEXT, strlen(TEXT) + 1);
+
+       TS_ASSERT(streq(TEXT, strbuf_str(&buf)));
+
+       return 0;
+}
+DEFINE_TEST(test_strbuf_pushmem, .description = "test strbuf_reserve");
+
+static int test_strbuf_used(void)
+{
+       _cleanup_strbuf_ struct strbuf buf;
+
+       strbuf_init(&buf);
+       TS_ASSERT(strbuf_used(&buf) == 0);
+
+       strbuf_pushchars(&buf, TEXT);
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT));
+
+       strbuf_pushchar(&buf, 'a');
+       strbuf_popchar(&buf);
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT));
+
+       TS_ASSERT(streq(TEXT, strbuf_str(&buf)));
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT));
+
+       strbuf_pushchar(&buf, '\0');
+       TS_ASSERT(streq(TEXT, strbuf_str(&buf)));
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT) + 1);
+
+       return 0;
+}
+DEFINE_TEST(test_strbuf_used, .description = "test strbuf_used");
+
+static int test_strbuf_shrink_to(void)
+{
+       _cleanup_strbuf_ struct strbuf buf;
+
+       strbuf_init(&buf);
+       strbuf_shrink_to(&buf, 0);
+       TS_ASSERT(strbuf_used(&buf) == 0);
+
+       strbuf_pushchars(&buf, TEXT);
+       strbuf_shrink_to(&buf, strlen(TEXT) - 1);
+       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT) - 1);
+
+       return 0;
+}
+DEFINE_TEST(test_strbuf_shrink_to, .description = "test strbuf_shrink_to");
+
+static int xfail_strbuf_shrink_to(void)
+{
+       _cleanup_strbuf_ struct strbuf buf;
+
+       strbuf_init(&buf);
+       strbuf_pushchar(&buf, '/');
+
+       /* This should crash on assert */
+       strbuf_shrink_to(&buf, 2);
+
+       return 0;
+}
+DEFINE_TEST(xfail_strbuf_shrink_to, .description = "xfail strbuf_shrink_to",
+           .expected_fail = true);
+
 TESTSUITE_MAIN();

diff --git a/testsuite/test-strbuf.c b/testsuite/test-strbuf.c
deleted file mode 100644 (file)
index 5b94470..0000000
--- a/testsuite/test-strbuf.c
+++ /dev/null
@@ -1,204 +0,0 @@
-// SPDX-License-Identifier: LGPL-2.1-or-later
-/*
- * Copyright (C)  2014 Intel Corporation. All rights reserved.
- */
-
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <shared/strbuf.h>
-#include <shared/util.h>
-
-#include "testsuite.h"
-
-static const char *TEXT =
-       "this is a very long test that is longer than the size we initially se in the strbuf";
-
-static int test_strbuf_pushchar(void)
-{
-       _cleanup_strbuf_ struct strbuf buf;
-       const char *result;
-       const char *c;
-
-       strbuf_init(&buf);
-
-       for (c = TEXT; *c != '\0'; c++)
-               strbuf_pushchar(&buf, *c);
-
-       result = strbuf_str(&buf);
-       TS_ASSERT(result == buf.bytes);
-       TS_ASSERT(streq(result, TEXT));
-
-       return 0;
-}
-DEFINE_TEST(test_strbuf_pushchar, .description = "test strbuf_{pushchar, str, steal}");
-
-static int test_strbuf_pushchars(void)
-{
-       _cleanup_strbuf_ struct strbuf buf;
-       const char *result;
-       char *saveptr = NULL, *str;
-       const char *c;
-       size_t lastwordlen = 0;
-
-       strbuf_init(&buf);
-       str = strdup(TEXT);
-       for (c = strtok_r(str, " ", &saveptr); c != NULL;
-            c = strtok_r(NULL, " ", &saveptr)) {
-               strbuf_pushchars(&buf, c);
-               strbuf_pushchar(&buf, ' ');
-               lastwordlen = strlen(c);
-       }
-
-       /*
-        * Replace the last space char, which also guarantees there's at least 1 char
-        * available for the '\0' added by strbuf_str() so result1 == buf.bytes should be
-        * true
-        */
-       strbuf_popchar(&buf);
-       result = strbuf_str(&buf);
-       TS_ASSERT(result == buf.bytes);
-       TS_ASSERT(streq(result, TEXT));
-
-       strbuf_popchars(&buf, lastwordlen);
-       result = strbuf_str(&buf);
-       TS_ASSERT(!streq(TEXT, result));
-       TS_ASSERT(strncmp(TEXT, result, strlen(TEXT) - lastwordlen) == 0);
-       TS_ASSERT(result[strlen(TEXT) - lastwordlen] == '\0');
-
-       free(str);
-
-       return 0;
-}
-DEFINE_TEST(test_strbuf_pushchars,
-           .description = "test strbuf_{pushchars, popchar, popchars}");
-
-static int test_strbuf_with_stack(void)
-{
-       const char test[] = "test-something-small";
-       const char *stack_buf;
-       const char *p;
-       DECLARE_STRBUF_WITH_STACK(buf, 256);
-       DECLARE_STRBUF_WITH_STACK(buf2, sizeof(test) + 1);
-       DECLARE_STRBUF_WITH_STACK(buf3, sizeof(test) + 1);
-
-       strbuf_pushchars(&buf, test);
-       TS_ASSERT(streq(test, strbuf_str(&buf)));
-       p = strbuf_str(&buf);
-       TS_ASSERT(streq(test, p));
-
-       strbuf_pushchars(&buf2, test);
-       TS_ASSERT(streq(test, strbuf_str(&buf2)));
-       /* It fits on stack, but when we steal, we get a copy on heap */
-       p = strbuf_str(&buf2);
-       TS_ASSERT(streq(test, p));
-
-       /*
-        * Check assumption about buffer being on stack vs heap is indeed valid.
-        * Not to be done in real code.
-        */
-       strbuf_clear(&buf3);
-       stack_buf = buf3.bytes;
-       strbuf_pushchars(&buf3, test);
-       TS_ASSERT(stack_buf == buf3.bytes);
-
-       TS_ASSERT(streq(test, strbuf_str(&buf3)));
-       TS_ASSERT(stack_buf == buf3.bytes);
-
-       strbuf_pushchars(&buf3, "-overflow");
-       TS_ASSERT(stack_buf != buf3.bytes);
-
-       return 0;
-}
-DEFINE_TEST(test_strbuf_with_stack, .description = "test strbuf with stack");
-
-static int test_strbuf_with_heap(void)
-{
-       DECLARE_STRBUF(heapbuf);
-
-       TS_ASSERT(heapbuf.bytes == NULL);
-       TS_ASSERT(heapbuf.size == 0);
-       TS_ASSERT(heapbuf.used == 0);
-       strbuf_pushchars(&heapbuf, "-overflow");
-       TS_ASSERT(heapbuf.bytes != NULL);
-       TS_ASSERT(heapbuf.size != 0);
-       TS_ASSERT(heapbuf.used != 0);
-
-       return 0;
-}
-DEFINE_TEST(test_strbuf_with_heap, .description = "test strbuf with heap only");
-
-static int test_strbuf_pushmem(void)
-{
-       _cleanup_strbuf_ struct strbuf buf;
-
-       strbuf_init(&buf);
-       strbuf_pushmem(&buf, "", 0);
-       strbuf_pushmem(&buf, TEXT, strlen(TEXT) + 1);
-
-       TS_ASSERT(streq(TEXT, strbuf_str(&buf)));
-
-       return 0;
-}
-DEFINE_TEST(test_strbuf_pushmem, .description = "test strbuf_reserve");
-
-static int test_strbuf_used(void)
-{
-       _cleanup_strbuf_ struct strbuf buf;
-
-       strbuf_init(&buf);
-       TS_ASSERT(strbuf_used(&buf) == 0);
-
-       strbuf_pushchars(&buf, TEXT);
-       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT));
-
-       strbuf_pushchar(&buf, 'a');
-       strbuf_popchar(&buf);
-       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT));
-
-       TS_ASSERT(streq(TEXT, strbuf_str(&buf)));
-       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT));
-
-       strbuf_pushchar(&buf, '\0');
-       TS_ASSERT(streq(TEXT, strbuf_str(&buf)));
-       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT) + 1);
-
-       return 0;
-}
-DEFINE_TEST(test_strbuf_used, .description = "test strbuf_used");
-
-static int test_strbuf_shrink_to(void)
-{
-       _cleanup_strbuf_ struct strbuf buf;
-
-       strbuf_init(&buf);
-       strbuf_shrink_to(&buf, 0);
-       TS_ASSERT(strbuf_used(&buf) == 0);
-
-       strbuf_pushchars(&buf, TEXT);
-       strbuf_shrink_to(&buf, strlen(TEXT) - 1);
-       TS_ASSERT(strbuf_used(&buf) == strlen(TEXT) - 1);
-
-       return 0;
-}
-DEFINE_TEST(test_strbuf_shrink_to, .description = "test strbuf_shrink_to");
-
-static int xfail_strbuf_shrink_to(void)
-{
-       _cleanup_strbuf_ struct strbuf buf;
-
-       strbuf_init(&buf);
-       strbuf_pushchar(&buf, '/');
-
-       /* This should crash on assert */
-       strbuf_shrink_to(&buf, 2);
-
-       return 0;
-}
-DEFINE_TEST(xfail_strbuf_shrink_to, .description = "xfail strbuf_shrink_to",
-           .expected_fail = true);
-
-TESTSUITE_MAIN();