Index: lib/libsbuf/tests/sbuf_core_test.c
===================================================================
--- lib/libsbuf/tests/sbuf_core_test.c
+++ lib/libsbuf/tests/sbuf_core_test.c
@@ -1,4 +1,4 @@
-/*-
+ /*-
  * Copyright (c) 2017 Enji Cooper <ngie@freebsd.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -63,6 +63,9 @@
 	 */
 	child_proc = atf_utils_fork();
 	if (child_proc == 0) {
+		ATF_REQUIRE_EQ_MSG(0, sbuf_finish(sb), "sbuf_finish failed: %s",
+		    strerror(errno));
+
 		sbuf_putbuf(sb);
 		exit(0);
 	}
@@ -100,6 +103,34 @@
 	sbuf_delete(sb);
 }
 
+static int
+drain_ret0(void *arg, const char *data, int len)
+{
+
+	(void)arg;
+	(void)data;
+	(void)len;
+
+	return (0);
+}
+
+ATF_TC_WITHOUT_HEAD(sbuf_drain_ret0_test);
+ATF_TC_BODY(sbuf_drain_ret0_test, tc)
+{
+	struct sbuf *sb;
+
+	sb = sbuf_new_auto();
+
+	sbuf_set_drain(sb, drain_ret0, NULL);
+
+	sbuf_cat(sb, test_string);
+
+	ATF_CHECK_EQ_MSG(-1, sbuf_finish(sb),
+	    "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");
+}
+
 ATF_TC_WITHOUT_HEAD(sbuf_len_test);
 ATF_TC_BODY(sbuf_len_test, tc)
 {
@@ -131,6 +162,34 @@
 	sbuf_delete(sb);
 }
 
+ATF_TC_WITHOUT_HEAD(sbuf_new_fixedlen);
+ATF_TC_BODY(sbuf_new_fixedlen, tc)
+{
+	char buf[strlen(test_string) + 1];
+	struct sbuf sb;
+	pid_t child_proc;
+
+	sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN);
+
+	sbuf_cat(&sb, test_string);
+
+	child_proc = atf_utils_fork();
+	if (child_proc == 0) {
+		ATF_REQUIRE_EQ_MSG(0, sbuf_finish(&sb), "sbuf_finish failed: %s",
+		    strerror(errno));
+
+		sbuf_putbuf(&sb);
+		exit(0);
+	}
+	atf_utils_wait(child_proc, 0, test_string, "");
+
+	sbuf_putc(&sb, ' ');
+
+	ATF_CHECK_EQ_MSG(-1, sbuf_finish(&sb), "failed to return error on overflow");
+
+	sbuf_delete(&sb);
+}
+
 ATF_TC_WITHOUT_HEAD(sbuf_setpos_test);
 ATF_TC_BODY(sbuf_setpos_test, tc)
 {
@@ -185,26 +244,94 @@
 	sbuf_delete(sb);
 }
 
+ATF_TC_WITHOUT_HEAD(sbuf_clear_flags_test);
+ATF_TC_BODY(sbuf_clear_flags_test, tc) {
+  	struct sbuf *sb = NULL;
+
+	sb = sbuf_new_auto();
+	ATF_REQUIRE_MSG(sb != NULL, "sbuf_new_auto failed: %s",
+	    strerror(errno));
+
+	sbuf_set_flags(sb, SBUF_INCLUDENUL);
+	sbuf_set_flags(sb, SBUF_DRAINTOEOR);
+
+	sbuf_clear_flags(sb, SBUF_INCLUDENUL);
+	int actual_flags = sbuf_get_flags(sb);
+	ATF_CHECK((actual_flags & SBUF_INCLUDENUL) == 0);
+
+	int expected_flags = SBUF_AUTOEXTEND | SBUF_DRAINTOEOR;
+	ATF_CHECK(actual_flags == expected_flags);
+
+	sbuf_clear_flags(sb, SBUF_AUTOEXTEND | SBUF_DRAINTOEOR);
+	actual_flags = sbuf_get_flags(sb);
+	ATF_CHECK(actual_flags == 0);
+	sbuf_delete(sb);
+}
+
+ATF_TC_WITHOUT_HEAD(sbuf_set_get_flags_test);
+ATF_TC_BODY(sbuf_set_get_flags_test, tc) {
+      	struct sbuf *sb = NULL;
+
+	char buf[strlen(test_string) + 1];
+	sb = sbuf_new(sb, buf, sizeof(buf), SBUF_FIXEDLEN);
+
+	int actual_flags = sbuf_get_flags(sb);
+	int expected_flags = SBUF_FIXEDLEN;
+	ATF_CHECK(actual_flags == expected_flags);
+
+	sbuf_set_flags(sb, SBUF_AUTOEXTEND);
+	sbuf_set_flags(sb, SBUF_INCLUDENUL);
+	sbuf_set_flags(sb, SBUF_DRAINTOEOR);
+
+	actual_flags = sbuf_get_flags(sb);
+	expected_flags = SBUF_AUTOEXTEND | SBUF_INCLUDENUL | SBUF_DRAINTOEOR;
+	ATF_CHECK(actual_flags == expected_flags);
+	ATF_CHECK((actual_flags & SBUF_AUTOEXTEND) == SBUF_AUTOEXTEND);
+	ATF_CHECK((actual_flags & SBUF_INCLUDENUL) == SBUF_INCLUDENUL);
+	ATF_CHECK((actual_flags & SBUF_DRAINTOEOR) == SBUF_DRAINTOEOR);
+
+	sbuf_delete(sb);
+}
+
+ATF_TC_WITHOUT_HEAD(sbuf_new_positive_test);
+ATF_TC_BODY(sbuf_new_positive_test, tc) {
+        struct sbuf *sb = NULL;
+
+	char buf[strlen(test_string) + 1];
+	sb = sbuf_new(sb, buf, sizeof(buf), SBUF_FIXEDLEN);
+	ATF_REQUIRE_MSG(sb != NULL, "sbuf_new failed due to %s",
+			strerror(errno));
+
+	sbuf_delete(sb);
+
+	sbuf_new(sb, NULL, 0, SBUF_AUTOEXTEND);
+	ATF_REQUIRE_MSG(sb != NULL, "sbuf_new failed due to %s",
+			strerror(errno));
+	sbuf_delete(sb);
+}
+
+ATF_TC_WITHOUT_HEAD(sbuf_new_negative_test);
+ATF_TC_BODY(sbuf_new_negative_test, tc) {
+        atf_tc_skip("Please see discussion on https://reviews.freebsd.org/D26220");
+}
+
 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);
-#if 0
-	/* TODO */
+	ATF_TP_ADD_TC(tp, sbuf_new_fixedlen);
+
 #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);
+#ifdef	HAVE_SBUF_SET_FLAGS
+	ATF_TP_ADD_TC(tp, sbuf_set_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());