diff --git a/lib/libc/tests/nss/getgr_test.c b/lib/libc/tests/nss/getgr_test.c
index 757382b02f39..ec06d5cf2f6c 100644
--- a/lib/libc/tests/nss/getgr_test.c
+++ b/lib/libc/tests/nss/getgr_test.c
@@ -1,544 +1,544 @@
 /*-
  * Copyright (c) 2006 Michael Bushkov <bushman@freebsd.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <arpa/inet.h>
 #include <errno.h>
 #include <grp.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stringlist.h>
 #include <unistd.h>
 
 #include <atf-c.h>
 
 #include "testutil.h"
 
 enum test_methods {
 	TEST_GETGRENT = 1,
 	TEST_GETGRNAM = 2,
 	TEST_GETGRGID = 4,
 	TEST_GETGRENT_2PASS = 8,
 	TEST_BUILD_SNAPSHOT = 16,
 };
 
 DECLARE_TEST_DATA(group)
 DECLARE_TEST_FILE_SNAPSHOT(group)
 DECLARE_1PASS_TEST(group)
 DECLARE_2PASS_TEST(group)
 
 static void clone_group(struct group *, struct group const *);
 static int compare_group(struct group *, struct group *, void *);
 static void dump_group(struct group *);
 static void free_group(struct group *);
 
 static void sdump_group(struct group *, char *, size_t);
 static int group_read_snapshot_func(struct group *, char *);
 
-static int group_check_ambiguity(struct group_test_data *,
-	struct group *);
+static int group_check_ambiguity(struct group_test_data *, struct group *);
 static int group_fill_test_data(struct group_test_data *);
 static int group_test_correctness(struct group *, void *);
 static int group_test_getgrnam(struct group *, void *);
 static int group_test_getgrgid(struct group *, void *);
 static int group_test_getgrent(struct group *, void *);
 
 IMPLEMENT_TEST_DATA(group)
 IMPLEMENT_TEST_FILE_SNAPSHOT(group)
 IMPLEMENT_1PASS_TEST(group)
 IMPLEMENT_2PASS_TEST(group)
 
 static void
 clone_group(struct group *dest, struct group const *src)
 {
 	ATF_REQUIRE(dest != NULL);
 	ATF_REQUIRE(src != NULL);
 
 	char **cp;
 	int members_num;
 
 	memset(dest, 0, sizeof(struct group));
 
 	if (src->gr_name != NULL) {
 		dest->gr_name = strdup(src->gr_name);
 		ATF_REQUIRE(dest->gr_name != NULL);
 	}
 
 	if (src->gr_passwd != NULL) {
 		dest->gr_passwd = strdup(src->gr_passwd);
 		ATF_REQUIRE(dest->gr_passwd != NULL);
 	}
 	dest->gr_gid = src->gr_gid;
 
 	if (src->gr_mem != NULL) {
 		members_num = 0;
 		for (cp = src->gr_mem; *cp; ++cp)
 			++members_num;
 
 		dest->gr_mem = calloc(members_num + 1, sizeof(char *));
 		ATF_REQUIRE(dest->gr_mem != NULL);
 
 		for (cp = src->gr_mem; *cp; ++cp) {
 			dest->gr_mem[cp - src->gr_mem] = strdup(*cp);
 			ATF_REQUIRE(dest->gr_mem[cp - src->gr_mem] != NULL);
 		}
 	}
 }
 
 static void
 free_group(struct group *grp)
 {
 	char **cp;
 
 	ATF_REQUIRE(grp != NULL);
 
 	free(grp->gr_name);
 	free(grp->gr_passwd);
 
 	for (cp = grp->gr_mem; *cp; ++cp)
 		free(*cp);
 	free(grp->gr_mem);
 }
 
 static  int
 compare_group(struct group *grp1, struct group *grp2, void *mdata)
 {
 	char **c1, **c2;
 
 	if (grp1 == grp2)
 		return (0);
 
 	if (grp1 == NULL || grp2 == NULL)
 		goto errfin;
 
 	if (strcmp(grp1->gr_name, grp2->gr_name) != 0 ||
 	    strcmp(grp1->gr_passwd, grp2->gr_passwd) != 0 ||
 	    grp1->gr_gid != grp2->gr_gid)
 			goto errfin;
 
 	c1 = grp1->gr_mem;
 	c2 = grp2->gr_mem;
 
 	if (grp1->gr_mem == NULL || grp2->gr_mem == NULL)
 		goto errfin;
 
 	for (; *c1 && *c2; ++c1, ++c2)
 		if (strcmp(*c1, *c2) != 0)
 			goto errfin;
 
 	if (*c1 != NULL || *c2 != NULL)
 		goto errfin;
 
 	return 0;
 
 errfin:
 	if (mdata == NULL) {
 		printf("following structures are not equal:\n");
 		dump_group(grp1);
 		dump_group(grp2);
 	}
 
 	return (-1);
 }
 
 static void
 sdump_group(struct group *grp, char *buffer, size_t buflen)
 {
 	char **cp;
 	int written;
 
 	written = snprintf(buffer, buflen, "%s:%s:%d:",
-		grp->gr_name, grp->gr_passwd, grp->gr_gid);
+	    grp->gr_name, grp->gr_passwd, grp->gr_gid);
 	buffer += written;
 	if (written > (int)buflen)
 		return;
 	buflen -= written;
 
 	if (grp->gr_mem != NULL) {
 		if (*(grp->gr_mem) != NULL) {
 			for (cp = grp->gr_mem; *cp; ++cp) {
 				written = snprintf(buffer, buflen, "%s%s",
 				    cp == grp->gr_mem ? "" : ",", *cp);
 				buffer += written;
 				if (written > (int)buflen)
 					return;
 				buflen -= written;
 
 				if (buflen == 0)
 					return;
 			}
 		} else
 			snprintf(buffer, buflen, "nomem");
 	} else
 		snprintf(buffer, buflen, "(null)");
 }
 
 static int
 group_read_snapshot_func(struct group *grp, char *line)
 {
 	StringList *sl;
 	char *s, *ps, *ts;
 	const char *sep;
 	int i;
 
 	printf("1 line read from snapshot:\n%s\n", line);
 
 	i = 0;
 	sl = NULL;
 	ps = line;
 	sep = ":";
 	memset(grp, 0, sizeof(struct group));
 	while ((s = strsep(&ps, sep)) != NULL) {
 		switch (i) {
 		case 0:
 			grp->gr_name = strdup(s);
 			ATF_REQUIRE(grp->gr_name != NULL);
 			break;
 
 		case 1:
 			grp->gr_passwd = strdup(s);
 			ATF_REQUIRE(grp->gr_passwd != NULL);
 			break;
 
 		case 2:
 			grp->gr_gid = (gid_t)strtol(s, &ts, 10);
 			if (*ts != '\0') {
 				free(grp->gr_name);
 				free(grp->gr_passwd);
 				grp->gr_name = NULL;
 				grp->gr_passwd = NULL;
 				return (-1);
 			}
 			/* Change to parsing groups. */
 			sep = ",";
 			break;
 
 		default:
 			if (sl == NULL) {
 				if (strcmp(s, "(null)") == 0)
 					return (0);
 
 				sl = sl_init();
 				ATF_REQUIRE(sl != NULL);
 
 				if (strcmp(s, "nomem") != 0) {
 					ts = strdup(s);
 					ATF_REQUIRE(ts != NULL);
 					sl_add(sl, ts);
 				}
 			} else {
 				ts = strdup(s);
 				ATF_REQUIRE(ts != NULL);
 				sl_add(sl, ts);
 			}
 			break;
 		}
 		++i;
 	}
 
 	if (i < 3) {
 		free(grp->gr_name);
 		free(grp->gr_passwd);
 		memset(grp, 0, sizeof(struct group));
 		return (-1);
 	}
 
 	sl_add(sl, NULL);
 	grp->gr_mem = sl->sl_str;
 
 	/* NOTE: is it a dirty hack or not? */
 	free(sl);
 	return (0);
 }
 
 static void
 dump_group(struct group *result)
 {
 	if (result != NULL) {
 		char buffer[1024];
 		sdump_group(result, buffer, sizeof(buffer));
 		printf("%s\n", buffer);
 	} else
 		printf("(null)\n");
 }
 
 static int
 group_fill_test_data(struct group_test_data *td)
 {
 	struct group *grp;
 
 	setgroupent(1);
 	while ((grp = getgrent()) != NULL) {
 		if (group_test_correctness(grp, NULL) == 0)
 			TEST_DATA_APPEND(group, td, grp);
 		else
 			return (-1);
 	}
 	endgrent();
 
 	return (0);
 }
 
 static int
 group_test_correctness(struct group *grp, void *mdata __unused)
 {
 	printf("testing correctness with the following data:\n");
 	dump_group(grp);
 
 	if (grp == NULL)
 		goto errfin;
 
 	if (grp->gr_name == NULL)
 		goto errfin;
 
 	if (grp->gr_passwd == NULL)
 		goto errfin;
 
 	if (grp->gr_mem == NULL)
 		goto errfin;
 
 	printf("correct\n");
 
 	return (0);
 errfin:
 	printf("incorrect\n");
 
 	return (-1);
 }
 
 /* group_check_ambiguity() is needed here because when doing the getgrent()
  * calls sequence, records from different nsswitch sources can be different,
  * though having the same pw_name/pw_uid */
 static int
 group_check_ambiguity(struct group_test_data *td, struct group *pwd)
 {
 
-	return (TEST_DATA_FIND(group, td, pwd, compare_group,
-		NULL) != NULL ? 0 : -1);
+	return (TEST_DATA_FIND(group, td, pwd, compare_group, NULL) !=
+	    NULL ? 0 : -1);
 }
 
 static int
 group_test_getgrnam(struct group *grp_model, void *mdata)
 {
 	struct group *grp;
 
 	printf("testing getgrnam() with the following data:\n");
 	dump_group(grp_model);
 
 	grp = getgrnam(grp_model->gr_name);
 	if (group_test_correctness(grp, NULL) != 0)
 		goto errfin;
 
 	if (compare_group(grp, grp_model, NULL) != 0 &&
 	    group_check_ambiguity((struct group_test_data *)mdata, grp) != 0)
 	    goto errfin;
 
 	return (0);
 
 errfin:
 	return (-1);
 }
 
 static int
 group_test_getgrgid(struct group *grp_model, void *mdata)
 {
 	struct group *grp;
 
 	printf("testing getgrgid() with the following data...\n");
 	dump_group(grp_model);
 
 	grp = getgrgid(grp_model->gr_gid);
 	if (group_test_correctness(grp, NULL) != 0 ||
 	    (compare_group(grp, grp_model, NULL) != 0 &&
-	     group_check_ambiguity((struct group_test_data *)mdata, grp) != 0)) {
+	     group_check_ambiguity((struct group_test_data *)mdata, grp) != 0))
 		return (-1);
-	} else {
+	else
 		return (0);
-	}
 }
 
 static int
 group_test_getgrent(struct group *grp, void *mdata __unused)
 {
-	/* Only correctness can be checked when doing 1-pass test for
-	 * getgrent(). */
+	/*
+	 * Only correctness can be checked when doing 1-pass test for
+	 * getgrent().
+	 */
 	return (group_test_correctness(grp, NULL));
 }
 
 static int
 run_tests(const char *snapshot_file, enum test_methods method)
 {
 	struct group_test_data td, td_snap, td_2pass;
 	int rv;
 
 	TEST_DATA_INIT(group, &td, clone_group, free_group);
 	TEST_DATA_INIT(group, &td_snap, clone_group, free_group);
 	if (snapshot_file != NULL) {
 		if (access(snapshot_file, W_OK | R_OK) != 0) {
 			if (errno == ENOENT)
 				method = TEST_BUILD_SNAPSHOT;
 			else {
 				printf("can't access the file %s\n",
 				    snapshot_file);
 
 				rv = -1;
 				goto fin;
 			}
 		} else {
 			if (method == TEST_BUILD_SNAPSHOT) {
 				rv = 0;
 				goto fin;
 			}
 
 			TEST_SNAPSHOT_FILE_READ(group, snapshot_file,
 				&td_snap, group_read_snapshot_func);
 		}
 	}
 
 	rv = group_fill_test_data(&td);
 	if (rv == -1)
 		return (-1);
 	switch (method) {
 	case TEST_GETGRNAM:
 		if (snapshot_file == NULL)
 			rv = DO_1PASS_TEST(group, &td,
 				group_test_getgrnam, (void *)&td);
 		else
 			rv = DO_1PASS_TEST(group, &td_snap,
 				group_test_getgrnam, (void *)&td_snap);
 		break;
 	case TEST_GETGRGID:
 		if (snapshot_file == NULL)
 			rv = DO_1PASS_TEST(group, &td,
 				group_test_getgrgid, (void *)&td);
 		else
 			rv = DO_1PASS_TEST(group, &td_snap,
 				group_test_getgrgid, (void *)&td_snap);
 		break;
 	case TEST_GETGRENT:
 		if (snapshot_file == NULL)
 			rv = DO_1PASS_TEST(group, &td, group_test_getgrent,
 				(void *)&td);
 		else
 			rv = DO_2PASS_TEST(group, &td, &td_snap,
 				compare_group, NULL);
 		break;
 	case TEST_GETGRENT_2PASS:
-			TEST_DATA_INIT(group, &td_2pass, clone_group, free_group);
-			rv = group_fill_test_data(&td_2pass);
-			if (rv != -1)
-				rv = DO_2PASS_TEST(group, &td, &td_2pass,
-					compare_group, NULL);
-			TEST_DATA_DESTROY(group, &td_2pass);
+		TEST_DATA_INIT(group, &td_2pass, clone_group, free_group);
+		rv = group_fill_test_data(&td_2pass);
+		if (rv != -1)
+			rv = DO_2PASS_TEST(group, &td, &td_2pass,
+				compare_group, NULL);
+		TEST_DATA_DESTROY(group, &td_2pass);
 		break;
 	case TEST_BUILD_SNAPSHOT:
 		if (snapshot_file != NULL)
 			rv = TEST_SNAPSHOT_FILE_WRITE(group, snapshot_file, &td,
 			    sdump_group);
 		break;
 	default:
 		rv = 0;
 		break;
 	}
 
 fin:
 	TEST_DATA_DESTROY(group, &td_snap);
 	TEST_DATA_DESTROY(group, &td);
 
 	return (rv);
 }
 
 #define	SNAPSHOT_FILE	"snapshot_grp"
 
 ATF_TC_WITHOUT_HEAD(getgrent);
 ATF_TC_BODY(getgrent, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETGRENT) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getgrent_with_snapshot);
 ATF_TC_BODY(getgrent_with_snapshot, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETGRENT) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getgrent_with_two_pass);
 ATF_TC_BODY(getgrent_with_two_pass, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETGRENT_2PASS) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getgrgid);
 ATF_TC_BODY(getgrgid, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETGRGID) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getgrgid_with_snapshot);
 ATF_TC_BODY(getgrgid_with_snapshot, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETGRGID) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getgrnam);
 ATF_TC_BODY(getgrnam, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETGRNAM) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getgrnam_with_snapshot);
 ATF_TC_BODY(getgrnam_with_snapshot, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETGRNAM) == 0);
 }
 
 ATF_TP_ADD_TCS(tp)
 {
 
 	ATF_TP_ADD_TC(tp, getgrent);
 	ATF_TP_ADD_TC(tp, getgrent_with_snapshot);
 	ATF_TP_ADD_TC(tp, getgrent_with_two_pass);
 	ATF_TP_ADD_TC(tp, getgrgid);
 	ATF_TP_ADD_TC(tp, getgrgid_with_snapshot);
 	ATF_TP_ADD_TC(tp, getgrnam);
 	ATF_TP_ADD_TC(tp, getgrnam_with_snapshot);
 
 	return (atf_no_error());
 }
diff --git a/lib/libc/tests/nss/getpw_test.c b/lib/libc/tests/nss/getpw_test.c
index c7ad2e5a4889..e7c5304005ec 100644
--- a/lib/libc/tests/nss/getpw_test.c
+++ b/lib/libc/tests/nss/getpw_test.c
@@ -1,532 +1,533 @@
 /*-
  * Copyright (c) 2006 Michael Bushkov <bushman@freebsd.org>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <errno.h>
 #include <pwd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include <atf-c.h>
 
 #include "testutil.h"
 
 enum test_methods {
 	TEST_GETPWENT,
 	TEST_GETPWNAM,
 	TEST_GETPWUID,
 	TEST_GETPWENT_2PASS,
 	TEST_BUILD_SNAPSHOT
 };
 
 DECLARE_TEST_DATA(passwd)
 DECLARE_TEST_FILE_SNAPSHOT(passwd)
 DECLARE_1PASS_TEST(passwd)
 DECLARE_2PASS_TEST(passwd)
 
 static void clone_passwd(struct passwd *, struct passwd const *);
 static int compare_passwd(struct passwd *, struct passwd *, void *);
 static void free_passwd(struct passwd *);
 
 static void sdump_passwd(struct passwd *, char *, size_t);
 #ifdef DEBUG
 static void dump_passwd(struct passwd *);
 #endif
 
 static int passwd_read_snapshot_func(struct passwd *, char *);
 
 static int passwd_check_ambiguity(struct passwd_test_data *, struct passwd *);
 static int passwd_fill_test_data(struct passwd_test_data *);
 static int passwd_test_correctness(struct passwd *, void *);
 static int passwd_test_getpwnam(struct passwd *, void *);
 static int passwd_test_getpwuid(struct passwd *, void *);
 static int passwd_test_getpwent(struct passwd *, void *);
 
 IMPLEMENT_TEST_DATA(passwd)
 IMPLEMENT_TEST_FILE_SNAPSHOT(passwd)
 IMPLEMENT_1PASS_TEST(passwd)
 IMPLEMENT_2PASS_TEST(passwd)
 
 static void
 clone_passwd(struct passwd *dest, struct passwd const *src)
 {
 	ATF_REQUIRE(dest != NULL);
 	ATF_REQUIRE(src != NULL);
 
 	memcpy(dest, src, sizeof(struct passwd));
 	if (src->pw_name != NULL)
 		dest->pw_name = strdup(src->pw_name);
 	if (src->pw_passwd != NULL)
 		dest->pw_passwd = strdup(src->pw_passwd);
 	if (src->pw_class != NULL)
 		dest->pw_class = strdup(src->pw_class);
 	if (src->pw_gecos != NULL)
 		dest->pw_gecos = strdup(src->pw_gecos);
 	if (src->pw_dir != NULL)
 		dest->pw_dir = strdup(src->pw_dir);
 	if (src->pw_shell != NULL)
 		dest->pw_shell = strdup(dest->pw_shell);
 }
 
 static int
 compare_passwd(struct passwd *pwd1, struct passwd *pwd2, void *mdata __unused)
 {
 	ATF_REQUIRE(pwd1 != NULL);
 	ATF_REQUIRE(pwd2 != NULL);
 
 	if (pwd1 == pwd2)
 		return (0);
 
 	if (pwd1->pw_uid != pwd2->pw_uid ||
 	    pwd1->pw_gid != pwd2->pw_gid ||
 	    pwd1->pw_change != pwd2->pw_change ||
 	    pwd1->pw_expire != pwd2->pw_expire ||
 	    pwd1->pw_fields != pwd2->pw_fields ||
 	    strcmp(pwd1->pw_name, pwd2->pw_name) != 0 ||
 	    strcmp(pwd1->pw_passwd, pwd2->pw_passwd) != 0 ||
 	    strcmp(pwd1->pw_class, pwd2->pw_class) != 0 ||
 	    strcmp(pwd1->pw_gecos, pwd2->pw_gecos) != 0 ||
 	    strcmp(pwd1->pw_dir, pwd2->pw_dir) != 0 ||
 	    strcmp(pwd1->pw_shell, pwd2->pw_shell) != 0)
 		return (-1);
 	else
 		return (0);
 }
 
 static void
 free_passwd(struct passwd *pwd)
 {
 	free(pwd->pw_name);
 	free(pwd->pw_passwd);
 	free(pwd->pw_class);
 	free(pwd->pw_gecos);
 	free(pwd->pw_dir);
 	free(pwd->pw_shell);
 }
 
 static void
 sdump_passwd(struct passwd *pwd, char *buffer, size_t buflen)
 {
 	snprintf(buffer, buflen, "%s:%s:%d:%d:%jd:%s:%s:%s:%s:%jd:%d",
 	    pwd->pw_name, pwd->pw_passwd, pwd->pw_uid, pwd->pw_gid,
 	    (uintmax_t)pwd->pw_change, pwd->pw_class, pwd->pw_gecos,
 	    pwd->pw_dir, pwd->pw_shell, (uintmax_t)pwd->pw_expire,
 	    pwd->pw_fields);
 }
 
 #ifdef DEBUG
 static void
 dump_passwd(struct passwd *pwd)
 {
 	if (pwd != NULL) {
 		char buffer[2048];
 		sdump_passwd(pwd, buffer, sizeof(buffer));
 		printf("%s\n", buffer);
 	} else
 		printf("(null)\n");
 }
 #endif
 
 static int
 passwd_read_snapshot_func(struct passwd *pwd, char *line)
 {
 	char *s, *ps, *ts;
 	int i;
 
 #ifdef DEBUG
 	printf("1 line read from snapshot:\n%s\n", line);
 #endif
 
 	i = 0;
 	ps = line;
 	memset(pwd, 0, sizeof(struct passwd));
 	while ((s = strsep(&ps, ":")) != NULL) {
 		switch (i) {
 		case 0:
 			pwd->pw_name = strdup(s);
 			ATF_REQUIRE(pwd->pw_name != NULL);
 			break;
 		case 1:
 			pwd->pw_passwd = strdup(s);
 			ATF_REQUIRE(pwd->pw_passwd != NULL);
 			break;
 		case 2:
 			pwd->pw_uid = (uid_t)strtol(s, &ts, 10);
 			if (*ts != '\0')
 				goto fin;
 			break;
 		case 3:
 			pwd->pw_gid = (gid_t)strtol(s, &ts, 10);
 			if (*ts != '\0')
 				goto fin;
 			break;
 		case 4:
 			pwd->pw_change = (time_t)strtol(s, &ts, 10);
 			if (*ts != '\0')
 				goto fin;
 			break;
 		case 5:
 			pwd->pw_class = strdup(s);
 			ATF_REQUIRE(pwd->pw_class != NULL);
 			break;
 		case 6:
 			pwd->pw_gecos = strdup(s);
 			ATF_REQUIRE(pwd->pw_gecos != NULL);
 			break;
 		case 7:
 			pwd->pw_dir = strdup(s);
 			ATF_REQUIRE(pwd->pw_dir != NULL);
 			break;
 		case 8:
 			pwd->pw_shell = strdup(s);
 			ATF_REQUIRE(pwd->pw_shell != NULL);
 			break;
 		case 9:
 			pwd->pw_expire = (time_t)strtol(s, &ts, 10);
 			if (*ts != '\0')
 				goto fin;
 			break;
 		case 10:
 			pwd->pw_fields = (int)strtol(s, &ts, 10);
 			if (*ts != '\0')
 				goto fin;
 			break;
 		default:
 			break;
 		}
 		++i;
 	}
 
 fin:
 	if (i != 11) {
 		free_passwd(pwd);
 		memset(pwd, 0, sizeof(struct passwd));
 		return (-1);
 	}
 
 	return (0);
 }
 
 static int
 passwd_fill_test_data(struct passwd_test_data *td)
 {
 	struct passwd *pwd;
 
 	setpassent(1);
 	while ((pwd = getpwent()) != NULL) {
 		if (passwd_test_correctness(pwd, NULL) == 0)
 			TEST_DATA_APPEND(passwd, td, pwd);
 		else
 			return (-1);
 	}
 	endpwent();
 
 	return (0);
 }
 
 static int
 passwd_test_correctness(struct passwd *pwd, void *mdata __unused)
 {
 
 #ifdef DEBUG
 	printf("testing correctness with the following data:\n");
 	dump_passwd(pwd);
 #endif
 
 	if (pwd == NULL)
 		return (-1);
 
 	if (pwd->pw_name == NULL)
 		goto errfin;
 
 	if (pwd->pw_passwd == NULL)
 		goto errfin;
 
 	if (pwd->pw_class == NULL)
 		goto errfin;
 
 	if (pwd->pw_gecos == NULL)
 		goto errfin;
 
 	if (pwd->pw_dir == NULL)
 		goto errfin;
 
 	if (pwd->pw_shell == NULL)
 		goto errfin;
 
 #ifdef DEBUG
 	printf("correct\n");
 #endif
 
 	return (0);
 errfin:
 #ifdef DEBUG
 	printf("incorrect\n");
 #endif
 
 	return (-1);
 }
 
 /* passwd_check_ambiguity() is needed here because when doing the getpwent()
  * calls sequence, records from different nsswitch sources can be different,
  * though having the same pw_name/pw_uid */
 static int
 passwd_check_ambiguity(struct passwd_test_data *td, struct passwd *pwd)
 {
 
-	return (TEST_DATA_FIND(passwd, td, pwd, compare_passwd,
-		NULL) != NULL ? 0 : -1);
+	return (TEST_DATA_FIND(passwd, td, pwd, compare_passwd, NULL) !=
+	    NULL ? 0 : -1);
 }
 
 static int
 passwd_test_getpwnam(struct passwd *pwd_model, void *mdata)
 {
 	struct passwd *pwd;
 
 #ifdef DEBUG
 	printf("testing getpwnam() with the following data:\n");
 	dump_passwd(pwd_model);
 #endif
 
 	pwd = getpwnam(pwd_model->pw_name);
 	if (passwd_test_correctness(pwd, NULL) != 0)
 		goto errfin;
 
-	if ((compare_passwd(pwd, pwd_model, NULL) != 0) &&
-	    (passwd_check_ambiguity((struct passwd_test_data *)mdata, pwd)
-	    !=0))
-	    goto errfin;
+	if (compare_passwd(pwd, pwd_model, NULL) != 0 &&
+	    passwd_check_ambiguity((struct passwd_test_data *)mdata, pwd) != 0)
+		goto errfin;
 
 #ifdef DEBUG
 	printf("ok\n");
 #endif
 	return (0);
 
 errfin:
 #ifdef DEBUG
 	printf("not ok\n");
 #endif
 	return (-1);
 }
 
 static int
 passwd_test_getpwuid(struct passwd *pwd_model, void *mdata)
 {
 	struct passwd *pwd;
 
 #ifdef DEBUG
 	printf("testing getpwuid() with the following data...\n");
 	dump_passwd(pwd_model);
 #endif
 
 	pwd = getpwuid(pwd_model->pw_uid);
-	if ((passwd_test_correctness(pwd, NULL) != 0) ||
-	    ((compare_passwd(pwd, pwd_model, NULL) != 0) &&
-	    (passwd_check_ambiguity((struct passwd_test_data *)mdata, pwd)
-	    != 0))) {
+	if (passwd_test_correctness(pwd, NULL) != 0 ||
+	    (compare_passwd(pwd, pwd_model, NULL) != 0 &&
+	    passwd_check_ambiguity((struct passwd_test_data *)mdata,
+	    pwd) != 0)) {
 #ifdef DEBUG
 		printf("not ok\n");
 #endif
 		return (-1);
 	} else {
 #ifdef DEBUG
 		printf("ok\n");
 #endif
 		return (0);
 	}
 }
 
 static int
 passwd_test_getpwent(struct passwd *pwd, void *mdata __unused)
 {
-	/* Only correctness can be checked when doing 1-pass test for
-	 * getpwent(). */
+	/*
+	 * Only correctness can be checked when doing 1-pass test for
+	 * getpwent().
+	 */
 	return (passwd_test_correctness(pwd, NULL));
 }
 
 static int
 run_tests(const char *snapshot_file, enum test_methods method)
 {
 	struct passwd_test_data td, td_snap, td_2pass;
 	int rv;
 
 	TEST_DATA_INIT(passwd, &td, clone_passwd, free_passwd);
 	TEST_DATA_INIT(passwd, &td_snap, clone_passwd, free_passwd);
 	if (snapshot_file != NULL) {
 		if (access(snapshot_file, W_OK | R_OK) != 0) {
 			if (errno == ENOENT)
 				method = TEST_BUILD_SNAPSHOT;
 			else {
 				printf("can't access the file %s\n",
 				    snapshot_file);
 				rv = -1;
 				goto fin;
 			}
 		} else {
 			if (method == TEST_BUILD_SNAPSHOT) {
 				rv = 0;
 				goto fin;
 			}
 
 			TEST_SNAPSHOT_FILE_READ(passwd, snapshot_file,
-				&td_snap, passwd_read_snapshot_func);
+			    &td_snap, passwd_read_snapshot_func);
 		}
 	}
 
 	rv = passwd_fill_test_data(&td);
 	if (rv == -1)
 		return (-1);
 
 	switch (method) {
 	case TEST_GETPWNAM:
 		if (snapshot_file == NULL)
 			rv = DO_1PASS_TEST(passwd, &td,
-				passwd_test_getpwnam, (void *)&td);
+			    passwd_test_getpwnam, (void *)&td);
 		else
 			rv = DO_1PASS_TEST(passwd, &td_snap,
-				passwd_test_getpwnam, (void *)&td_snap);
+			    passwd_test_getpwnam, (void *)&td_snap);
 		break;
 	case TEST_GETPWUID:
 		if (snapshot_file == NULL)
 			rv = DO_1PASS_TEST(passwd, &td,
-				passwd_test_getpwuid, (void *)&td);
+			    passwd_test_getpwuid, (void *)&td);
 		else
 			rv = DO_1PASS_TEST(passwd, &td_snap,
-				passwd_test_getpwuid, (void *)&td_snap);
+			    passwd_test_getpwuid, (void *)&td_snap);
 		break;
 	case TEST_GETPWENT:
 		if (snapshot_file == NULL)
 			rv = DO_1PASS_TEST(passwd, &td, passwd_test_getpwent,
-				(void *)&td);
+			    (void *)&td);
 		else
 			rv = DO_2PASS_TEST(passwd, &td, &td_snap,
-				compare_passwd, NULL);
+			    compare_passwd, NULL);
 		break;
 	case TEST_GETPWENT_2PASS:
 		TEST_DATA_INIT(passwd, &td_2pass, clone_passwd, free_passwd);
 		rv = passwd_fill_test_data(&td_2pass);
 		if (rv != -1)
 			rv = DO_2PASS_TEST(passwd, &td, &td_2pass,
 			    compare_passwd, NULL);
 		TEST_DATA_DESTROY(passwd, &td_2pass);
 		break;
 	case TEST_BUILD_SNAPSHOT:
 		if (snapshot_file != NULL)
 			rv = TEST_SNAPSHOT_FILE_WRITE(passwd, snapshot_file,
 			    &td, sdump_passwd);
 		break;
 	default:
 		rv = 0;
 		break;
 	}
 
 fin:
 	TEST_DATA_DESTROY(passwd, &td_snap);
 	TEST_DATA_DESTROY(passwd, &td);
 
 	return (rv);
 }
 
 #define	SNAPSHOT_FILE	"snapshot_pwd"
 
 ATF_TC_WITHOUT_HEAD(build_snapshot);
 ATF_TC_BODY(build_snapshot, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getpwent);
 ATF_TC_BODY(getpwent, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPWENT) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getpwent_with_snapshot);
 ATF_TC_BODY(getpwent_with_snapshot, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPWENT) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getpwent_with_two_pass);
 ATF_TC_BODY(getpwent_with_two_pass, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPWENT_2PASS) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getpwnam);
 ATF_TC_BODY(getpwnam, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPWNAM) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getpwnam_with_snapshot);
 ATF_TC_BODY(getpwnam_with_snapshot, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPWNAM) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getpwuid);
 ATF_TC_BODY(getpwuid, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPWUID) == 0);
 }
 
 ATF_TC_WITHOUT_HEAD(getpwuid_with_snapshot);
 ATF_TC_BODY(getpwuid_with_snapshot, tc)
 {
 
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0);
 	ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETPWUID) == 0);
 }
 
 ATF_TP_ADD_TCS(tp)
 {
 
 	ATF_TP_ADD_TC(tp, build_snapshot);
 	ATF_TP_ADD_TC(tp, getpwent);
 	ATF_TP_ADD_TC(tp, getpwent_with_snapshot);
 	ATF_TP_ADD_TC(tp, getpwent_with_two_pass);
 	ATF_TP_ADD_TC(tp, getpwnam);
 	ATF_TP_ADD_TC(tp, getpwnam_with_snapshot);
 	ATF_TP_ADD_TC(tp, getpwuid);
 	ATF_TP_ADD_TC(tp, getpwuid_with_snapshot);
 
 	return (atf_no_error());
 }
diff --git a/lib/libc/tests/nss/testutil.h b/lib/libc/tests/nss/testutil.h
index ff9e8f0a9304..7b55e16580d1 100644
--- a/lib/libc/tests/nss/testutil.h
+++ b/lib/libc/tests/nss/testutil.h
@@ -1,330 +1,330 @@
 /*-
  * Copyright (c) 2006 Michael Bushkov <bushman@freebsd.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  * $FreeBSD$
  */
 
 #include <sys/queue.h>
 
 #define DECLARE_TEST_DATA(ent)						\
 struct ent##_entry {							\
 	struct ent data;						\
 	STAILQ_ENTRY(ent##_entry) entries;				\
 };									\
 									\
 struct ent##_test_data {						\
 	void (*clone_func)(struct ent *, struct ent const *);		\
 	void (*free_func)(struct ent *);				\
 									\
 	STAILQ_HEAD(ent_head, ent##_entry) snapshot_data;		\
 };									\
 									\
 void __##ent##_test_data_init(struct ent##_test_data *, 		\
 	void (*)(struct ent *, struct ent const *),			\
 	void (*freef)(struct ent *));		 			\
 void __##ent##_test_data_destroy(struct ent##_test_data *);		\
 									\
 void __##ent##_test_data_append(struct ent##_test_data *, struct ent *data);\
 int __##ent##_test_data_foreach(struct ent##_test_data *,		\
 	int (*)(struct ent *, void *), void *);				\
 int __##ent##_test_data_compare(struct ent##_test_data *,		\
 	struct ent##_test_data *, int (*)(struct ent *, struct ent *,	\
 	void *), void *);						\
 struct ent *__##ent##_test_data_find(struct ent##_test_data *, struct ent *,\
 	int (*)(struct ent *, struct ent *, void *), void *);		\
 void __##ent##_test_data_clear(struct ent##_test_data *);
 
 #define TEST_DATA_INIT(ent, td, clonef, freef)\
 	__##ent##_test_data_init(td, clonef, freef)
 #define TEST_DATA_DESTROY(ent, td) __##ent##_test_data_destroy(td)
 #define TEST_DATA_APPEND(ent, td, d) __##ent##_test_data_append(td, d)
 #define TEST_DATA_FOREACH(ent, td, f, mdata)\
 	__##ent##_test_data_foreach(td, f, mdata)
 #define TEST_DATA_COMPARE(ent, td1, td2, fcmp, mdata)\
 	__##ent##_test_data_compare(td1, td2, fcmp, mdata);
 #define TEST_DATA_FIND(ent, td, d, fcmp, mdata)\
 	__##ent##_test_data_find(td, d, fcmp, mdata)
 #define TEST_DATA_CLEAR(ent, td) __##ent##_test_data_clear(td)
 
 #define IMPLEMENT_TEST_DATA(ent)					\
 void									\
 __##ent##_test_data_init(struct ent##_test_data *td,			\
 	void (*clonef)(struct ent *, struct ent const *),		\
 	void (*freef)(struct ent *))					\
 {									\
 	ATF_REQUIRE(td != NULL);					\
 	ATF_REQUIRE(clonef != NULL);					\
 	ATF_REQUIRE(freef != NULL);					\
 									\
 	memset(td, 0, sizeof(*td));					\
 	td->clone_func = clonef;					\
 	td->free_func = freef;						\
 	STAILQ_INIT(&td->snapshot_data);				\
 }									\
 									\
 void 									\
 __##ent##_test_data_destroy(struct ent##_test_data *td)			\
 {									\
 	__##ent##_test_data_clear(td);					\
 }									\
 									\
 void 									\
 __##ent##_test_data_append(struct ent##_test_data *td, struct ent *app_data)\
 {									\
 	struct ent##_entry *e;						\
 									\
 	ATF_REQUIRE(td != NULL);					\
 	ATF_REQUIRE(app_data != NULL);					\
 									\
 	e = (struct ent##_entry *)malloc(sizeof(struct ent##_entry));	\
 	ATF_REQUIRE(e != NULL);						\
 	memset(e, 0, sizeof(struct ent##_entry));			\
 									\
 	td->clone_func(&e->data, app_data);				\
 	STAILQ_INSERT_TAIL(&td->snapshot_data, e, entries);		\
 }									\
 									\
 int									\
 __##ent##_test_data_foreach(struct ent##_test_data *td,			\
 	int (*forf)(struct ent *, void *), void *mdata)			\
 {									\
 	struct ent##_entry *e;						\
 	int rv;								\
 									\
 	ATF_REQUIRE(td != NULL);					\
 	ATF_REQUIRE(forf != NULL);					\
 									\
 	rv = 0;								\
 	STAILQ_FOREACH(e, &td->snapshot_data, entries) {		\
 		rv = forf(&e->data, mdata);				\
 		if (rv != 0)						\
 			break;						\
 	}								\
 									\
 	return (rv);							\
 }									\
 									\
 int									\
 __##ent##_test_data_compare(struct ent##_test_data *td1, struct ent##_test_data *td2,\
 	int (*cmp_func)(struct ent *, struct ent *, void *), void *mdata)\
 {									\
 	struct ent##_entry *e1, *e2;					\
 	int rv;								\
 									\
 	ATF_REQUIRE(td1 != NULL);					\
 	ATF_REQUIRE(td2 != NULL);					\
 	ATF_REQUIRE(cmp_func != NULL);					\
 									\
 	e1 = STAILQ_FIRST(&td1->snapshot_data);				\
 	e2 = STAILQ_FIRST(&td2->snapshot_data);				\
 									\
 	rv = 0;								\
 	do {								\
 		if ((e1 == NULL) || (e2 == NULL)) {			\
 			if (e1 == e2)					\
 				return (0);				\
 			else						\
 				return (-1);				\
 		}							\
 									\
 		rv = cmp_func(&e1->data, &e2->data, mdata);		\
 		e1 = STAILQ_NEXT(e1, entries);				\
 		e2 = STAILQ_NEXT(e2, entries);				\
 	} while (rv == 0);						\
 									\
 	return (rv);							\
 }									\
 									\
 struct ent *								\
 __##ent##_test_data_find(struct ent##_test_data *td, struct ent *data,	\
 	int (*cmp)(struct ent *, struct ent *, void *), void *mdata)	\
 {									\
 	struct ent##_entry *e;						\
 	struct ent *result;						\
 									\
 	ATF_REQUIRE(td != NULL);					\
 	ATF_REQUIRE(cmp != NULL);					\
 									\
 	result = NULL;							\
 	STAILQ_FOREACH(e, &td->snapshot_data, entries) {		\
 		if (cmp(&e->data, data, mdata) == 0) {			\
 			result = &e->data;				\
 			break;						\
 		}							\
 	}								\
 									\
 	return (result);						\
 }									\
 									\
 									\
 void									\
 __##ent##_test_data_clear(struct ent##_test_data *td)			\
 {									\
 	struct ent##_entry *e;						\
 	ATF_REQUIRE(td != NULL);					\
 									\
 	while (!STAILQ_EMPTY(&td->snapshot_data)) {			\
 		e = STAILQ_FIRST(&td->snapshot_data);			\
 		STAILQ_REMOVE_HEAD(&td->snapshot_data, entries);	\
 									\
 		td->free_func(&e->data);				\
 		free(e);						\
 		e = NULL;						\
 	}								\
 }
 
 #define DECLARE_TEST_FILE_SNAPSHOT(ent)					\
 struct ent##_snp_param {						\
 	FILE *fp;							\
 	void (*sdump_func)(struct ent *, char *, size_t);		\
 };									\
 									\
 int __##ent##_snapshot_write_func(struct ent *, void *);		\
 int __##ent##_snapshot_write(char const *, struct ent##_test_data *,	\
 	void (*)(struct ent *, char *, size_t));			\
 int __##ent##_snapshot_read(char const *, struct ent##_test_data *,	\
 	int (*)(struct ent *, char *));
 
 #define TEST_SNAPSHOT_FILE_WRITE(ent, fname, td, f)			\
 	__##ent##_snapshot_write(fname, td, f)
 #define TEST_SNAPSHOT_FILE_READ(ent, fname, td, f)			\
 	__##ent##_snapshot_read(fname, td, f)
 
 #define IMPLEMENT_TEST_FILE_SNAPSHOT(ent)				\
 int									\
 __##ent##_snapshot_write_func(struct ent *data, void *mdata)		\
 {									\
 	char buffer[1024];						\
 	struct ent##_snp_param *param;					\
 									\
 	ATF_REQUIRE(data != NULL);					\
 									\
 	param = (struct ent##_snp_param *)mdata;			\
 	param->sdump_func(data, buffer, sizeof(buffer));		\
 	fputs(buffer, param->fp);					\
 	fputc('\n', param->fp);						\
 									\
 	return (0);							\
 }									\
 									\
 int									\
 __##ent##_snapshot_write(char const *fname, struct ent##_test_data *td,	\
 	void (*sdump_func)(struct ent *, char *, size_t))		\
 {									\
 	struct ent##_snp_param	param;					\
 									\
 	ATF_REQUIRE(fname != NULL);					\
 	ATF_REQUIRE(td != NULL);					\
 									\
 	param.fp = fopen(fname, "w");					\
 	if (param.fp == NULL)						\
 		return (-1);						\
 									\
 	param.sdump_func = sdump_func;					\
 	__##ent##_test_data_foreach(td, __##ent##_snapshot_write_func, &param);\
 	fclose(param.fp);						\
 									\
 	return (0);							\
 }									\
 									\
 int									\
 __##ent##_snapshot_read(char const *fname, struct ent##_test_data *td,	\
 	int (*read_func)(struct ent *, char *))				\
 {									\
 	struct ent data;						\
 	FILE *fi;							\
 	size_t len;							\
 	int rv;								\
 									\
 	ATF_REQUIRE(fname != NULL);					\
 	ATF_REQUIRE(td != NULL);					\
 									\
 	fi = fopen(fname, "r");						\
 	if (fi == NULL)							\
 		return (-1);						\
 									\
 	rv = 0;								\
 	while (!feof(fi)) {						\
 		char *buf = fgetln(fi, &len);				\
 		if (buf == NULL || len <= 1)				\
 			continue;					\
 		if (buf[len - 1] == '\n')				\
 			buf[len - 1] = '\0';				\
 		else							\
 			buf[len] = '\0';				\
 		if (buf[0] == '#')					\
 			continue;					\
 		rv = read_func(&data, buf);				\
 		if (rv == 0) {						\
 			__##ent##_test_data_append(td, &data);		\
 			td->free_func(&data);				\
 		} else 							\
 			goto fin;					\
 	}								\
 									\
 fin:									\
 	fclose(fi);							\
 	return (rv);							\
 }
 
 #define DECLARE_1PASS_TEST(ent)						\
 int __##ent##_1pass_test(struct ent##_test_data *, 			\
 	int (*)(struct ent *, void *),					\
 	void *);
 
 #define DO_1PASS_TEST(ent, td, f, mdata)				\
 	__##ent##_1pass_test(td, f, mdata)
 
 #define IMPLEMENT_1PASS_TEST(ent)					\
 int									\
 __##ent##_1pass_test(struct ent##_test_data *td, 			\
 	int (*tf)(struct ent *, void *),				\
 	void *mdata)							\
 {									\
 	int rv;								\
 	rv = __##ent##_test_data_foreach(td, tf, mdata);		\
 									\
 	return (rv);							\
 }
 
 #define DECLARE_2PASS_TEST(ent)						\
 int __##ent##_2pass_test(struct ent##_test_data *, 			\
 	struct ent##_test_data *, 					\
 	int (*)(struct ent *, struct ent *, void *), void *);
 
 #define DO_2PASS_TEST(ent, td1, td2, f, mdata)				\
 	__##ent##_2pass_test(td1, td2, f, mdata)
 
 #define IMPLEMENT_2PASS_TEST(ent)					\
 int									\
 __##ent##_2pass_test(struct ent##_test_data *td1,			\
 	struct ent##_test_data *td2,					\
 	int (*cmp_func)(struct ent *, struct ent *, void *),		\
 	void *cmp_mdata)						\
 {									\
 	int rv;								\
 									\
-	rv = __##ent##_test_data_compare(td1, td2, cmp_func, cmp_mdata);	\
+	rv = __##ent##_test_data_compare(td1, td2, cmp_func, cmp_mdata);\
 	return (rv);							\
 }