git: 760efcc775c3 - main - sbuf(3): increase test coverage

The branch main has been updated by ngie:

URL: https://cgit.FreeBSD.org/src/commit/?id=760efcc775c304d175a360dddf499a7b0d5e3935

commit 760efcc775c304d175a360dddf499a7b0d5e3935
Author:     Joao Bonifacio <joaoboni017@gmail.com>
AuthorDate: 2026-08-09 22:43:26 +0000
Commit:     Enji Cooper <ngie@FreeBSD.org>
CommitDate: 2026-10-18 17:53:25 +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
---
 lib/libsbuf/tests/sbuf_core_test.c | 90 ++++++++++++++++++++++++++++++++------
 1 file changed, 77 insertions(+), 13 deletions(-)

diff --git a/lib/libsbuf/tests/sbuf_core_test.c b/lib/libsbuf/tests/sbuf_core_test.c
index 14bbc475043a..b736efb36756 100644
--- a/lib/libsbuf/tests/sbuf_core_test.c
+++ b/lib/libsbuf/tests/sbuf_core_test.c
@@ -125,6 +125,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);
@@ -242,27 +244,89 @@ ATF_TC_BODY(sbuf_setpos_test, tc)
 	sbuf_delete(sb);
 }
 
+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);
+}
+
+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);
+}
+
+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_TP_ADD_TCS(tp)
 {
+	ATF_TP_ADD_TC(tp, sbuf_clear_flags_test);
 	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_get_flags_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);
-#endif
-#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);
-#ifdef HAVE_SBUF_SET_FLAGS
 	ATF_TP_ADD_TC(tp, sbuf_set_flags_test);
-#endif
-#endif
 	ATF_TP_ADD_TC(tp, sbuf_setpos_test);
 
 	return (atf_no_error());