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

@@ -41,6 +41,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)
 {
@@ -80,6 +104,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)
@@ -125,6 +150,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,26 +269,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);