257 lines
8.1 KiB
C
257 lines
8.1 KiB
C
/* bits.c - bitops testing.
|
|
*
|
|
* Copyright (C) 2024 Bruno Raoult ("br")
|
|
* Licensed under the GNU General Public License v3.0 or later.
|
|
* Some rights reserved. See COPYING.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with this
|
|
* program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
|
|
*
|
|
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
|
|
*
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "br.h"
|
|
#include "bitops.h"
|
|
#include "cutest/CuTest.h"
|
|
|
|
static const struct test32_1 {
|
|
u32 t32; /* input */
|
|
int popc;
|
|
int ctz;
|
|
int clz;
|
|
int ffs;
|
|
int ffz;
|
|
int fls;
|
|
int ilog2;
|
|
} test32_1[] = {
|
|
{ 0x00000000, 0, 32, 32, 0, 1, 0, 0 }, /* C undefined for some values */
|
|
{ 0xffffffff, 32, 0, 0, 1, 0, 32, 31 },
|
|
{ 0x00000001, 1, 0, 31, 1, 2, 1, 0 },
|
|
{ 0x80000000, 1, 31, 0, 32, 1, 32, 31 },
|
|
{ 0x71800718, 10, 3, 1, 4, 1, 31, 30 },
|
|
{ 0x07eeeef7, 22, 0, 5, 1, 4, 27, 26 },
|
|
};
|
|
|
|
static const struct test64_1 {
|
|
u64 t64; /* input */
|
|
int popc;
|
|
int ctz;
|
|
int clz;
|
|
int ffs;
|
|
int ffz;
|
|
int fls;
|
|
int ilog2;
|
|
} test64_1[] = {
|
|
{ 0x0000000000000000, 0, 64, 64, 0, 1, 0, 0 }, /* undefined for some values */
|
|
{ 0xffffffffffffffff, 64, 0, 0, 1, 0, 64, 63 },
|
|
{ 0x0000000100000001, 2, 0, 31, 1, 2, 33, 32 },
|
|
{ 0x8000000000000000, 1, 63, 0, 64, 1, 64, 63 },
|
|
{ 0x7180071871800718, 20, 3, 1, 4, 1, 63, 62 },
|
|
{ 0x07eeeef707eeeef7, 44, 0, 5, 1, 4, 59, 58 },
|
|
};
|
|
|
|
static void cutest_popcount(CuTest *tc)
|
|
{
|
|
for (uint i = 0; i < ARRAY_SIZE(test32_1); ++i) {
|
|
int res = popcount32(test32_1[i].t32);
|
|
CuAssertIntEquals(tc, test32_1[i].popc, res);
|
|
}
|
|
for (uint i = 0; i < ARRAY_SIZE(test64_1); ++i) {
|
|
int res = popcount64(test64_1[i].t64);
|
|
CuAssertIntEquals(tc, test64_1[i].popc, res);
|
|
}
|
|
}
|
|
|
|
static void cutest_ctz(CuTest *tc)
|
|
{
|
|
for (uint i = 0; i < ARRAY_SIZE(test32_1); ++i) {
|
|
int res = ctz32(test32_1[i].t32);
|
|
CuAssertIntEquals(tc, test32_1[i].ctz, res);
|
|
}
|
|
for (uint i = 0; i < ARRAY_SIZE(test64_1); ++i) {
|
|
int res = ctz64(test64_1[i].t64);
|
|
//printf("t=%#llx r=%d e=%d\n", test64_1[i].t64, res, test64_1[i].ctz);
|
|
CuAssertIntEquals(tc, test64_1[i].ctz, res);
|
|
}
|
|
}
|
|
|
|
static void cutest_clz(CuTest *tc)
|
|
{
|
|
for (uint i = 0; i < ARRAY_SIZE(test32_1); ++i) {
|
|
int res = clz32(test32_1[i].t32);
|
|
//printf("clz t=%#x r=%d e=%d\n", test32_1[i].t32, res, test32_1[i].clz);
|
|
CuAssertIntEquals(tc, test32_1[i].clz, res);
|
|
}
|
|
for (uint i = 0; i < ARRAY_SIZE(test64_1); ++i) {
|
|
int res = clz64(test64_1[i].t64);
|
|
//printf("clz t=%#llx r=%d e=%d\n", test64_1[i].t64, res, test64_1[i].clz);
|
|
CuAssertIntEquals(tc, test64_1[i].clz, res);
|
|
}
|
|
}
|
|
|
|
static void cutest_ffs(CuTest *tc)
|
|
{
|
|
for (uint i = 0; i < ARRAY_SIZE(test32_1); ++i) {
|
|
int res = ffs32(test32_1[i].t32);
|
|
CuAssertIntEquals(tc, test32_1[i].ffs, res);
|
|
}
|
|
for (uint i = 0; i < ARRAY_SIZE(test64_1); ++i) {
|
|
int res = ffs64(test64_1[i].t64);
|
|
//printf("ffs64 t=%#llx r=%d e=%d\n", test64_1[i].t64, res, test64_1[i].ffs);
|
|
CuAssertIntEquals(tc, test64_1[i].ffs, res);
|
|
}
|
|
}
|
|
|
|
static void cutest_ffz(CuTest *tc)
|
|
{
|
|
for (uint i = 0; i < ARRAY_SIZE(test32_1); ++i) {
|
|
int res = ffz32(test32_1[i].t32);
|
|
//printf("ffz32 t=%#x r=%d e=%d\n", test32_1[i].t32, res, test32_1[i].ffz);
|
|
CuAssertIntEquals(tc, test32_1[i].ffz, res);
|
|
}
|
|
for (uint i = 0; i < ARRAY_SIZE(test64_1); ++i) {
|
|
int res = ffz64(test64_1[i].t64);
|
|
//printf("ffz64 t=%#llx r=%d e=%d\n", test64_1[i].t64, res, test64_1[i].ffz);
|
|
CuAssertIntEquals(tc, test64_1[i].ffz, res);
|
|
}
|
|
}
|
|
|
|
static void cutest_fls(CuTest *tc)
|
|
{
|
|
for (uint i = 0; i < ARRAY_SIZE(test32_1); ++i) {
|
|
int res = fls32(test32_1[i].t32);
|
|
//printf("fls32 t=%#x r=%d e=%d\n", test32_1[i].t32, res, test32_1[i].fls);
|
|
CuAssertIntEquals(tc, test32_1[i].fls, res);
|
|
}
|
|
for (uint i = 0; i < ARRAY_SIZE(test64_1); ++i) {
|
|
int res = fls64(test64_1[i].t64);
|
|
//printf("fls64 t=%#llx r=%d e=%d\n", test64_1[i].t64, res, test64_1[i].fls);
|
|
CuAssertIntEquals(tc, test64_1[i].fls, res);
|
|
}
|
|
}
|
|
|
|
static void cutest_ilog(CuTest *tc)
|
|
{
|
|
for (uint i = 0; i < ARRAY_SIZE(test32_1); ++i) {
|
|
if (!test32_1[i].t32) {
|
|
printf("ilog2_32 t=%#x skipped\n", test32_1[i].t32);
|
|
continue;
|
|
}
|
|
int res = ilog2_32(test32_1[i].t32);
|
|
printf("ilog2_32_n t=%#x r=%d e=%d\n", test32_1[i].t32,
|
|
res, test32_1[i].ilog2);
|
|
CuAssertIntEquals(tc, test32_1[i].ilog2, res);
|
|
}
|
|
for (uint i = 0; i < ARRAY_SIZE(test64_1); ++i) {
|
|
if (!test64_1[i].t64) {
|
|
printf("ilog2_32 t=%#llx skipped\n", test64_1[i].t64);
|
|
continue;
|
|
}
|
|
int res = ilog2_64(test64_1[i].t64);
|
|
printf("ilog2_64_n t=%#llx r=%d e=%d\n", test64_1[i].t64,
|
|
res, test64_1[i].ilog2);
|
|
CuAssertIntEquals(tc, test64_1[i].ilog2, res);
|
|
}
|
|
}
|
|
|
|
struct test32_2 {
|
|
u32 t32; /* input */
|
|
u32 arg;
|
|
u32 rol;
|
|
u32 ror;
|
|
} test32_2[] = {
|
|
{ 0x00000000, 0, 0, 0 },
|
|
{ 0x00000000, 1, 0, 0 },
|
|
{ 0x10000001, 2, 0x40000004, 0x44000000 },
|
|
{ 0x80000008, 3, 0x00000044, 0x10000001 },
|
|
{ 0x71800718, 8, 0x80071871, 0x18718007 },
|
|
{ 0x07eeeef7, 4, 0x7eeeef70, 0x707eeeef },
|
|
};
|
|
|
|
struct test64_2 {
|
|
u64 t64; /* input */
|
|
u32 arg;
|
|
u64 rol;
|
|
u64 ror;
|
|
} test64_2[] = {
|
|
{ 0x0000000000000000, 0, 0, 0 },
|
|
{ 0x0000000000000000, 1, 0, 0 },
|
|
{ 0x1000000110000001, 2, 0x4000000440000004, 0x4400000044000000 },
|
|
{ 0x8000000880000008, 3, 0x0000004400000044, 0x1000000110000001 },
|
|
{ 0x7180071871800718, 8, 0x8007187180071871, 0x1871800718718007 },
|
|
{ 0x07eeeef707eeeef7, 4, 0x7eeeef707eeeef70, 0x707eeeef707eeeef },
|
|
};
|
|
|
|
static void cutest_rol(CuTest *tc)
|
|
{
|
|
for (uint i = 0; i < ARRAY_SIZE(test32_2); ++i) {
|
|
u32 res = rol32(test32_2[i].t32, test32_2[i].arg);
|
|
//printf("rol32 t=%#x a=%u r=%#08x e=%#08x\n", test32_2[i].t32,
|
|
// test32_2[i].arg, res, test32_2[i].rol);
|
|
CuAssertU32Equals(tc, test32_2[i].rol, res);
|
|
}
|
|
for (uint i = 0; i < ARRAY_SIZE(test64_2); ++i) {
|
|
u64 res = rol64(test64_2[i].t64, test64_2[i].arg);
|
|
//printf("rol64 t=%#llx a=%u r=%#08llx e=%#08llx\n", test64_2[i].t64,
|
|
// test64_2[i].arg, res, test64_2[i].rol);
|
|
CuAssertU64Equals(tc, test64_2[i].rol, res);
|
|
}
|
|
}
|
|
|
|
static void cutest_ror(CuTest *tc)
|
|
{
|
|
for (uint i = 0; i < ARRAY_SIZE(test32_2); ++i) {
|
|
u32 res = ror32(test32_2[i].t32, test32_2[i].arg);
|
|
//printf("ror32 t=%#x a=%u r=%#08x e=%#08x\n", test32_2[i].t32,
|
|
// test32_2[i].arg, res, test32_2[i].ror);
|
|
CuAssertU32Equals(tc, test32_2[i].ror, res);
|
|
}
|
|
for (uint i = 0; i < ARRAY_SIZE(test64_2); ++i) {
|
|
u64 res = ror64(test64_2[i].t64, test64_2[i].arg);
|
|
//printf("ror64 t=%#0llx a=%u r=%#08llx e=%#08llx\n", test64_2[i].t64,
|
|
// test64_2[i].arg, res, test64_2[i].ror);
|
|
CuAssertU64Equals(tc, test64_2[i].ror, res);
|
|
}
|
|
}
|
|
|
|
#define MAXLOOPS 8
|
|
|
|
static CuSuite *bitops_GetSuite()
|
|
{
|
|
CuSuite* suite = CuSuiteNew();
|
|
SUITE_ADD_TEST(suite, cutest_popcount);
|
|
SUITE_ADD_TEST(suite, cutest_ctz);
|
|
SUITE_ADD_TEST(suite, cutest_clz);
|
|
SUITE_ADD_TEST(suite, cutest_ffs);
|
|
SUITE_ADD_TEST(suite, cutest_ffz);
|
|
SUITE_ADD_TEST(suite, cutest_fls);
|
|
SUITE_ADD_TEST(suite, cutest_ilog);
|
|
|
|
SUITE_ADD_TEST(suite, cutest_rol);
|
|
SUITE_ADD_TEST(suite, cutest_ror);
|
|
return suite;
|
|
}
|
|
|
|
static void RunAllTests(void)
|
|
{
|
|
CuString *output = CuStringNew();
|
|
CuSuite* suite = CuSuiteNew();
|
|
|
|
CuSuiteAddSuite(suite, bitops_GetSuite());
|
|
|
|
CuSuiteRun(suite);
|
|
CuSuiteSummary(suite, output);
|
|
CuSuiteDetails(suite, output);
|
|
printf("%s\n", output->buffer);
|
|
}
|
|
|
|
int main()
|
|
{
|
|
RunAllTests();
|
|
exit(0);
|
|
}
|