diff options
Diffstat (limited to 'contrib/netbsd-tests/include')
| -rw-r--r-- | contrib/netbsd-tests/include/sys/t_bitops.c | 204 | ||||
| -rw-r--r-- | contrib/netbsd-tests/include/sys/t_cdefs.c | 116 | ||||
| -rw-r--r-- | contrib/netbsd-tests/include/sys/t_pslist.c | 125 | ||||
| -rw-r--r-- | contrib/netbsd-tests/include/sys/t_socket.c | 4 | ||||
| -rw-r--r-- | contrib/netbsd-tests/include/t_paths.c | 23 |
5 files changed, 367 insertions, 105 deletions
diff --git a/contrib/netbsd-tests/include/sys/t_bitops.c b/contrib/netbsd-tests/include/sys/t_bitops.c index 7c90da0..6bdeb2b 100644 --- a/contrib/netbsd-tests/include/sys/t_bitops.c +++ b/contrib/netbsd-tests/include/sys/t_bitops.c @@ -1,4 +1,4 @@ -/* $NetBSD: t_bitops.c,v 1.16 2012/12/07 02:28:19 christos Exp $ */ +/* $NetBSD: t_bitops.c,v 1.19 2015/03/21 05:50:19 isaki Exp $ */ /*- * Copyright (c) 2011, 2012 The NetBSD Foundation, Inc. @@ -29,7 +29,7 @@ * POSSIBILITY OF SUCH DAMAGE. */ #include <sys/cdefs.h> -__RCSID("$NetBSD: t_bitops.c,v 1.16 2012/12/07 02:28:19 christos Exp $"); +__RCSID("$NetBSD: t_bitops.c,v 1.19 2015/03/21 05:50:19 isaki Exp $"); #include <atf-c.h> @@ -67,7 +67,7 @@ static const struct { ATF_TC(bitmap_basic); ATF_TC_HEAD(bitmap_basic, tc) { - atf_tc_set_md_var(tc, "descr", "A basic test of __BITMAP_*"); + atf_tc_set_md_var(tc, "descr", "A basic test of __BITMAP_*"); } ATF_TC_BODY(bitmap_basic, tc) @@ -174,65 +174,191 @@ ATF_TC_BODY(ffsfls, tc) } } -ATF_TC(ilog2_basic); -ATF_TC_HEAD(ilog2_basic, tc) +ATF_TC(ilog2_32bit); +ATF_TC_HEAD(ilog2_32bit, tc) { - atf_tc_set_md_var(tc, "descr", "Test ilog2(3) for correctness"); + atf_tc_set_md_var(tc, "descr", "Test ilog2(3) for 32bit variable"); } -ATF_TC_BODY(ilog2_basic, tc) +ATF_TC_BODY(ilog2_32bit, tc) { - uint64_t i, x; + int i; + uint32_t x; - for (i = x = 0; i < 64; i++) { + for (i = 0; i < 32; i++) { + x = 1 << i; + ATF_REQUIRE(ilog2(x) == i); + } +} + +ATF_TC(ilog2_64bit); +ATF_TC_HEAD(ilog2_64bit, tc) +{ + atf_tc_set_md_var(tc, "descr", "Test ilog2(3) for 64bit variable"); +} - x = (uint64_t)1 << i; +ATF_TC_BODY(ilog2_64bit, tc) +{ + int i; + uint64_t x; - ATF_REQUIRE(i == (uint64_t)ilog2(x)); + for (i = 0; i < 64; i++) { + x = ((uint64_t)1) << i; + ATF_REQUIRE(ilog2(x) == i); } } -ATF_TC(ilog2_log2); -ATF_TC_HEAD(ilog2_log2, tc) +ATF_TC(ilog2_const); +ATF_TC_HEAD(ilog2_const, tc) { - atf_tc_set_md_var(tc, "descr", "Test log2(3) vs. ilog2(3)"); + atf_tc_set_md_var(tc, "descr", "Test ilog2(3) for constant"); } -ATF_TC_BODY(ilog2_log2, tc) +ATF_TC_BODY(ilog2_const, tc) { -#ifdef __vax__ - atf_tc_skip("Test is unavailable on vax because of lack of log2()"); -#else - double x, y; - uint64_t i; - /* - * This may fail under QEMU; see PR misc/44767. + * These inlines test __builtin_constant_p() part of ilog2() + * at compile time, so don't change it to loop. PR lib/49745 */ - for (i = 1; i < UINT32_MAX; i += UINT16_MAX) { - - x = log2(i); - y = (double)(ilog2(i)); - - ATF_REQUIRE(ceil(x) >= y); - - if (fabs(floor(x) - y) > 1.0e-40) { - atf_tc_expect_fail("PR misc/44767"); - atf_tc_fail("log2(%"PRIu64") != " - "ilog2(%"PRIu64")", i, i); - } - } -#endif + ATF_REQUIRE(ilog2(0x0000000000000001ULL) == 0); + ATF_REQUIRE(ilog2(0x0000000000000002ULL) == 1); + ATF_REQUIRE(ilog2(0x0000000000000004ULL) == 2); + ATF_REQUIRE(ilog2(0x0000000000000008ULL) == 3); + ATF_REQUIRE(ilog2(0x0000000000000010ULL) == 4); + ATF_REQUIRE(ilog2(0x0000000000000020ULL) == 5); + ATF_REQUIRE(ilog2(0x0000000000000040ULL) == 6); + ATF_REQUIRE(ilog2(0x0000000000000080ULL) == 7); + ATF_REQUIRE(ilog2(0x0000000000000100ULL) == 8); + ATF_REQUIRE(ilog2(0x0000000000000200ULL) == 9); + ATF_REQUIRE(ilog2(0x0000000000000400ULL) == 10); + ATF_REQUIRE(ilog2(0x0000000000000800ULL) == 11); + ATF_REQUIRE(ilog2(0x0000000000001000ULL) == 12); + ATF_REQUIRE(ilog2(0x0000000000002000ULL) == 13); + ATF_REQUIRE(ilog2(0x0000000000004000ULL) == 14); + ATF_REQUIRE(ilog2(0x0000000000008000ULL) == 15); + ATF_REQUIRE(ilog2(0x0000000000010000ULL) == 16); + ATF_REQUIRE(ilog2(0x0000000000020000ULL) == 17); + ATF_REQUIRE(ilog2(0x0000000000040000ULL) == 18); + ATF_REQUIRE(ilog2(0x0000000000080000ULL) == 19); + ATF_REQUIRE(ilog2(0x0000000000100000ULL) == 20); + ATF_REQUIRE(ilog2(0x0000000000200000ULL) == 21); + ATF_REQUIRE(ilog2(0x0000000000400000ULL) == 22); + ATF_REQUIRE(ilog2(0x0000000000800000ULL) == 23); + ATF_REQUIRE(ilog2(0x0000000001000000ULL) == 24); + ATF_REQUIRE(ilog2(0x0000000002000000ULL) == 25); + ATF_REQUIRE(ilog2(0x0000000004000000ULL) == 26); + ATF_REQUIRE(ilog2(0x0000000008000000ULL) == 27); + ATF_REQUIRE(ilog2(0x0000000010000000ULL) == 28); + ATF_REQUIRE(ilog2(0x0000000020000000ULL) == 29); + ATF_REQUIRE(ilog2(0x0000000040000000ULL) == 30); + ATF_REQUIRE(ilog2(0x0000000080000000ULL) == 31); + ATF_REQUIRE(ilog2(0x0000000100000000ULL) == 32); + ATF_REQUIRE(ilog2(0x0000000200000000ULL) == 33); + ATF_REQUIRE(ilog2(0x0000000400000000ULL) == 34); + ATF_REQUIRE(ilog2(0x0000000800000000ULL) == 35); + ATF_REQUIRE(ilog2(0x0000001000000000ULL) == 36); + ATF_REQUIRE(ilog2(0x0000002000000000ULL) == 37); + ATF_REQUIRE(ilog2(0x0000004000000000ULL) == 38); + ATF_REQUIRE(ilog2(0x0000008000000000ULL) == 39); + ATF_REQUIRE(ilog2(0x0000010000000000ULL) == 40); + ATF_REQUIRE(ilog2(0x0000020000000000ULL) == 41); + ATF_REQUIRE(ilog2(0x0000040000000000ULL) == 42); + ATF_REQUIRE(ilog2(0x0000080000000000ULL) == 43); + ATF_REQUIRE(ilog2(0x0000100000000000ULL) == 44); + ATF_REQUIRE(ilog2(0x0000200000000000ULL) == 45); + ATF_REQUIRE(ilog2(0x0000400000000000ULL) == 46); + ATF_REQUIRE(ilog2(0x0000800000000000ULL) == 47); + ATF_REQUIRE(ilog2(0x0001000000000000ULL) == 48); + ATF_REQUIRE(ilog2(0x0002000000000000ULL) == 49); + ATF_REQUIRE(ilog2(0x0004000000000000ULL) == 50); + ATF_REQUIRE(ilog2(0x0008000000000000ULL) == 51); + ATF_REQUIRE(ilog2(0x0010000000000000ULL) == 52); + ATF_REQUIRE(ilog2(0x0020000000000000ULL) == 53); + ATF_REQUIRE(ilog2(0x0040000000000000ULL) == 54); + ATF_REQUIRE(ilog2(0x0080000000000000ULL) == 55); + ATF_REQUIRE(ilog2(0x0100000000000000ULL) == 56); + ATF_REQUIRE(ilog2(0x0200000000000000ULL) == 57); + ATF_REQUIRE(ilog2(0x0400000000000000ULL) == 58); + ATF_REQUIRE(ilog2(0x0800000000000000ULL) == 59); + ATF_REQUIRE(ilog2(0x1000000000000000ULL) == 60); + ATF_REQUIRE(ilog2(0x2000000000000000ULL) == 61); + ATF_REQUIRE(ilog2(0x4000000000000000ULL) == 62); + ATF_REQUIRE(ilog2(0x8000000000000000ULL) == 63); + + ATF_REQUIRE(ilog2(0x0000000000000003ULL) == 1); + ATF_REQUIRE(ilog2(0x0000000000000007ULL) == 2); + ATF_REQUIRE(ilog2(0x000000000000000fULL) == 3); + ATF_REQUIRE(ilog2(0x000000000000001fULL) == 4); + ATF_REQUIRE(ilog2(0x000000000000003fULL) == 5); + ATF_REQUIRE(ilog2(0x000000000000007fULL) == 6); + ATF_REQUIRE(ilog2(0x00000000000000ffULL) == 7); + ATF_REQUIRE(ilog2(0x00000000000001ffULL) == 8); + ATF_REQUIRE(ilog2(0x00000000000003ffULL) == 9); + ATF_REQUIRE(ilog2(0x00000000000007ffULL) == 10); + ATF_REQUIRE(ilog2(0x0000000000000fffULL) == 11); + ATF_REQUIRE(ilog2(0x0000000000001fffULL) == 12); + ATF_REQUIRE(ilog2(0x0000000000003fffULL) == 13); + ATF_REQUIRE(ilog2(0x0000000000007fffULL) == 14); + ATF_REQUIRE(ilog2(0x000000000000ffffULL) == 15); + ATF_REQUIRE(ilog2(0x000000000001ffffULL) == 16); + ATF_REQUIRE(ilog2(0x000000000003ffffULL) == 17); + ATF_REQUIRE(ilog2(0x000000000007ffffULL) == 18); + ATF_REQUIRE(ilog2(0x00000000000fffffULL) == 19); + ATF_REQUIRE(ilog2(0x00000000001fffffULL) == 20); + ATF_REQUIRE(ilog2(0x00000000003fffffULL) == 21); + ATF_REQUIRE(ilog2(0x00000000007fffffULL) == 22); + ATF_REQUIRE(ilog2(0x0000000000ffffffULL) == 23); + ATF_REQUIRE(ilog2(0x0000000001ffffffULL) == 24); + ATF_REQUIRE(ilog2(0x0000000003ffffffULL) == 25); + ATF_REQUIRE(ilog2(0x0000000007ffffffULL) == 26); + ATF_REQUIRE(ilog2(0x000000000fffffffULL) == 27); + ATF_REQUIRE(ilog2(0x000000001fffffffULL) == 28); + ATF_REQUIRE(ilog2(0x000000003fffffffULL) == 29); + ATF_REQUIRE(ilog2(0x000000007fffffffULL) == 30); + ATF_REQUIRE(ilog2(0x00000000ffffffffULL) == 31); + ATF_REQUIRE(ilog2(0x00000001ffffffffULL) == 32); + ATF_REQUIRE(ilog2(0x00000003ffffffffULL) == 33); + ATF_REQUIRE(ilog2(0x00000007ffffffffULL) == 34); + ATF_REQUIRE(ilog2(0x0000000fffffffffULL) == 35); + ATF_REQUIRE(ilog2(0x0000001fffffffffULL) == 36); + ATF_REQUIRE(ilog2(0x0000003fffffffffULL) == 37); + ATF_REQUIRE(ilog2(0x0000007fffffffffULL) == 38); + ATF_REQUIRE(ilog2(0x000000ffffffffffULL) == 39); + ATF_REQUIRE(ilog2(0x000001ffffffffffULL) == 40); + ATF_REQUIRE(ilog2(0x000003ffffffffffULL) == 41); + ATF_REQUIRE(ilog2(0x000007ffffffffffULL) == 42); + ATF_REQUIRE(ilog2(0x00000fffffffffffULL) == 43); + ATF_REQUIRE(ilog2(0x00001fffffffffffULL) == 44); + ATF_REQUIRE(ilog2(0x00003fffffffffffULL) == 45); + ATF_REQUIRE(ilog2(0x00007fffffffffffULL) == 46); + ATF_REQUIRE(ilog2(0x0000ffffffffffffULL) == 47); + ATF_REQUIRE(ilog2(0x0001ffffffffffffULL) == 48); + ATF_REQUIRE(ilog2(0x0003ffffffffffffULL) == 49); + ATF_REQUIRE(ilog2(0x0007ffffffffffffULL) == 50); + ATF_REQUIRE(ilog2(0x000fffffffffffffULL) == 51); + ATF_REQUIRE(ilog2(0x001fffffffffffffULL) == 52); + ATF_REQUIRE(ilog2(0x003fffffffffffffULL) == 53); + ATF_REQUIRE(ilog2(0x007fffffffffffffULL) == 54); + ATF_REQUIRE(ilog2(0x00ffffffffffffffULL) == 55); + ATF_REQUIRE(ilog2(0x01ffffffffffffffULL) == 56); + ATF_REQUIRE(ilog2(0x03ffffffffffffffULL) == 57); + ATF_REQUIRE(ilog2(0x07ffffffffffffffULL) == 58); + ATF_REQUIRE(ilog2(0x0fffffffffffffffULL) == 59); + ATF_REQUIRE(ilog2(0x1fffffffffffffffULL) == 60); + ATF_REQUIRE(ilog2(0x3fffffffffffffffULL) == 61); + ATF_REQUIRE(ilog2(0x7fffffffffffffffULL) == 62); + ATF_REQUIRE(ilog2(0xffffffffffffffffULL) == 63); } ATF_TP_ADD_TCS(tp) { - ATF_TP_ADD_TC(tp, bitmap_basic); + ATF_TP_ADD_TC(tp, bitmap_basic); ATF_TP_ADD_TC(tp, fast_divide32); ATF_TP_ADD_TC(tp, ffsfls); - ATF_TP_ADD_TC(tp, ilog2_basic); - ATF_TP_ADD_TC(tp, ilog2_log2); + ATF_TP_ADD_TC(tp, ilog2_32bit); + ATF_TP_ADD_TC(tp, ilog2_64bit); + ATF_TP_ADD_TC(tp, ilog2_const); return atf_no_error(); } diff --git a/contrib/netbsd-tests/include/sys/t_cdefs.c b/contrib/netbsd-tests/include/sys/t_cdefs.c index a473009..14f5cf2 100644 --- a/contrib/netbsd-tests/include/sys/t_cdefs.c +++ b/contrib/netbsd-tests/include/sys/t_cdefs.c @@ -1,4 +1,4 @@ -/* $NetBSD: t_cdefs.c,v 1.3 2013/09/05 09:01:27 gsutre Exp $ */ +/* $NetBSD: t_cdefs.c,v 1.4 2016/03/16 07:21:36 mrg Exp $ */ /*- * Copyright (c) 2012 The NetBSD Foundation, Inc. @@ -32,7 +32,7 @@ #include <sys/cdefs.h> __COPYRIGHT("@(#) Copyright (c) 2008\ The NetBSD Foundation, inc. All rights reserved."); -__RCSID("$NetBSD: t_cdefs.c,v 1.3 2013/09/05 09:01:27 gsutre Exp $"); +__RCSID("$NetBSD: t_cdefs.c,v 1.4 2016/03/16 07:21:36 mrg Exp $"); #include <atf-c.h> #include <sys/types.h> @@ -180,34 +180,34 @@ ATF_TC_HEAD(stypefit, tc) ATF_TC_BODY(stypefit, tc) { -#define CHECK(a, b, c) ATF_REQUIRE(!__type_fit(a, b) == c) - - CHECK(signed char, -1, 0); - CHECK(signed char, 1, 0); - CHECK(signed char, 0x7f, 0); - CHECK(signed char, 0x80, 1); - CHECK(signed char, 0xff, 1); - CHECK(signed char, 0x1ff, 1); - - CHECK(signed short, -1, 0); - CHECK(signed short, 1, 0); - CHECK(signed short, 0x7fff, 0); - CHECK(signed short, 0x8000, 1); - CHECK(signed short, 0xffff, 1); - CHECK(signed short, 0x1ffff, 1); - - CHECK(signed int, -1, 0); - CHECK(signed int, 1, 0); - CHECK(signed int, 0x7fffffff, 0); - CHECK(signed int, 0x80000000, 1); - CHECK(signed int, 0xffffffff, 1); - CHECK(signed int, 0x1ffffffffLL, 1); - - CHECK(signed long long, -1, 0); - CHECK(signed long long, 1, 0); - CHECK(signed long long, 0x7fffffffffffffffLL, 0); - CHECK(signed long long, 0x8000000000000000LL, 1); - CHECK(signed long long, 0xffffffffffffffffLL, 1); +#define CHECK(a, b, c) ATF_REQUIRE(__type_fit(a, b) == c) + + CHECK(signed char, -1, 1); + CHECK(signed char, 1, 1); + CHECK(signed char, 0x7f, 1); + CHECK(signed char, 0x80, 0); + CHECK(signed char, 0xff, 0); + CHECK(signed char, 0x1ff, 0); + + CHECK(signed short, -1, 1); + CHECK(signed short, 1, 1); + CHECK(signed short, 0x7fff, 1); + CHECK(signed short, 0x8000, 0); + CHECK(signed short, 0xffff, 0); + CHECK(signed short, 0x1ffff, 0); + + CHECK(signed int, -1, 1); + CHECK(signed int, 1, 1); + CHECK(signed int, 0x7fffffff, 1); + CHECK(signed int, 0x80000000, 0); + CHECK(signed int, 0xffffffff, 0); + CHECK(signed int, 0x1ffffffffLL, 0); + + CHECK(signed long long, -1, 1); + CHECK(signed long long, 1, 1); + CHECK(signed long long, 0x7fffffffffffffffLL, 1); + CHECK(signed long long, 0x8000000000000000LL, 0); + CHECK(signed long long, 0xffffffffffffffffLL, 0); #undef CHECK } @@ -220,34 +220,34 @@ ATF_TC_HEAD(utypefit, tc) ATF_TC_BODY(utypefit, tc) { -#define CHECK(a, b, c) ATF_REQUIRE(!__type_fit(a, b) == c) - - CHECK(unsigned char, -1, 1); - CHECK(unsigned char, 1, 0); - CHECK(unsigned char, 0x7f, 0); - CHECK(unsigned char, 0x80, 0); - CHECK(unsigned char, 0xff, 0); - CHECK(unsigned char, 0x1ff, 1); - - CHECK(unsigned short, -1, 1); - CHECK(unsigned short, 1, 0); - CHECK(unsigned short, 0x7fff, 0); - CHECK(unsigned short, 0x8000, 0); - CHECK(unsigned short, 0xffff, 0); - CHECK(unsigned short, 0x1ffff, 1); - - CHECK(unsigned int, -1, 1); - CHECK(unsigned int, 1, 0); - CHECK(unsigned int, 0x7fffffff, 0); - CHECK(unsigned int, 0x80000000, 0); - CHECK(unsigned int, 0xffffffff, 0); - CHECK(unsigned int, 0x1ffffffffLL, 1); - - CHECK(unsigned long long, -1, 1); - CHECK(unsigned long long, 1, 0); - CHECK(unsigned long long, 0x7fffffffffffffffULL, 0); - CHECK(unsigned long long, 0x8000000000000000ULL, 0); - CHECK(unsigned long long, 0xffffffffffffffffULL, 0); +#define CHECK(a, b, c) ATF_REQUIRE(__type_fit(a, b) == c) + + CHECK(unsigned char, -1, 0); + CHECK(unsigned char, 1, 1); + CHECK(unsigned char, 0x7f, 1); + CHECK(unsigned char, 0x80, 1); + CHECK(unsigned char, 0xff, 1); + CHECK(unsigned char, 0x1ff, 0); + + CHECK(unsigned short, -1, 0); + CHECK(unsigned short, 1, 1); + CHECK(unsigned short, 0x7fff, 1); + CHECK(unsigned short, 0x8000, 1); + CHECK(unsigned short, 0xffff, 1); + CHECK(unsigned short, 0x1ffff, 0); + + CHECK(unsigned int, -1, 0); + CHECK(unsigned int, 1, 1); + CHECK(unsigned int, 0x7fffffff, 1); + CHECK(unsigned int, 0x80000000, 1); + CHECK(unsigned int, 0xffffffff, 1); + CHECK(unsigned int, 0x1ffffffffLL, 0); + + CHECK(unsigned long long, -1, 0); + CHECK(unsigned long long, 1, 1); + CHECK(unsigned long long, 0x7fffffffffffffffULL, 1); + CHECK(unsigned long long, 0x8000000000000000ULL, 1); + CHECK(unsigned long long, 0xffffffffffffffffULL, 1); #undef CHECK } diff --git a/contrib/netbsd-tests/include/sys/t_pslist.c b/contrib/netbsd-tests/include/sys/t_pslist.c new file mode 100644 index 0000000..f46ed57 --- /dev/null +++ b/contrib/netbsd-tests/include/sys/t_pslist.c @@ -0,0 +1,125 @@ +/* $NetBSD: t_pslist.c,v 1.1 2016/04/09 04:39:47 riastradh Exp $ */ + +/*- + * Copyright (c) 2016 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Taylor R. Campbell. + * + * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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/pslist.h> + +#include <atf-c.h> + +/* + * XXX This is a limited test to make sure the operations behave as + * described on a sequential machine. It does nothing to test the + * pserialize-safety of any operations. + */ + +ATF_TC(misc); +ATF_TC_HEAD(misc, tc) +{ + atf_tc_set_md_var(tc, "descr", "pserialize-safe list tests"); +} +ATF_TC_BODY(misc, tc) +{ + struct pslist_head h = PSLIST_INITIALIZER; + struct element { + unsigned i; + struct pslist_entry entry; + } elements[] = { + { .i = 0, .entry = PSLIST_ENTRY_INITIALIZER }, + { .i = 1 }, + { .i = 2 }, + { .i = 3 }, + { .i = 4 }, + { .i = 5 }, + { .i = 6 }, + { .i = 7 }, + }; + struct element *element; + unsigned i; + + /* Check PSLIST_INITIALIZER is destroyable. */ + PSLIST_DESTROY(&h); + PSLIST_INIT(&h); + + /* Check PSLIST_ENTRY_INITIALIZER is destroyable. */ + PSLIST_ENTRY_DESTROY(&elements[0], entry); + + for (i = 0; i < __arraycount(elements); i++) + PSLIST_ENTRY_INIT(&elements[i], entry); + + PSLIST_WRITER_INSERT_HEAD(&h, &elements[4], entry); + PSLIST_WRITER_INSERT_BEFORE(&elements[4], &elements[2], entry); + PSLIST_WRITER_INSERT_BEFORE(&elements[4], &elements[3], entry); + PSLIST_WRITER_INSERT_BEFORE(&elements[2], &elements[1], entry); + PSLIST_WRITER_INSERT_HEAD(&h, &elements[0], entry); + PSLIST_WRITER_INSERT_AFTER(&elements[4], &elements[5], entry); + PSLIST_WRITER_INSERT_AFTER(&elements[5], &elements[7], entry); + PSLIST_WRITER_INSERT_AFTER(&elements[5], &elements[6], entry); + + PSLIST_WRITER_REMOVE(&elements[0], entry); + ATF_CHECK(elements[0].entry.ple_next != NULL); + PSLIST_ENTRY_DESTROY(&elements[0], entry); + + PSLIST_WRITER_REMOVE(&elements[4], entry); + ATF_CHECK(elements[4].entry.ple_next != NULL); + PSLIST_ENTRY_DESTROY(&elements[4], entry); + + PSLIST_ENTRY_INIT(&elements[0], entry); + PSLIST_WRITER_INSERT_HEAD(&h, &elements[0], entry); + + PSLIST_ENTRY_INIT(&elements[4], entry); + PSLIST_WRITER_INSERT_AFTER(&elements[3], &elements[4], entry); + + i = 0; + PSLIST_WRITER_FOREACH(element, &h, struct element, entry) { + ATF_CHECK_EQ(i, element->i); + i++; + } + i = 0; + PSLIST_READER_FOREACH(element, &h, struct element, entry) { + ATF_CHECK_EQ(i, element->i); + i++; + } + + while ((element = PSLIST_WRITER_FIRST(&h, struct element, entry)) + != NULL) { + PSLIST_WRITER_REMOVE(element, entry); + PSLIST_ENTRY_DESTROY(element, entry); + } + + PSLIST_DESTROY(&h); +} + +ATF_TP_ADD_TCS(tp) +{ + + ATF_TP_ADD_TC(tp, misc); + + return atf_no_error(); +} diff --git a/contrib/netbsd-tests/include/sys/t_socket.c b/contrib/netbsd-tests/include/sys/t_socket.c index ad4d2e6..f60941c 100644 --- a/contrib/netbsd-tests/include/sys/t_socket.c +++ b/contrib/netbsd-tests/include/sys/t_socket.c @@ -1,4 +1,4 @@ -/* $NetBSD: t_socket.c,v 1.3 2013/10/19 17:45:00 christos Exp $ */ +/* $NetBSD: t_socket.c,v 1.4 2015/02/27 08:30:30 martin Exp $ */ #include <sys/types.h> #include <sys/mount.h> @@ -74,7 +74,7 @@ ATF_TC(cmsg_sendfd); ATF_TC_HEAD(cmsg_sendfd, tc) { atf_tc_set_md_var(tc, "descr", "Checks that fd passing works"); - atf_tc_set_md_var(tc, "timeout", "2"); + atf_tc_set_md_var(tc, "timeout", "10"); } ATF_TC_BODY(cmsg_sendfd, tc) diff --git a/contrib/netbsd-tests/include/t_paths.c b/contrib/netbsd-tests/include/t_paths.c index 653a70b..52a150e 100644 --- a/contrib/netbsd-tests/include/t_paths.c +++ b/contrib/netbsd-tests/include/t_paths.c @@ -1,4 +1,4 @@ -/* $NetBSD: t_paths.c,v 1.14 2014/11/04 00:20:19 justin Exp $ */ +/* $NetBSD: t_paths.c,v 1.16 2015/05/07 06:23:23 pgoyette Exp $ */ /*- * Copyright (c) 2011 The NetBSD Foundation, Inc. @@ -29,7 +29,7 @@ * POSSIBILITY OF SUCH DAMAGE. */ #include <sys/cdefs.h> -__RCSID("$NetBSD: t_paths.c,v 1.14 2014/11/04 00:20:19 justin Exp $"); +__RCSID("$NetBSD: t_paths.c,v 1.16 2015/05/07 06:23:23 pgoyette Exp $"); #include <sys/param.h> #include <sys/stat.h> @@ -47,6 +47,7 @@ __RCSID("$NetBSD: t_paths.c,v 1.14 2014/11/04 00:20:19 justin Exp $"); #define PATH_DIR __BIT(1) /* A directory */ #define PATH_FILE __BIT(2) /* A file */ #define PATH_ROOT __BIT(3) /* Access for root only */ +#define PATH_OPT __BIT(3) /* Optional, ENODEV if not supported */ static const struct { const char *path; @@ -82,7 +83,7 @@ static const struct { { _PATH_MIXER, PATH_DEV }, { _PATH_MIXER0, PATH_DEV }, { _PATH_NOLOGIN, PATH_FILE }, - { _PATH_POWER, PATH_DEV | PATH_ROOT }, + { _PATH_POWER, PATH_DEV | PATH_ROOT | PATH_OPT }, { _PATH_PRINTCAP, PATH_FILE }, { _PATH_PUD, PATH_DEV | PATH_ROOT }, { _PATH_PUFFS, PATH_DEV | PATH_ROOT }, @@ -92,12 +93,13 @@ static const struct { { _PATH_SKEYKEYS, PATH_FILE | PATH_ROOT }, { _PATH_SOUND, PATH_DEV }, { _PATH_SOUND0, PATH_DEV }, - { _PATH_SYSMON, PATH_DEV }, + { _PATH_SYSMON, PATH_DEV | PATH_OPT }, { _PATH_TTY, PATH_DEV }, { _PATH_UNIX, PATH_FILE | PATH_ROOT }, { _PATH_URANDOM, PATH_DEV }, { _PATH_VIDEO, PATH_DEV }, { _PATH_VIDEO0, PATH_DEV }, + { _PATH_WATCHDOG, PATH_DEV | PATH_OPT }, { _PATH_DEV, PATH_DIR }, { _PATH_DEV_PTS, PATH_DIR }, @@ -143,13 +145,22 @@ ATF_TC_BODY(paths, tc) switch (errno) { + case ENODEV: + if ((paths[i].flags & PATH_OPT) == 0) { + + atf_tc_fail("Required path %s does " + "not exist", paths[i].path); + } + break; + case EPERM: /* FALLTHROUGH */ case EACCES: /* FALLTHROUGH */ if ((paths[i].flags & PATH_ROOT) == 0) { - atf_tc_fail("UID %u failed to open %s", - (uint32_t)uid, paths[i].path); + atf_tc_fail("UID %u failed to open %s, " + "error %d", (uint32_t)uid, + paths[i].path, errno); } case EBUSY: /* FALLTHROUGH */ |
