From 85b938c4678c6f2e365510cf575b8131098b5b61 Mon Sep 17 00:00:00 2001 From: Simon Kuenzer Date: Mon, 30 Jan 2023 03:53:36 +0100 Subject: [PATCH] lib/ukstreambuf: Unit tests: Append operations for binary data MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Registers `libuktest` unit tests for append operations of binary data to a streambuf object. Signed-off-by: Simon Kuenzer Reviewed-by: Eduard Vintilă Reviewed-by: Andra Paraschiv Approved-by: Razvan Deaconescu Tested-by: Unikraft CI GitHub-Closes: #737 --- lib/ukstreambuf/tests/test_ukstreambuf.c | 190 +++++++++++++++++++++++ 1 file changed, 190 insertions(+) diff --git a/lib/ukstreambuf/tests/test_ukstreambuf.c b/lib/ukstreambuf/tests/test_ukstreambuf.c index 0144dda53..dda2f24e0 100644 --- a/lib/ukstreambuf/tests/test_ukstreambuf.c +++ b/lib/ukstreambuf/tests/test_ukstreambuf.c @@ -278,6 +278,196 @@ UK_TESTCASE(ukstreambuf, streambuf_printf_termshift) UK_TEST_EXPECT_ZERO(memcmp(buf, result, ARRAY_SIZE(buf))); } +UK_TESTCASE(ukstreambuf, streambuf_memcpy) +{ + struct uk_streambuf sb; + char buf[10]; + const char str_test1[] = "test1"; + const char str_minus[] = "-"; + const char str_test2[] = "test2"; + const char result[10] = { 't', 'e', 's', 't', '1', '\0', + '-', '\0', 't', 'e' }; + __sz ret; + + uk_streambuf_init(&sb, buf, ARRAY_SIZE(buf), 0x0); + + /* First memcpy */ + ret = uk_streambuf_memcpy(&sb, str_test1, 6); + UK_TEST_EXPECT_SNUM_EQ(ret, 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 4); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[6]); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Another memcpy */ + ret = uk_streambuf_memcpy(&sb, str_minus, 2); + UK_TEST_EXPECT_SNUM_EQ(ret, 2); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 8); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 8); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 2); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[8]); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Running out of space */ + ret = uk_streambuf_memcpy(&sb, str_test2, 6); + UK_TEST_EXPECT_SNUM_EQ(ret, 2); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 10); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 10); + UK_TEST_EXPECT_ZERO(uk_streambuf_left(&sb)); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[10]); + UK_TEST_EXPECT_NOT_ZERO(uk_streambuf_istruncated(&sb)); + + /* No space left */ + ret = uk_streambuf_memcpy(&sb, str_minus, 2); + UK_TEST_EXPECT_SNUM_EQ(ret, 0); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 10); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 10); + UK_TEST_EXPECT_ZERO(uk_streambuf_left(&sb)); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[10]); + UK_TEST_EXPECT_NOT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Result on buf as expected? */ + UK_TEST_EXPECT_ZERO(memcmp(buf, result, ARRAY_SIZE(buf))); +} + +UK_TESTCASE(ukstreambuf, streambuf_memcpy_termshift) +{ + struct uk_streambuf sb; + char buf[10]; + const char str_test1[] = "test1"; + const char str_minus[] = "-"; + const char str_test2[] = "test2"; + const char result[10] = { 't', 'e', 's', 't', '1', '-', + 't', 'e', 's', '-' }; + __sz ret; + + /* + * NOTE: With TERMSHIFT, the wptr should move one position backwards + * for successive writes (resulting in C-string concatenation). + */ + uk_streambuf_init(&sb, buf, ARRAY_SIZE(buf), UK_STREAMBUF_C_TERMSHIFT); + + /* First string */ + ret = uk_streambuf_memcpy(&sb, str_test1, 6); + UK_TEST_EXPECT_SNUM_EQ(ret, 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 5); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 5); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[5]); + UK_TEST_EXPECT_SNUM_EQ(buf[5], '\0'); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Append another string */ + ret = uk_streambuf_memcpy(&sb, str_minus, 2); + UK_TEST_EXPECT_SNUM_EQ(ret, 2); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 7); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 4); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[6]); + UK_TEST_EXPECT_SNUM_EQ(buf[6], '\0'); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Running out of space */ + ret = uk_streambuf_memcpy(&sb, str_test2, 6); + UK_TEST_EXPECT_SNUM_EQ(ret, 4); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 9); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 10); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 1); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[9]); + UK_TEST_EXPECT_SNUM_NQ(buf[9], '\0'); + UK_TEST_EXPECT_NOT_ZERO(uk_streambuf_istruncated(&sb)); + + /* + * No space left but the last character (due to TERMSHIFT) should + * be over-writable + */ + ret = uk_streambuf_memcpy(&sb, str_minus, 2); + UK_TEST_EXPECT_SNUM_EQ(ret, 1); /* '-' written */ + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 9); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 10); + /* Last '\0' stays overwritable (but only with '\0')*/ + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 1); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[9]); + UK_TEST_EXPECT_SNUM_NQ(buf[9], '\0'); + UK_TEST_EXPECT_NOT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Result on buf as expected? */ + UK_TEST_EXPECT_ZERO(memcmp(buf, result, ARRAY_SIZE(buf))); +} + +UK_TESTCASE(ukstreambuf, streambuf_reserve) +{ + struct uk_streambuf sb; + char buf[10]; + void *ret; + + uk_streambuf_init(&sb, buf, ARRAY_SIZE(buf), 0x0); + + /* First blob */ + ret = uk_streambuf_reserve(&sb, 6); + UK_TEST_EXPECT_PTR_EQ(ret, &buf[0]); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 4); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[6]); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Another blob */ + ret = uk_streambuf_reserve(&sb, 2); + UK_TEST_EXPECT_PTR_EQ(ret, &buf[6]); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 8); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 8); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 2); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[8]); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Out of space */ + ret = uk_streambuf_reserve(&sb, 6); + UK_TEST_EXPECT_NULL(ret); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 8); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 8); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 2); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[8]); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); +} + +UK_TESTCASE(ukstreambuf, streambuf_reserve_termshift) +{ + struct uk_streambuf sb; + char buf[10]; + void *ret; + + uk_streambuf_init(&sb, buf, ARRAY_SIZE(buf), UK_STREAMBUF_C_TERMSHIFT); + + /* First blob */ + ret = uk_streambuf_reserve(&sb, 6); + UK_TEST_EXPECT_PTR_EQ(ret, &buf[0]); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 5); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 5); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[5]); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Another blob */ + ret = uk_streambuf_reserve(&sb, 2); + UK_TEST_EXPECT_PTR_EQ(ret, &buf[5]); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 7); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 4); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[6]); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); + + /* Out of space */ + ret = uk_streambuf_reserve(&sb, 6); + UK_TEST_EXPECT_NULL(ret); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_seek(&sb), 6); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_len(&sb), 7); + UK_TEST_EXPECT_SNUM_EQ(uk_streambuf_left(&sb), 4); + UK_TEST_EXPECT_PTR_EQ(uk_streambuf_wptr(&sb), &buf[6]); + UK_TEST_EXPECT_ZERO(uk_streambuf_istruncated(&sb)); +} + /* * NOTE: `uk_streambuf_printf()` relies on `snprintf()` which may require a * TLS (depending on selected libc): -- 2.39.5