grub/grub-core/tests/shift_test.c

158 lines
3.6 KiB
C
Raw Normal View History

/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2015 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <grub/test.h>
#include <grub/dl.h>
#include <grub/misc.h>
GRUB_MOD_LICENSE ("GPLv3+");
static grub_uint64_t vectors[] = {
0xffffffffffffffffULL, 1, 2, 0, 0x0102030405060708ULL
};
/* We're testing shifts, don't replace access to this with a shift. */
static const grub_uint8_t bitmask[] =
{ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
typedef union {
grub_uint64_t v64;
grub_uint8_t v8[8];
} grub_raw_u64_t;
static int
get_bit64 (grub_uint64_t v, int b)
{
grub_raw_u64_t vr = { .v64 = v };
grub_uint8_t *p = vr.v8;
if (b >= 64)
return 0;
#ifdef GRUB_CPU_WORDS_BIGENDIAN
p += 7 - b / 8;
#else
p += b / 8;
#endif
return !!(*p & bitmask[b % 8]);
}
static grub_uint64_t
set_bit64 (grub_uint64_t v, int b)
{
grub_raw_u64_t vr = { .v64 = v };
grub_uint8_t *p = vr.v8;
if (b >= 64)
return v;
#ifdef GRUB_CPU_WORDS_BIGENDIAN
p += 7 - b / 8;
#else
p += b / 8;
#endif
*p |= bitmask[b % 8];
return vr.v64;
}
static grub_uint64_t
left_shift64 (grub_uint64_t v, int s)
{
grub_uint64_t r = 0;
int i;
for (i = 0; i + s < 64; i++)
if (get_bit64 (v, i))
r = set_bit64 (r, i + s);
return r;
}
static grub_uint64_t
right_shift64 (grub_uint64_t v, int s)
{
grub_uint64_t r = 0;
int i;
for (i = s; i < 64; i++)
if (get_bit64 (v, i))
r = set_bit64 (r, i - s);
return r;
}
static grub_uint64_t
arithmetic_right_shift64 (grub_uint64_t v, int s)
{
grub_uint64_t r = 0;
int i;
for (i = s; i < 64; i++)
if (get_bit64 (v, i))
r = set_bit64 (r, i - s);
if (get_bit64 (v, 63))
for (i -= s; i < 64; i++)
r = set_bit64 (r, i);
return r;
}
static void
test64 (grub_uint64_t v)
{
int i;
for (i = 0; i < 64; i++)
{
grub_test_assert ((v << i) == left_shift64 (v, i),
"lshift wrong: 0x%llx << %d: 0x%llx, 0x%llx",
(long long) v, i,
(long long) (v << i), (long long) left_shift64 (v, i));
grub_test_assert ((v >> i) == right_shift64 (v, i),
"rshift wrong: 0x%llx >> %d: 0x%llx, 0x%llx",
(long long) v, i,
(long long) (v >> i), (long long) right_shift64 (v, i));
grub_test_assert ((((grub_int64_t) v) >> i) == (grub_int64_t) arithmetic_right_shift64 (v, i),
"arithmetic rshift wrong: ((grub_int64_t) 0x%llx) >> %d: 0x%llx, 0x%llx",
(long long) v, i,
(long long) (((grub_int64_t) v) >> i), (long long) arithmetic_right_shift64 (v, i));
}
}
static void
test_all(grub_uint64_t a)
{
test64 (a);
}
static void
shift_test (void)
{
grub_uint64_t a = 404, b = 7;
grub_size_t i;
for (i = 0; i < ARRAY_SIZE (vectors); i++)
{
test_all (vectors[i]);
}
for (i = 0; i < 4000; i++)
{
a = 17 * a + 13 * b;
b = 23 * a + 29 * b;
if (b == 0)
b = 1;
if (a == 0)
a = 1;
test_all (a);
test_all (b);
}
}
/* Register example_test method as a functional test. */
GRUB_FUNCTIONAL_TEST (shift_test, shift_test);