git: 8f6b69224038 - stable/14 - sbuf(3): increase test coverage

The branch stable/14 has been updated by ngie:

URL: https://cgit.FreeBSD.org/src/commit/?id=8f6b692240387a4d22d032033b3766ddd806577c

commit 8f6b692240387a4d22d032033b3766ddd806577c
Author:     Joao Bonifacio <joaoboni017@gmail.com>
AuthorDate: 2026-08-09 22:43:26 +0000
Commit:     Enji Cooper <ngie@FreeBSD.org>
CommitDate: 2026-11-01 01:52:58 +0000

    sbuf(3): increase test coverage
    
    This change adds additional explicit test coverage for the following
    sbuf(3) APIs:
    - sbuf_clear_flags
    - sbuf_get_flags
    - sbuf_set_flags
    
    While here, add a missing `sbuf_delete` to `sbuf_drain_ret0_test`: while
    it isn't strictly required (the library's state is cleaned up shortly
    after the test process ends), tools such as Coverity and LSAN flag
    issues with leaked memory. Adding the sbuf_delete(3) call to the test
    quells that issue.
    
    MFC after:      1 week
    Reviewed-by:    ngie
    Pull-Request:   https://github.com/freebsd/freebsd-src/pull/2367
    
    (cherry picked from commit 642b3d965eb6ef3ecf733950e66fad565a27c967)
---
 lib/libsbuf/tests/sbuf_core_test.c | 87 +++++++++++++++++++++++++++++++++-----
 1 file changed, 77 insertions(+), 10 deletions(-)

diff --git a/lib/libsbuf/tests/sbuf_core_test.c b/lib/libsbuf/tests/sbuf_core_test.c
index b01a43e12c5c..d6c7873df74a 100644
--- a/lib/libsbuf/tests/sbuf_core_test.c
+++ b/lib/libsbuf/tests/sbuf_core_test.c
@@ -42,6 +42,30 @@ static char test_string[] = "this is a test string";
 _Static_assert(nitems(test_string) > TEST_STRING_CHOP_COUNT,
     "test_string is too short");
 
+#ifdef HAVE_SBUF_CLEAR_FLAGS
+ATF_TC_WITHOUT_HEAD(sbuf_clear_flags_test);
+ATF_TC_BODY(sbuf_clear_flags_test, tc)
+{
+	struct sbuf *sb;
+	int flags;
+
+	sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND | SBUF_INCLUDENUL);
+
+	ATF_REQUIRE_MSG(sb != NULL,
+	    "sbuf_new failed: %s", strerror(errno));
+
+	flags = sbuf_get_flags(sb);
+	ATF_REQUIRE_INTEQ(SBUF_INCLUDENUL, flags & SBUF_INCLUDENUL);
+
+	sbuf_clear_flags(sb, SBUF_INCLUDENUL);
+
+	flags = sbuf_get_flags(sb);
+
+	ATF_CHECK_INTEQ(0, flags & SBUF_INCLUDENUL);
+
+	sbuf_delete(sb);
+}
+
 ATF_TC_WITHOUT_HEAD(sbuf_clear_test);
 ATF_TC_BODY(sbuf_clear_test, tc)
 {
@@ -81,6 +105,7 @@ ATF_TC_BODY(sbuf_clear_test, tc)
 
 	sbuf_delete(sb);
 }
+#endif
 
 ATF_TC_WITHOUT_HEAD(sbuf_done_and_sbuf_finish_test);
 ATF_TC_BODY(sbuf_done_and_sbuf_finish_test, tc)
@@ -126,6 +151,8 @@ ATF_TC_BODY(sbuf_drain_ret0_test, tc)
 	    "required to return error when drain func returns 0");
 	ATF_CHECK_EQ_MSG(EDEADLK, errno,
 	    "errno required to be EDEADLK when drain func returns 0");
+
+	sbuf_delete(sb);
 }
 
 ATF_TC_WITHOUT_HEAD(sbuf_len_test);
@@ -243,26 +270,66 @@ ATF_TC_BODY(sbuf_setpos_test, tc)
 	sbuf_delete(sb);
 }
 
+#ifdef HAVE_SBUF_GET_FLAGS
+ATF_TC_WITHOUT_HEAD(sbuf_get_flags_test);
+ATF_TC_BODY(sbuf_get_flags_test, tc)
+{
+	struct sbuf *sb;
+	int flags;
+
+	sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND | SBUF_INCLUDENUL);
+
+	ATF_REQUIRE_MSG(sb != NULL, "sbuf_new failed: %s", strerror(errno));
+
+	flags = sbuf_get_flags(sb);
+
+	ATF_CHECK_INTEQ(
+	    flags & (SBUF_AUTOEXTEND | SBUF_AUTOEXTEND),
+	    SBUF_AUTOEXTEND | SBUF_AUTOEXTEND);
+	ATF_CHECK_INTEQ(flags ^ (SBUF_AUTOEXTEND | SBUF_INCLUDENUL), 0);
+	sbuf_delete(sb);
+}
+#endif
+
+#ifdef HAVE_SBUF_SET_FLAGS
+ATF_TC_WITHOUT_HEAD(sbuf_set_flags_test);
+ATF_TC_BODY(sbuf_set_flags_test, tc)
+{
+	struct sbuf *sb;
+
+	sb = sbuf_new_auto();
+
+	ATF_REQUIRE_MSG(sb != NULL,
+	    "sbuf_new_auto failed: %s", strerror(errno));
+
+	sbuf_set_flags(sb, SBUF_INCLUDENUL);
+
+	ATF_REQUIRE_MSG(sbuf_cat(sb, test_string) == 0, "sbuf_cat failed");
+
+	ATF_REQUIRE_EQ_MSG(0, sbuf_finish(sb),
+	    "sbuf_finish failed: %s", strerror(errno));
+
+	ATF_CHECK_EQ((ssize_t)(strlen(test_string) + 1), sbuf_len(sb));
+
+	sbuf_delete(sb);
+}
+#endif
+
 ATF_TP_ADD_TCS(tp)
 {
-	ATF_TP_ADD_TC(tp, sbuf_clear_test);
-	ATF_TP_ADD_TC(tp, sbuf_done_and_sbuf_finish_test);
-	ATF_TP_ADD_TC(tp, sbuf_drain_ret0_test);
-	ATF_TP_ADD_TC(tp, sbuf_len_test);
-	ATF_TP_ADD_TC(tp, sbuf_new_fixedlen);
-#if 0
-	/* TODO */
 #ifdef HAVE_SBUF_CLEAR_FLAGS
 	ATF_TP_ADD_TC(tp, sbuf_clear_flags_test);
+	ATF_TP_ADD_TC(tp, sbuf_clear_test);
 #endif
+	ATF_TP_ADD_TC(tp, sbuf_done_and_sbuf_finish_test);
+	ATF_TP_ADD_TC(tp, sbuf_drain_ret0_test);
 #ifdef HAVE_SBUF_GET_FLAGS
 	ATF_TP_ADD_TC(tp, sbuf_get_flags_test);
 #endif
-	ATF_TP_ADD_TC(tp, sbuf_new_positive_test);
-	ATF_TP_ADD_TC(tp, sbuf_new_negative_test);
+	ATF_TP_ADD_TC(tp, sbuf_len_test);
+	ATF_TP_ADD_TC(tp, sbuf_new_fixedlen);
 #ifdef HAVE_SBUF_SET_FLAGS
 	ATF_TP_ADD_TC(tp, sbuf_set_flags_test);
-#endif
 #endif
 	ATF_TP_ADD_TC(tp, sbuf_setpos_test);