Merge remote-tracking branch 'origin/stable/10' into develdevel

author: Renato Botelho <renato@netgate.com> 2017-02-23 06:28:41 -0300
committer: Renato Botelho <renato@netgate.com> 2017-02-23 06:28:41 -0300
commit: 82ceeb2ea625cd9bff60f2863b9a0830f55b7905 (patch)
tree: 263ca9347bf664a4489743f9302e699ce14de1df /contrib/netbsd-tests/include
parent: 4a05f5440acda223e6a0ec5157bc32ecc0f09ff9 (diff)
parent: d20dd8b36e7a565be7bfbb22aade51c8ffd753e9 (diff)
download: FreeBSD-src-devel.zip
FreeBSD-src-devel.tar.gz
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 */
author	Renato Botelho <renato@netgate.com>	2017-02-23 06:28:41 -0300
committer	Renato Botelho <renato@netgate.com>	2017-02-23 06:28:41 -0300
commit	82ceeb2ea625cd9bff60f2863b9a0830f55b7905 (patch)
tree	263ca9347bf664a4489743f9302e699ce14de1df /contrib/netbsd-tests/include
parent	4a05f5440acda223e6a0ec5157bc32ecc0f09ff9 (diff)
parent	d20dd8b36e7a565be7bfbb22aade51c8ffd753e9 (diff)
download	FreeBSD-src-devel.zip FreeBSD-src-devel.tar.gz