/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2025 Oxide Computer Company
 */

/*
 * Test various aspects of the libc stdbit(3HEAD) interfaces. This does not test
 * the generic interfaces so that way this can be built and run by compilers
 * that don't support C23 and we also want to explicitly test the various type
 * specific values.
 *
 * This test is built 32-bit and 64-bit. The width of a long varies between an
 * ILP32 and LP64 environment and therefore will end up getting back different
 * values. Hence the ifdefs.
 */

#include <stdbit.h>
#include <stdlib.h>
#include <stdio.h>
#include <err.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>

typedef enum {
	STDBIT_TEST_U8	 = 1 << 0,
	STDBIT_TEST_U16	 = 1 << 1,
	STDBIT_TEST_U32	 = 1 << 2,
	STDBIT_TEST_U64	 = 1 << 3
} stdbit_test_type_t;

#define	STDBIT_TEST_64P	(STDBIT_TEST_U64)
#define	STDBIT_TEST_32P	(STDBIT_TEST_U32  | STDBIT_TEST_64P)
#define	STDBIT_TEST_16P	(STDBIT_TEST_U16 | STDBIT_TEST_32P)
#define	STDBIT_TEST_ALL	(STDBIT_TEST_U8 | STDBIT_TEST_16P)

typedef struct {
	const char *so_name;
	unsigned int (*so_uc)(unsigned char);
	unsigned int (*so_us)(unsigned short);
	unsigned int (*so_ui)(unsigned int);
	unsigned int (*so_ul)(unsigned long);
	unsigned int (*so_ull)(unsigned long long);
	int32_t so_delta[3];
} stdbit_ops_t;

typedef struct {
	stdbit_test_type_t st_types;
	uint64_t st_val;
	uint64_t st_res;
} stdbit_test_t;

/*
 * Count Leading Zeros tests. As the integer increases in size, there are a
 * bunch of leading zeros added, hence the delta values in this entry.
 */
static const stdbit_ops_t stdbit_clz_ops = {
	.so_name = "Count Leading Zeros",
	.so_uc = stdc_leading_zeros_uc,
	.so_us = stdc_leading_zeros_us,
	.so_ui = stdc_leading_zeros_ui,
	.so_ul = stdc_leading_zeros_ul,
	.so_ull = stdc_leading_zeros_ull,
	.so_delta = { 8, 16, 32 }
};

static const stdbit_test_t stdbit_clz_tests[] = { {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = UINT8_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x42,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 1,
	.st_res = 7
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT16_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x7777,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x800,
	.st_res = 4
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x080,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x008,
	.st_res = 12
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT32_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x23000000,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x23000032,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x400000000,
	.st_res = 29
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT64_MAX,
	.st_res = 0
} };

/*
 * Unlike count leading zeros, when we take a value and hand it to a larger
 * function, it will always go to a value of zero. As a result, we don't test
 * many of this suite across everything.
 */
static const stdbit_ops_t stdbit_clo_ops = {
	.so_name = "Count Leading Ones",
	.so_uc = stdc_leading_ones_uc,
	.so_us = stdc_leading_ones_us,
	.so_ui = stdc_leading_ones_ui,
	.so_ul = stdc_leading_ones_ul,
	.so_ull = stdc_leading_ones_ull,
};


static const stdbit_test_t stdbit_clo_tests[] = { {
	.st_types = STDBIT_TEST_U8,
	.st_val = UINT8_MAX,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x42,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0xe0,
	.st_res = 3
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0xfc,
	.st_res = 6
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT8_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x142,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = UINT16_MAX,
	.st_res = 16
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = 0xc0ff,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = 0xf88f,
	.st_res = 5
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0x12345678,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = UINT32_MAX,
	.st_res = 32
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0x87654321,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0xff7ff7ff,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0xfffffeee,
	.st_res = 23
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = UINT64_MAX,
	.st_res = 64
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = 0x8000000000000000,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = 0xffffffff80000000,
	.st_res = 33
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = 0xffffffffffff9999,
	.st_res = 49
} };

/*
 * The results for zero is the only special case that occurs with this
 * particular case.
 */
static const stdbit_ops_t stdbit_ctz_ops = {
	.so_name = "Count Trailing Zeros",
	.so_uc = stdc_trailing_zeros_uc,
	.so_us = stdc_trailing_zeros_us,
	.so_ui = stdc_trailing_zeros_ui,
	.so_ul = stdc_trailing_zeros_ul,
	.so_ull = stdc_trailing_zeros_ull,
};

static const stdbit_test_t stdbit_ctz_tests[] = { {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = 0,
	.st_res = 16
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0,
	.st_res = 32
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = 0,
	.st_res = 64
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = UINT8_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x1,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x4,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x80,
	.st_res = 7
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0xff60,
	.st_res = 5
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x8ad0,
	.st_res = 4
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x2300,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x42000000,
	.st_res = 25
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x99887700,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT32_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0xaa00000000000000,
	.st_res = 57
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0xbadcaf0000000000,
	.st_res = 40
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT64_MAX,
	.st_res = 0
} };

/*
 * Count Trailing Ones Tests
 */
static const stdbit_ops_t stdbit_cto_ops = {
	.so_name = "Count Trailing Ones",
	.so_uc = stdc_trailing_ones_uc,
	.so_us = stdc_trailing_ones_us,
	.so_ui = stdc_trailing_ones_ui,
	.so_ul = stdc_trailing_ones_ul,
	.so_ull = stdc_trailing_ones_ull,
};

static const stdbit_test_t stdbit_cto_tests[] = { {
	.st_types = STDBIT_TEST_ALL,
	.st_val = UINT8_MAX,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 3,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x7e,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x7f,
	.st_res = 7
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT16_MAX,
	.st_res = 16
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x8765,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0xcdef,
	.st_res = 4
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x9fff,
	.st_res = 13
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT32_MAX,
	.st_res = 32
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x85ab91ff,
	.st_res = 9
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x7fffffff,
	.st_res = 31
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT64_MAX,
	.st_res = 64
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x1bffffffffffffff,
	.st_res = 58
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x9abe83cff6ff7ff8,
	.st_res = 0
} };

/*
 * See the manual. The C23 definition for "most-significant" bit is
 * counter-intuitive. Basically bit 0 is considered the most significant bit. So
 * for a uint8_t bit 0 is considered index 7 and bit 7 is index 0. The results
 * always have 1 added to them.
 */
static const stdbit_ops_t stdbit_flz_ops = {
	.so_name = "First Leading Zero",
	.so_uc = stdc_first_leading_zero_uc,
	.so_us = stdc_first_leading_zero_us,
	.so_ui = stdc_first_leading_zero_ui,
	.so_ul = stdc_first_leading_zero_ul,
	.so_ull = stdc_first_leading_zero_ull,
};

static const stdbit_test_t stdbit_flz_tests[] = { {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x3,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0xf0,
	.st_res = 5
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0xef,
	.st_res = 4
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0xc4,
	.st_res = 3
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = UINT8_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT8_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = UINT16_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = 0xfabc,
	.st_res = 6
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = 0xcbaf,
	.st_res = 3
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT16_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = UINT32_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0xff7ff623,
	.st_res = 9
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0xfffff623,
	.st_res = 21
}, {
.	st_types = STDBIT_TEST_U32,
	.st_val = 0xffffff95,
	.st_res = 26
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT32_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = UINT64_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = 0xfffffffffffffffe,
	.st_res = 64
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = 0xffff2b9542fffffe,
	.st_res = 17
} };

/*
 * See the note on the flz tests for the oddities with calculating this. Due to
 * the nature of how these are counted, the larger the number gets, the more the
 * first 1 increases in its "most-significant" value. However, we have to
 * special case 0 in our logic because it will stay consistent across all the
 * values.
 */
static const stdbit_ops_t stdbit_flo_ops = {
	.so_name = "First Leading One",
	.so_uc = stdc_first_leading_one_uc,
	.so_us = stdc_first_leading_one_us,
	.so_ui = stdc_first_leading_one_ui,
	.so_ul = stdc_first_leading_one_ul,
	.so_ull = stdc_first_leading_one_ull,
	.so_delta = { 8, 16, 32 }
};

static const stdbit_test_t stdbit_flo_tests[] = { {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = 0,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = 0,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x1,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0xf,
	.st_res = 5
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0xfe,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x7f,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = UINT8_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT16_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0xfeed,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x1aff,
	.st_res = 4
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x02b0,
	.st_res = 7
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT32_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x00001234,
	.st_res = 20
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x2bb22bb2,
	.st_res = 3
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x00420000,
	.st_res = 10
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT64_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x000000000c000000,
	.st_res = 37
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x000fedcba9abcdef,
	.st_res = 13
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x000001992aa3bb4c,
	.st_res = 24
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x0706050403020100,
	.st_res = 6
} };

/*
 * First Trailing Zero. This numbers indexes in the way that someone expects
 * where the bit 0 is least significant index zero, which returns a value of 1.
 * When there are no zeros this returns 0. There is no reliable increment
 * pattern here.
 */
static const stdbit_ops_t stdbit_ftz_ops = {
	.so_name = "First Trailing Zero",
	.so_uc = stdc_first_trailing_zero_uc,
	.so_us = stdc_first_trailing_zero_us,
	.so_ui = stdc_first_trailing_zero_ui,
	.so_ul = stdc_first_trailing_zero_ul,
	.so_ull = stdc_first_trailing_zero_ull,
};

static const stdbit_test_t stdbit_ftz_tests[] = { {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = UINT8_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0xfe,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0xef,
	.st_res = 5
}, {
	.st_types = STDBIT_TEST_U8,
	.st_val = 0x7f,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = UINT8_MAX,
	.st_res = 9
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = UINT16_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = 0xfffe,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = 0xefff,
	.st_res = 13
}, {
	.st_types = STDBIT_TEST_U16,
	.st_val = 0x07ff,
	.st_res = 12
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = UINT16_MAX,
	.st_res = 17
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = UINT32_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0xcaffffff,
	.st_res = 25
}, {
	.st_types = STDBIT_TEST_U32,
	.st_val = 0xcabfffff,
	.st_res = 23
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = UINT32_MAX,
	.st_res = 33
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = UINT64_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = 0xface2bface95a2ff,
	.st_res = 9
}, {
	.st_types = STDBIT_TEST_U64,
	.st_val = 0x7777777777777777,
	.st_res = 4
} };

/*
 * First Trailing One. This numbers indexes in the way that someone expects
 * where the bit 0 is least significant index zero, which returns a value of 1.
 * When there are no zeros this returns 0. This is classical ffs().
 */
static const stdbit_ops_t stdbit_fto_ops = {
	.so_name = "First Trailing One",
	.so_uc = stdc_first_trailing_one_uc,
	.so_us = stdc_first_trailing_one_us,
	.so_ui = stdc_first_trailing_one_ui,
	.so_ul = stdc_first_trailing_one_ul,
	.so_ull = stdc_first_trailing_one_ull,
};

static const stdbit_test_t stdbit_fto_tests[] = { {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = UINT8_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0xf7,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0xf8,
	.st_res = 4
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x6d,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0xd6,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x40,
	.st_res = 7
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT16_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0xf840,
	.st_res = 7
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x0a00,
	.st_res = 10
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x8000,
	.st_res = 16
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT32_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0xb0000000,
	.st_res = 29
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0xf9c00000,
	.st_res = 23
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0xfed81500,
	.st_res = 9
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT64_MAX,
	.st_res = 1
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0xfed80d0000000000,
	.st_res = 41
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0xff70000000000000,
	.st_res = 53
} };

/*
 * Count Zeros.
 */
static const stdbit_ops_t stdbit_cz_ops = {
	.so_name = "Count Zeros",
	.so_uc = stdc_count_zeros_uc,
	.so_us = stdc_count_zeros_us,
	.so_ui = stdc_count_zeros_ui,
	.so_ul = stdc_count_zeros_ul,
	.so_ull = stdc_count_zeros_ull,
	.so_delta = { 8, 16, 32 }
};

static const stdbit_test_t stdbit_cz_tests[] = { {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = UINT8_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x77,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x88,
	.st_res = 6
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x5,
	.st_res = 6
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x1f,
	.st_res = 3
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT16_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x1234,
	.st_res = 11
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x4321,
	.st_res = 11
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x2ba2,
	.st_res = 9
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT32_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0xdeadbeef,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x12345678,
	.st_res = 19
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT64_MAX,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0xabbabccbcddcdeed,
	.st_res = 22
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x1221244248848008,
	.st_res = 50
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0xfffffffeefffffff,
	.st_res = 2
} };

/*
 * Count Ones.
 */
static const stdbit_ops_t stdbit_co_ops = {
	.so_name = "Count Ones",
	.so_uc = stdc_count_ones_uc,
	.so_us = stdc_count_ones_us,
	.so_ui = stdc_count_ones_ui,
	.so_ul = stdc_count_ones_ul,
	.so_ull = stdc_count_ones_ull,
};

static const stdbit_test_t stdbit_co_tests[] = { {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = UINT8_MAX,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x77,
	.st_res = 6
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x88,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x5,
	.st_res = 2
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x1f,
	.st_res = 5
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT16_MAX,
	.st_res = 16
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x1234,
	.st_res = 5
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x4321,
	.st_res = 5
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x2ba2,
	.st_res = 7
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT32_MAX,
	.st_res = 32
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0xdeadbeef,
	.st_res = 24
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x12345678,
	.st_res = 13
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT64_MAX,
	.st_res = 64
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0xabbabccbcddcdeed,
	.st_res = 42
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x1221244248848008,
	.st_res = 14
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0xfffffffeefffffff,
	.st_res = 62
} };

/*
 * Bit width tests. These values should stay the same as we increase integer
 * sizes as values are only adding zeros.
 */
static const stdbit_ops_t stdbit_bw_ops = {
	.so_name = "Bit Width",
	.so_uc = stdc_bit_width_uc,
	.so_us = stdc_bit_width_us,
	.so_ui = stdc_bit_width_ui,
	.so_ul = stdc_bit_width_ul,
	.so_ull = stdc_bit_width_ull,
};

static const stdbit_test_t stdbit_bw_tests[] = { {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = 0
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = UINT8_MAX,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x80,
	.st_res = 8
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x08,
	.st_res = 4
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x17,
	.st_res = 5
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT16_MAX,
	.st_res = 16
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x7777,
	.st_res = 15
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x2bb2,
	.st_res = 14
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x0230,
	.st_res = 10
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT32_MAX,
	.st_res = 32
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0xfedc4000,
	.st_res = 32
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x0004cedf,
	.st_res = 19
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x001ee100,
	.st_res = 21
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x8000000000000000,
	.st_res = 64
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x00ff11ee22dd33cc,
	.st_res = 56
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT64_MAX,
	.st_res = 64
} };

static void
stdbit_print_pass(stdbit_test_type_t types, uint64_t val, const char *cat)
{
	bool first = true;
	(void) printf("TEST PASSED: %s (0x%" PRIx64 ") [", cat, val);
	if ((types & STDBIT_TEST_U8) != 0) {
		(void) printf("8");
		first = false;
	}

	if ((types & STDBIT_TEST_U16) != 0) {
		(void) printf("%s16", first ? "" : ",");
		first = false;
	}

	if ((types & STDBIT_TEST_U32) != 0) {
		(void) printf("%s32", first ? "" : ",");
		first = false;
	}

	if ((types & STDBIT_TEST_U64) != 0) {
		(void) printf("%s64", first ? "" : ",");
		first = false;
	}

	(void) printf("]\n");
}

static bool
stdbit_test_one(const stdbit_test_t *test, const stdbit_ops_t *ops)
{
	bool ret = true;
	uint64_t comp = test->st_res;

	VERIFY3U(test->st_types, !=, 0);
	if ((test->st_types & STDBIT_TEST_U8) != 0) {
		unsigned res = ops->so_uc(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: %s (0x%" PRIx64 ") 8-bit (uchar) "
			    "returned 0x%x, expected 0x%" PRIx64,
			    ops->so_name, test->st_val, res, comp);
			ret = false;
		}

		comp += ops->so_delta[0];
	}

	if ((test->st_types & STDBIT_TEST_U16) != 0) {
		unsigned res = ops->so_us(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: %s (0x%" PRIx64 ") 16-bit (ushort) "
			    "returned 0x%x, expected 0x%" PRIx64,
			    ops->so_name, test->st_val, res, comp);
			ret = false;
		}

		comp += ops->so_delta[1];
	}

	if ((test->st_types & STDBIT_TEST_U32) != 0) {
		unsigned res = ops->so_ui(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: %s (0x%" PRIx64 ") 32-bit (uint) "
			    "returned 0x%x, expected 0x%" PRIx64,
			    ops->so_name, test->st_val, res, comp);
			ret = false;
		}

#ifdef	_ILP32
		res = ops->so_ul(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: %s (0x%" PRIx64 ") 32-bit (ulong) "
			    "returned 0x%x, expected 0x%" PRIx64,
			    ops->so_name, test->st_val, res, comp);
			ret = false;
		}
#endif	/* _ILP32 */

		comp += ops->so_delta[2];
	}

	if ((test->st_types & STDBIT_TEST_U64) != 0) {
		unsigned res;
#ifdef	_LP64
		res = ops->so_ul(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: %s (0x%" PRIx64 ") 64-bit (ulong) "
			    "returned 0x%x, expected 0x%" PRIx64,
			    ops->so_name, test->st_val, res, comp);
			ret = false;
		}
#endif	/* _LP64 */

		res = ops->so_ull(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: %s (0x%" PRIx64 ") 64-bit (ulong "
			    "long) returned 0x%x, expected 0x%" PRIx64,
			    ops->so_name, test->st_val, res, comp);
			ret = false;
		}
	}

	if (ret) {
		stdbit_print_pass(test->st_types, test->st_val, ops->so_name);
	}

	return (ret);
}

/*
 * This is used for all the functions that can return unsigned.
 */
typedef struct {
	const stdbit_ops_t *sg_ops;
	const stdbit_test_t *sg_tests;
	size_t sg_ntests;
} stdbit_std_group_t;

static const stdbit_std_group_t stdbit_groups[] = {
	{ &stdbit_clz_ops, stdbit_clz_tests, ARRAY_SIZE(stdbit_clz_tests) },
	{ &stdbit_clo_ops, stdbit_clo_tests, ARRAY_SIZE(stdbit_clo_tests) },
	{ &stdbit_ctz_ops, stdbit_ctz_tests, ARRAY_SIZE(stdbit_ctz_tests) },
	{ &stdbit_cto_ops, stdbit_cto_tests, ARRAY_SIZE(stdbit_cto_tests) },
	{ &stdbit_flz_ops, stdbit_flz_tests, ARRAY_SIZE(stdbit_flz_tests) },
	{ &stdbit_flo_ops, stdbit_flo_tests, ARRAY_SIZE(stdbit_flo_tests) },
	{ &stdbit_ftz_ops, stdbit_ftz_tests, ARRAY_SIZE(stdbit_ftz_tests) },
	{ &stdbit_fto_ops, stdbit_fto_tests, ARRAY_SIZE(stdbit_fto_tests) },
	{ &stdbit_cz_ops, stdbit_cz_tests, ARRAY_SIZE(stdbit_cz_tests) },
	{ &stdbit_co_ops, stdbit_co_tests, ARRAY_SIZE(stdbit_co_tests) },
	{ &stdbit_bw_ops, stdbit_bw_tests, ARRAY_SIZE(stdbit_bw_tests) },
};

/*
 * Tests for is a single bit set. These should be the same regardless of integer
 * size.
 */
static const stdbit_test_t stdbit_1b_tests[] = { {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0,
	.st_res = false
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = UINT8_MAX,
	.st_res = false
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x40,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x23,
	.st_res = false
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x81,
	.st_res = false
}, {
	.st_types = STDBIT_TEST_ALL,
	.st_val = 0x08,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = UINT16_MAX,
	.st_res = false
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x0100,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x7777,
	.st_res = false
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x8000,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x0400,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x0020,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_16P,
	.st_val = 0x0001,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = UINT32_MAX,
	.st_res = false
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x00200000,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0xbaddcafe,
	.st_res = false
}, {
	.st_types = STDBIT_TEST_32P,
	.st_val = 0x80000000,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = UINT64_MAX,
	.st_res = false
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x8000000000000000,
	.st_res = true
}, {
	.st_types = STDBIT_TEST_64P,
	.st_val = 0x0010000000000000,
	.st_res = true
} };

/*
 * The single bit set tests require a slightly different runner because they
 * return a boolean.
 */
static bool
stdbit_1b_test_one(const stdbit_test_t *test)
{
	bool ret = true, comp;

	VERIFY(test->st_res == 0 || test->st_res == 1);
	comp = (bool)test->st_res;

	VERIFY3U(test->st_types, !=, 0);
	if ((test->st_types & STDBIT_TEST_U8) != 0) {
		bool res = stdc_has_single_bit_uc(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: Single-bit (0x%" PRIx64 ") 8-bit "
			    "(uchar) returned %s, expected %s", test->st_val,
			    res ? "true" : "false", comp ? "true" : "false");
			ret = false;
		}
	}

	if ((test->st_types & STDBIT_TEST_U16) != 0) {
		bool res = stdc_has_single_bit_us(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: Single-bit (0x%" PRIx64 ") 16-bit "
			    "(ushort) returned %s, expected %s", test->st_val,
			    res ? "true" : "false", comp ? "true" : "false");
			ret = false;
		}
	}

	if ((test->st_types & STDBIT_TEST_U32) != 0) {
		bool res = stdc_has_single_bit_ui(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: Single-bit (0x%" PRIx64 ") 32-bit "
			    "(uint) returned %s, expected %s", test->st_val,
			    res ? "true" : "false", comp ? "true" : "false");
			ret = false;
		}

#ifdef	_ILP32
		res = stdc_has_single_bit_ul(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: Single-bit (0x%" PRIx64 ") 32-bit "
			    "(ulong) returned %s, expected %s", test->st_val,
			    res ? "true" : "false", comp ? "true" : "false");
			ret = false;
		}
#endif	/* _ILP32 */
	}

	if ((test->st_types & STDBIT_TEST_U64) != 0) {
		bool res;
#ifdef	_LP64
		res = stdc_has_single_bit_ul(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: Single-bit (0x%" PRIx64 ") 64-bit "
			    "(ulong) returned %s, expected %s", test->st_val,
			    res ? "true" : "false", comp ? "true" : "false");
			ret = false;
		}
#endif	/* _LP64 */

		res = stdc_has_single_bit_ull(test->st_val);
		if (res != comp) {
			warnx("TEST FAILED: Single-bit (0x%" PRIx64 ") 64-bit "
			    "(ulong long) returned %s, expected %s",
			    test->st_val, res ? "true" : "false",
			    comp ? "true" : "false");
			ret = false;
		}
	}

	if (ret) {
		stdbit_print_pass(test->st_types, test->st_val, "Single-bit");
	}

	return (ret);
}

/*
 * We use a different test structure for the floor and ceiling tests and check
 * both at each stop.
 */
typedef struct {
	stdbit_test_type_t sfc_types;
	uint64_t sfc_val;
	uint64_t sfc_floor;
	uint64_t sfc_ceil;
} stdbit_fc_test_t;

/*
 * Bit floor and ceiling tests. Note, a bit ceiling test can fail and return 0
 * if the value would overlap the type it's in. In those cases we don't use all
 * tests. This happens when the most significant bit in a given integer is set.
 * It will work at the next size up. All others should always pass all tests.
 */
static const stdbit_fc_test_t stdbit_fc_tests[] = { {
	.sfc_types = STDBIT_TEST_ALL,
	.sfc_val = 0,
	.sfc_floor = 0,
	.sfc_ceil = 1
}, {
	.sfc_types = STDBIT_TEST_U8,
	.sfc_val = UINT8_MAX,
	.sfc_floor = 1ULL << 7,
	.sfc_ceil = 0
}, {
	.sfc_types = STDBIT_TEST_ALL,
	.sfc_val = 0x23,
	.sfc_floor = 1ULL << 5,
	.sfc_ceil = 1ULL << 6
}, {
	.sfc_types = STDBIT_TEST_ALL,
	.sfc_val = 0x06,
	.sfc_floor = 1ULL << 2,
	.sfc_ceil = 1ULL << 3
}, {
	.sfc_types = STDBIT_TEST_ALL,
	.sfc_val = 0x18,
	.sfc_floor = 1ULL << 4,
	.sfc_ceil = 1ULL << 5
}, {
	.sfc_types = STDBIT_TEST_U8,
	.sfc_val = 0x81,
	.sfc_floor = 1ULL << 7,
	.sfc_ceil = 0
}, {
	.sfc_types = STDBIT_TEST_16P,
	.sfc_val = UINT8_MAX,
	.sfc_floor = 1ULL << 7,
	.sfc_ceil = 1ULL << 8
}, {
	.sfc_types = STDBIT_TEST_16P,
	.sfc_val = 0x0ff7,
	.sfc_floor = 1ULL << 11,
	.sfc_ceil = 1ULL << 12
}, {
	.sfc_types = STDBIT_TEST_16P,
	.sfc_val = 0x20a4,
	.sfc_floor = 1ULL << 13,
	.sfc_ceil = 1ULL << 14
}, {
	.sfc_types = STDBIT_TEST_U16,
	.sfc_val = 0x8ab1,
	.sfc_floor = 1ULL << 15,
	.sfc_ceil = 0
}, {
	.sfc_types = STDBIT_TEST_U16,
	.sfc_val = UINT16_MAX,
	.sfc_floor = 1ULL << 15,
	.sfc_ceil = 0
}, {
	.sfc_types = STDBIT_TEST_32P,
	.sfc_val = UINT16_MAX,
	.sfc_floor = 1ULL << 15,
	.sfc_ceil = 1ULL << 16
}, {
	.sfc_types = STDBIT_TEST_32P,
	.sfc_val = 0x000271ab,
	.sfc_floor = 1ULL << 17,
	.sfc_ceil = 1ULL << 18
}, {
	.sfc_types = STDBIT_TEST_32P,
	.sfc_val = 0x01000009,
	.sfc_floor = 1ULL << 24,
	.sfc_ceil = 1ULL << 25
}, {
	.sfc_types = STDBIT_TEST_32P,
	.sfc_val = 0x02000000,
	.sfc_floor = 1ULL << 25,
	.sfc_ceil = 1ULL << 25
}, {
	.sfc_types = STDBIT_TEST_32P,
	.sfc_val = 0x1cabf917,
	.sfc_floor = 1ULL << 28,
	.sfc_ceil = 1ULL << 29
}, {
	.sfc_types = STDBIT_TEST_U32,
	.sfc_val = 0x800a9b03,
	.sfc_floor = 1ULL << 31,
	.sfc_ceil = 0
}, {
	.sfc_types = STDBIT_TEST_U32,
	.sfc_val = UINT32_MAX,
	.sfc_floor = 1ULL << 31,
	.sfc_ceil = 0
}, {
	.sfc_types = STDBIT_TEST_64P,
	.sfc_val = UINT32_MAX,
	.sfc_floor = 1ULL << 31,
	.sfc_ceil = 1ULL << 32
}, {
	.sfc_types = STDBIT_TEST_U64,
	.sfc_val = 0x0089a23b1389ba87,
	.sfc_floor = 1ULL << 55,
	.sfc_ceil = 1ULL << 56
}, {
	.sfc_types = STDBIT_TEST_U64,
	.sfc_val = 0x499aff6eb12e7777,
	.sfc_floor = 1ULL << 62,
	.sfc_ceil = 1ULL << 63
}, {
	.sfc_types = STDBIT_TEST_U64,
	.sfc_val = 0xc00123481980ab87,
	.sfc_floor = 1ULL << 63,
	.sfc_ceil = 0
}, {
	.sfc_types = STDBIT_TEST_U64,
	.sfc_val = UINT64_MAX,
	.sfc_floor = 1ULL << 63,
	.sfc_ceil = 0
} };

static bool
stdbit_fc_test_one(const stdbit_fc_test_t *test)
{
	bool ret = true;

	VERIFY3U(test->sfc_types, !=, 0);
	if ((test->sfc_types & STDBIT_TEST_U8) != 0) {
		uint64_t res = stdc_bit_floor_uc(test->sfc_val);
		if (res != test->sfc_floor) {
			warnx("TEST FAILED: Bit Floor (0x%" PRIx64 ") 8-bit "
			    "(uchar) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_floor);
			ret = false;
		}

		res = stdc_bit_ceil_uc(test->sfc_val);
		if (res != test->sfc_ceil) {
			warnx("TEST FAILED: Bit Ceiling (0x%" PRIx64 ") 8-bit "
			    "(uchar) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_ceil);
			ret = false;
		}
	}

	if ((test->sfc_types & STDBIT_TEST_U16) != 0) {
		uint64_t res = stdc_bit_floor_us(test->sfc_val);
		if (res != test->sfc_floor) {
			warnx("TEST FAILED: Bit Floor (0x%" PRIx64 ") 16-bit "
			    "(ushort) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_floor);
			ret = false;
		}

		res = stdc_bit_ceil_us(test->sfc_val);
		if (res != test->sfc_ceil) {
			warnx("TEST FAILED: Bit Ceiling (0x%" PRIx64 ") 16-bit "
			    "(ushort) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_ceil);
			ret = false;
		}
	}

	if ((test->sfc_types & STDBIT_TEST_U32) != 0) {
		uint64_t res = stdc_bit_floor_ui(test->sfc_val);
		if (res != test->sfc_floor) {
			warnx("TEST FAILED: Bit Floor (0x%" PRIx64 ") 32-bit "
			    "(uint) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_floor);
			ret = false;
		}

		res = stdc_bit_ceil_ui(test->sfc_val);
		if (res != test->sfc_ceil) {
			warnx("TEST FAILED: Bit Ceiling (0x%" PRIx64 ") 32-bit "
			    "(uint) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_ceil);
			ret = false;
		}

#ifdef	_ILP32
		res = stdc_bit_floor_ul(test->sfc_val);
		if (res != test->sfc_floor) {
			warnx("TEST FAILED: Bit Floor (0x%" PRIx64 ") 32-bit "
			    "(ulong) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_floor);
			ret = false;
		}

		res = stdc_bit_ceil_ul(test->sfc_val);
		if (res != test->sfc_ceil) {
			warnx("TEST FAILED: Bit Ceiling (0x%" PRIx64 ") 32-bit "
			    "(ulong) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_ceil);
			ret = false;
		}
#endif	/* _ILP32 */
	}

	if ((test->sfc_types & STDBIT_TEST_U64) != 0) {
		uint64_t res;

#ifdef	_LP64
		res = stdc_bit_floor_ul(test->sfc_val);
		if (res != test->sfc_floor) {
			warnx("TEST FAILED: Bit Floor (0x%" PRIx64 ") 64-bit "
			    "(ulong) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_floor);
			ret = false;
		}

		res = stdc_bit_ceil_ul(test->sfc_val);
		if (res != test->sfc_ceil) {
			warnx("TEST FAILED: Bit Ceiling (0x%" PRIx64 ") 64-bit "
			    "(ulong) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_ceil);
			ret = false;
		}
#endif	/* _LP64 */

		res = stdc_bit_floor_ull(test->sfc_val);
		if (res != test->sfc_floor) {
			warnx("TEST FAILED: Bit Floor (0x%" PRIx64 ") 64-bit "
			    "(ulong long) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_floor);
			ret = false;
		}

		res = stdc_bit_ceil_ull(test->sfc_val);
		if (res != test->sfc_ceil) {
			warnx("TEST FAILED: Bit Ceiling (0x%" PRIx64 ") 64-bit "
			    "(ulong long) returned 0x%" PRIx64 ", expected 0x%"
			    PRIx64, test->sfc_val, res, test->sfc_ceil);
			ret = false;
		}
	}

	if (ret) {
		stdbit_print_pass(test->sfc_types, test->sfc_val,
		    "Bit Floor/Ceiling");
	}

	return (ret);

}

int
main(void)
{
	int ret = EXIT_SUCCESS;

	for (size_t i = 0; i < ARRAY_SIZE(stdbit_groups); i++) {
		for (size_t t = 0; t < stdbit_groups[i].sg_ntests; t++) {
			if (!stdbit_test_one(&stdbit_groups[i].sg_tests[t],
			    stdbit_groups[i].sg_ops)) {
				ret = EXIT_FAILURE;
			}
		}
	}

	for (size_t i = 0; i < ARRAY_SIZE(stdbit_1b_tests); i++) {
		if (!stdbit_1b_test_one(&stdbit_1b_tests[i])) {
			ret = EXIT_FAILURE;
		}
	}

	for (size_t i = 0; i < ARRAY_SIZE(stdbit_fc_tests); i++) {
		if (!stdbit_fc_test_one(&stdbit_fc_tests[i])) {
			ret = EXIT_FAILURE;
		}
	}

	if (ret == EXIT_SUCCESS) {
		(void) printf("All tests passed successfully\n");
	}

	return (ret);
}