Index: head/lib/libc/tests/nss/getaddrinfo_test.c =================================================================== --- head/lib/libc/tests/nss/getaddrinfo_test.c (revision 319028) +++ head/lib/libc/tests/nss/getaddrinfo_test.c (revision 319029) @@ -1,556 +1,556 @@ /*- * Copyright (c) 2006 Michael Bushkov * 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include "freebsd_test_suite/macros.h" #include "testutil.h" enum test_methods { TEST_GETADDRINFO, TEST_BUILD_SNAPSHOT }; static struct addrinfo hints; static enum test_methods method = TEST_GETADDRINFO; DECLARE_TEST_DATA(addrinfo) DECLARE_TEST_FILE_SNAPSHOT(addrinfo) DECLARE_2PASS_TEST(addrinfo) static void clone_addrinfo(struct addrinfo *, struct addrinfo const *); static int compare_addrinfo(struct addrinfo *, struct addrinfo *, void *); static void dump_addrinfo(struct addrinfo *); static void sdump_addrinfo(struct addrinfo *, char *, size_t); IMPLEMENT_TEST_DATA(addrinfo) IMPLEMENT_TEST_FILE_SNAPSHOT(addrinfo) IMPLEMENT_2PASS_TEST(addrinfo) static void clone_addrinfo(struct addrinfo *dest, struct addrinfo const *src) { ATF_REQUIRE(dest != NULL); ATF_REQUIRE(src != NULL); memcpy(dest, src, sizeof(struct addrinfo)); if (src->ai_canonname != NULL) dest->ai_canonname = strdup(src->ai_canonname); if (src->ai_addr != NULL) { dest->ai_addr = malloc(src->ai_addrlen); ATF_REQUIRE(dest->ai_addr != NULL); memcpy(dest->ai_addr, src->ai_addr, src->ai_addrlen); } if (src->ai_next != NULL) { dest->ai_next = malloc(sizeof(struct addrinfo)); ATF_REQUIRE(dest->ai_next != NULL); clone_addrinfo(dest->ai_next, src->ai_next); } } static int compare_addrinfo_(struct addrinfo *ai1, struct addrinfo *ai2) { if ((ai1 == NULL) || (ai2 == NULL)) return (-1); if (ai1->ai_flags != ai2->ai_flags || ai1->ai_family != ai2->ai_family || ai1->ai_socktype != ai2->ai_socktype || ai1->ai_protocol != ai2->ai_protocol || ai1->ai_addrlen != ai2->ai_addrlen || ((ai1->ai_addr == NULL || ai2->ai_addr == NULL) && ai1->ai_addr != ai2->ai_addr) || ((ai1->ai_canonname == NULL || ai2->ai_canonname == NULL) && ai1->ai_canonname != ai2->ai_canonname)) return (-1); if (ai1->ai_canonname != NULL && strcmp(ai1->ai_canonname, ai2->ai_canonname) != 0) return (-1); if (ai1->ai_addr != NULL && memcmp(ai1->ai_addr, ai2->ai_addr, ai1->ai_addrlen) != 0) return (-1); if (ai1->ai_next == NULL && ai2->ai_next == NULL) return (0); else return (compare_addrinfo_(ai1->ai_next, ai2->ai_next)); } static int compare_addrinfo(struct addrinfo *ai1, struct addrinfo *ai2, void *mdata) { int rv; printf("testing equality of 2 addrinfo structures\n"); rv = compare_addrinfo_(ai1, ai2); if (rv == 0) printf("equal\n"); else { dump_addrinfo(ai1); dump_addrinfo(ai2); printf("not equal\n"); } return (rv); } -void +static void free_addrinfo(struct addrinfo *ai) { if (ai == NULL) return; free(ai->ai_addr); free(ai->ai_canonname); free_addrinfo(ai->ai_next); } void sdump_addrinfo(struct addrinfo *ai, char *buffer, size_t buflen) { int written, i; written = snprintf(buffer, buflen, "%d %d %d %d %d ", ai->ai_flags, ai->ai_family, ai->ai_socktype, ai->ai_protocol, ai->ai_addrlen); buffer += written; if (written > buflen) return; buflen -= written; written = snprintf(buffer, buflen, "%s ", ai->ai_canonname == NULL ? "(null)" : ai->ai_canonname); buffer += written; if (written > buflen) return; buflen -= written; if (ai->ai_addr == NULL) { written = snprintf(buffer, buflen, "(null)"); buffer += written; if (written > buflen) return; buflen -= written; } else { for (i = 0; i < ai->ai_addrlen; i++) { written = snprintf(buffer, buflen, i + 1 != ai->ai_addrlen ? "%d." : "%d", ((unsigned char *)ai->ai_addr)[i]); buffer += written; if (written > buflen) return; buflen -= written; if (buflen == 0) return; } } if (ai->ai_next != NULL) { written = snprintf(buffer, buflen, ":"); buffer += written; if (written > buflen) return; buflen -= written; sdump_addrinfo(ai->ai_next, buffer, buflen); } } void dump_addrinfo(struct addrinfo *result) { if (result != NULL) { char buffer[2048]; sdump_addrinfo(result, buffer, sizeof(buffer)); printf("%s\n", buffer); } else printf("(null)\n"); } static int addrinfo_read_snapshot_addr(char *addr, unsigned char *result, size_t len) { char *s, *ps, *ts; ps = addr; while ((s = strsep(&ps, ".")) != NULL) { if (len == 0) return (-1); *result = (unsigned char)strtol(s, &ts, 10); ++result; if (*ts != '\0') return (-1); --len; } if (len != 0) return (-1); else return (0); } static int addrinfo_read_snapshot_ai(struct addrinfo *ai, char *line) { char *s, *ps, *ts; int i, rv, *pi; rv = 0; i = 0; ps = line; memset(ai, 0, sizeof(struct addrinfo)); while ((s = strsep(&ps, " ")) != NULL) { switch (i) { case 0: case 1: case 2: case 3: pi = &ai->ai_flags + i; *pi = (int)strtol(s, &ts, 10); if (*ts != '\0') goto fin; break; case 4: ai->ai_addrlen = (socklen_t)strtol(s, &ts, 10); if (*ts != '\0') goto fin; break; case 5: if (strcmp(s, "(null)") != 0) { ai->ai_canonname = strdup(s); ATF_REQUIRE(ai->ai_canonname != NULL); } break; case 6: if (strcmp(s, "(null)") != 0) { ai->ai_addr = calloc(1, ai->ai_addrlen); ATF_REQUIRE(ai->ai_addr != NULL); rv = addrinfo_read_snapshot_addr(s, (unsigned char *)ai->ai_addr, ai->ai_addrlen); if (rv != 0) goto fin; } break; default: /* NOTE: should not be reachable */ rv = -1; goto fin; } ++i; } fin: if (i != 7 || rv != 0) { free_addrinfo(ai); ai = NULL; return (-1); } return (0); } static int addrinfo_read_snapshot_func(struct addrinfo *ai, char *line) { struct addrinfo *ai2; char *s, *ps; int i, rv; printf("1 line read from snapshot:\n%s\n", line); rv = 0; i = 0; ps = line; s = strsep(&ps, ":"); if (s == NULL) return (-1); rv = addrinfo_read_snapshot_ai(ai, s); if (rv != 0) return (-1); ai2 = ai; while ((s = strsep(&ps, ":")) != NULL) { ai2->ai_next = calloc(1, sizeof(struct addrinfo)); ATF_REQUIRE(ai2->ai_next != NULL); rv = addrinfo_read_snapshot_ai(ai2->ai_next, s); if (rv != 0) { free_addrinfo(ai); ai = NULL; return (-1); } ai2 = ai2->ai_next; } return (0); } static int addrinfo_test_correctness(struct addrinfo *ai, void *mdata) { printf("testing correctness with the following data:\n"); dump_addrinfo(ai); if (ai == NULL) goto errfin; if (!(ai->ai_family >= 0 && ai->ai_family < AF_MAX)) goto errfin; if (ai->ai_socktype != 0 && ai->ai_socktype != SOCK_STREAM && ai->ai_socktype != SOCK_DGRAM && ai->ai_socktype != SOCK_RAW) goto errfin; if (ai->ai_protocol != 0 && ai->ai_protocol != IPPROTO_UDP && ai->ai_protocol != IPPROTO_TCP) goto errfin; if ((ai->ai_flags & ~(AI_CANONNAME | AI_NUMERICHOST | AI_PASSIVE)) != 0) goto errfin; if (ai->ai_addrlen != ai->ai_addr->sa_len || ai->ai_family != ai->ai_addr->sa_family) goto errfin; printf("correct\n"); return (0); errfin: printf("incorrect\n"); return (-1); } static int addrinfo_read_hostlist_func(struct addrinfo *ai, char *line) { struct addrinfo *result; int rv; printf("resolving %s: ", line); rv = getaddrinfo(line, NULL, &hints, &result); if (rv == 0) { printf("found\n"); rv = addrinfo_test_correctness(result, NULL); if (rv != 0) { freeaddrinfo(result); result = NULL; return (rv); } clone_addrinfo(ai, result); freeaddrinfo(result); result = NULL; } else { printf("not found\n"); memset(ai, 0, sizeof(struct addrinfo)); } return (0); } -void +static void run_tests(char *hostlist_file, char *snapshot_file, int ai_family) { struct addrinfo_test_data td, td_snap; int rv; memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = ai_family; hints.ai_flags = AI_CANONNAME; if (snapshot_file != NULL) method = TEST_BUILD_SNAPSHOT; TEST_DATA_INIT(addrinfo, &td, clone_addrinfo, free_addrinfo); TEST_DATA_INIT(addrinfo, &td_snap, clone_addrinfo, free_addrinfo); ATF_REQUIRE_MSG(access(hostlist_file, R_OK) == 0, "can't access the hostlist file %s\n", hostlist_file); printf("building host lists from %s\n", hostlist_file); rv = TEST_SNAPSHOT_FILE_READ(addrinfo, hostlist_file, &td, addrinfo_read_hostlist_func); if (rv != 0) goto fin; 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 snapshot " "file %s\n", snapshot_file); rv = -1; goto fin; } } else { rv = TEST_SNAPSHOT_FILE_READ(addrinfo, snapshot_file, &td_snap, addrinfo_read_snapshot_func); if (rv != 0) { printf("error reading snapshot file: %s\n", strerror(errno)); goto fin; } } } switch (method) { case TEST_GETADDRINFO: if (snapshot_file != NULL) ATF_CHECK(DO_2PASS_TEST(addrinfo, &td, &td_snap, compare_addrinfo, NULL) == 0); break; case TEST_BUILD_SNAPSHOT: if (snapshot_file != NULL) { ATF_CHECK(TEST_SNAPSHOT_FILE_WRITE(addrinfo, snapshot_file, &td, sdump_addrinfo) == 0); } break; default: break; } fin: TEST_DATA_DESTROY(addrinfo, &td_snap); TEST_DATA_DESTROY(addrinfo, &td); free(hostlist_file); free(snapshot_file); } #define HOSTLIST_FILE "mach" #define RUN_TESTS(tc, snapshot_file, ai_family) do { \ char *_hostlist_file; \ char *_snapshot_file; \ ATF_REQUIRE(0 < asprintf(&_hostlist_file, "%s/%s", \ atf_tc_get_config_var(tc, "srcdir"), HOSTLIST_FILE)); \ if (snapshot_file == NULL) \ _snapshot_file = NULL; \ else { \ _snapshot_file = strdup(snapshot_file); \ ATF_REQUIRE(_snapshot_file != NULL); \ } \ run_tests(_hostlist_file, _snapshot_file, ai_family); \ } while(0) ATF_TC_WITHOUT_HEAD(pf_unspec); ATF_TC_BODY(pf_unspec, tc) { RUN_TESTS(tc, NULL, AF_UNSPEC); } ATF_TC_WITHOUT_HEAD(pf_unspec_with_snapshot); ATF_TC_BODY(pf_unspec_with_snapshot, tc) { RUN_TESTS(tc, "snapshot_ai", AF_UNSPEC); } ATF_TC_WITHOUT_HEAD(pf_inet); ATF_TC_BODY(pf_inet, tc) { ATF_REQUIRE_FEATURE("inet"); RUN_TESTS(tc, NULL, AF_INET); } ATF_TC_WITHOUT_HEAD(pf_inet_with_snapshot); ATF_TC_BODY(pf_inet_with_snapshot, tc) { ATF_REQUIRE_FEATURE("inet"); RUN_TESTS(tc, "snapshot_ai4", AF_INET); } ATF_TC_WITHOUT_HEAD(pf_inet6); ATF_TC_BODY(pf_inet6, tc) { ATF_REQUIRE_FEATURE("inet6"); RUN_TESTS(tc, NULL, AF_INET6); } ATF_TC_WITHOUT_HEAD(pf_inet6_with_snapshot); ATF_TC_BODY(pf_inet6_with_snapshot, tc) { ATF_REQUIRE_FEATURE("inet6"); RUN_TESTS(tc, "snapshot_ai6", AF_INET6); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, pf_unspec); ATF_TP_ADD_TC(tp, pf_unspec_with_snapshot); ATF_TP_ADD_TC(tp, pf_inet); ATF_TP_ADD_TC(tp, pf_inet_with_snapshot); ATF_TP_ADD_TC(tp, pf_inet6); ATF_TP_ADD_TC(tp, pf_inet6_with_snapshot); return (atf_no_error()); } Index: head/lib/libc/tests/nss/getgr_test.c =================================================================== --- head/lib/libc/tests/nss/getgr_test.c (revision 319028) +++ head/lib/libc/tests/nss/getgr_test.c (revision 319029) @@ -1,546 +1,544 @@ /*- * Copyright (c) 2006 Michael Bushkov * 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include "testutil.h" enum test_methods { TEST_GETGRENT = 1, TEST_GETGRNAM = 2, TEST_GETGRGID = 4, TEST_GETGRENT_2PASS = 8, TEST_BUILD_SNAPSHOT = 16, }; -static enum test_methods method = TEST_BUILD_SNAPSHOT; - 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_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 != '\0' || *c2 != '\0') 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); buffer += written; if (written > buflen) return; buflen -= written; if (grp->gr_mem != NULL) { if (*(grp->gr_mem) != '\0') { for (cp = grp->gr_mem; *cp; ++cp) { written = snprintf(buffer, buflen, "%s%s", cp == grp->gr_mem ? "" : ",", *cp); buffer += written; if (written > 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) { 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); } 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)) { return (-1); } else { return (0); } } static int group_test_getgrent(struct group *grp, void *mdata) { /* 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); 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()); } Index: head/lib/libc/tests/nss/getpw_test.c =================================================================== --- head/lib/libc/tests/nss/getpw_test.c (revision 319028) +++ head/lib/libc/tests/nss/getpw_test.c (revision 319029) @@ -1,530 +1,528 @@ /*- * Copyright (c) 2006 Michael Bushkov * 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include "testutil.h" enum test_methods { TEST_GETPWENT, TEST_GETPWNAM, TEST_GETPWUID, TEST_GETPWENT_2PASS, TEST_BUILD_SNAPSHOT }; -static enum test_methods method = 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); static void dump_passwd(struct passwd *); 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) { 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); } 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"); } 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) { #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); } 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; #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))) { #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) { /* 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); } } 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); else rv = DO_1PASS_TEST(passwd, &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); else rv = DO_1PASS_TEST(passwd, &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); else rv = DO_2PASS_TEST(passwd, &td, &td_snap, 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()); } Index: head/lib/libc/tests/nss/getusershell_test.c =================================================================== --- head/lib/libc/tests/nss/getusershell_test.c (revision 319028) +++ head/lib/libc/tests/nss/getusershell_test.c (revision 319029) @@ -1,225 +1,223 @@ /*- * Copyright (c) 2006 Michael Bushkov * 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 __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include "testutil.h" enum test_methods { TEST_GETUSERSHELL, TEST_BUILD_SNAPSHOT }; struct usershell { char *path; }; -static enum test_methods method = TEST_GETUSERSHELL; - DECLARE_TEST_DATA(usershell) DECLARE_TEST_FILE_SNAPSHOT(usershell) DECLARE_2PASS_TEST(usershell) static void clone_usershell(struct usershell *, struct usershell const *); static int compare_usershell(struct usershell *, struct usershell *, void *); static void free_usershell(struct usershell *); static void sdump_usershell(struct usershell *, char *, size_t); static void dump_usershell(struct usershell *); IMPLEMENT_TEST_DATA(usershell) IMPLEMENT_TEST_FILE_SNAPSHOT(usershell) IMPLEMENT_2PASS_TEST(usershell) static void clone_usershell(struct usershell *dest, struct usershell const *src) { assert(dest != NULL); assert(src != NULL); if (src->path != NULL) { dest->path = strdup(src->path); assert(dest->path != NULL); } } static int compare_usershell(struct usershell *us1, struct usershell *us2, void *mdata) { int rv; assert(us1 != NULL); assert(us2 != NULL); dump_usershell(us1); dump_usershell(us2); if (us1 == us2) return (0); rv = strcmp(us1->path, us2->path); if (rv != 0) { printf("following structures are not equal:\n"); dump_usershell(us1); dump_usershell(us2); } return (rv); } static void free_usershell(struct usershell *us) { free(us->path); } static void sdump_usershell(struct usershell *us, char *buffer, size_t buflen) { snprintf(buffer, buflen, "%s", us->path); } static void dump_usershell(struct usershell *us) { if (us != NULL) { char buffer[2048]; sdump_usershell(us, buffer, sizeof(buffer)); printf("%s\n", buffer); } else printf("(null)\n"); } static int usershell_read_snapshot_func(struct usershell *us, char *line) { us->path = strdup(line); ATF_REQUIRE(us->path != NULL); return (0); } int run_tests(const char *snapshot_file, enum test_methods method) { struct usershell_test_data td, td_snap; struct usershell ushell; int rv; rv = 0; TEST_DATA_INIT(usershell, &td, clone_usershell, free_usershell); TEST_DATA_INIT(usershell, &td_snap, clone_usershell, free_usershell); setusershell(); while ((ushell.path = getusershell()) != NULL) { printf("usershell found:\n"); dump_usershell(&ushell); TEST_DATA_APPEND(usershell, &td, &ushell); } endusershell(); 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 snapshot file %s\n", snapshot_file); rv = -1; goto fin; } } else { rv = TEST_SNAPSHOT_FILE_READ(usershell, snapshot_file, &td_snap, usershell_read_snapshot_func); if (rv != 0) { printf("error reading snapshot file\n"); goto fin; } } } switch (method) { case TEST_GETUSERSHELL: rv = DO_2PASS_TEST(usershell, &td, &td_snap, compare_usershell, NULL); break; case TEST_BUILD_SNAPSHOT: if (snapshot_file != NULL) { rv = TEST_SNAPSHOT_FILE_WRITE(usershell, snapshot_file, &td, sdump_usershell); } break; default: rv = 0; break; } fin: TEST_DATA_DESTROY(usershell, &td_snap); TEST_DATA_DESTROY(usershell, &td); return (rv); } #define SNAPSHOT_FILE "snapshot_usershell" ATF_TC_WITHOUT_HEAD(getusershell_with_snapshot); ATF_TC_BODY(getusershell_with_snapshot, tc) { ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0); } ATF_TC_WITHOUT_HEAD(getusershell_with_two_pass); ATF_TC_BODY(getusershell_with_two_pass, tc) { ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_BUILD_SNAPSHOT) == 0); ATF_REQUIRE(run_tests(SNAPSHOT_FILE, TEST_GETUSERSHELL) == 0); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, getusershell_with_snapshot); ATF_TP_ADD_TC(tp, getusershell_with_two_pass); return (atf_no_error()); }