.githooks/
compiler/
kernel/
lib/
examples/
std/
arch/
bits/
tests.rad
3.2 KiB
char/
collections/
fs/
hash/
lang/
mem/
sys/
arch.rad
68 B
bits.rad
1.6 KiB
char.rad
1.5 KiB
collections.rad
39 B
fmt.rad
11.6 KiB
fs.rad
11.0 KiB
hash.rad
41 B
intrinsics.rad
467 B
io.rad
1.7 KiB
lang.rad
335 B
mem.rad
12.0 KiB
mem.ras
919 B
process.rad
6.2 KiB
std.manifest
4.9 KiB
std.rad
349 B
sys.rad
1.0 KiB
testing.rad
2.4 KiB
tests.rad
26.6 KiB
vec.rad
3.2 KiB
scripts/
seed/
sublime/
test/
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
lib/std/bits/tests.rad
raw
| 1 | //! Tests for fixed-width bit operations. |
| 2 | |
| 3 | use std::bits; |
| 4 | use std::mem; |
| 5 | use std::testing; |
| 6 | |
| 7 | /// Check both word widths against bit-by-bit counts and wide rotations. |
| 8 | @test fn operations() throws (testing::TestError) { |
| 9 | for i in 0 .. 130 { |
| 10 | let value: u64 = 1 as u64 << (i % 64) as u64 |
| 11 | if i < 64 |
| 12 | else ~(1 as u64 << (i % 64) as u64); |
| 13 | let x = value as u32; |
| 14 | let mut ones32: u32 = 0; |
| 15 | let mut ones64: u32 = 0; |
| 16 | let mut leading32: u32 = 32; |
| 17 | let mut leading64: u32 = 64; |
| 18 | let mut trailing32: u32 = 32; |
| 19 | let mut trailing64: u32 = 64; |
| 20 | let mut swap32: u32 = 0; |
| 21 | let mut swap64: u64 = 0; |
| 22 | for bit in 0 .. 64 { |
| 23 | if (value & (1 as u64 << bit as u64)) <> 0 { |
| 24 | set ones64 += 1; |
| 25 | set leading64 = 63 - bit; |
| 26 | if trailing64 == 64 { |
| 27 | set trailing64 = bit; |
| 28 | } |
| 29 | } |
| 30 | if bit < 32 and (x & (1 as u32 << bit)) <> 0 { |
| 31 | set ones32 += 1; |
| 32 | set leading32 = 31 - bit; |
| 33 | if trailing32 == 32 { |
| 34 | set trailing32 = bit; |
| 35 | } |
| 36 | } |
| 37 | } |
| 38 | for byte in 0 .. 8 { |
| 39 | set swap64 = (swap64 << 8) | ((value >> (byte * 8) as u64) & 0xff); |
| 40 | if byte < 4 { |
| 41 | set swap32 = (swap32 << 8) | ((x >> (byte * 8)) & 0xff); |
| 42 | } |
| 43 | } |
| 44 | assert bits::leadingZeros32(x) == leading32; |
| 45 | assert bits::leadingZeros64(value) == leading64; |
| 46 | assert bits::trailingZeros32(x) == trailing32; |
| 47 | assert bits::trailingZeros64(value) == trailing64; |
| 48 | assert bits::popCount32(x) == ones32; |
| 49 | assert bits::popCount64(value) == ones64; |
| 50 | assert bits::byteSwap16(x as u16) as u32 == (swap32 >> 16); |
| 51 | assert bits::byteSwap32(x) as u64 == swap32 as u64; |
| 52 | assert bits::byteSwap64(value) == swap64; |
| 53 | for count in 0 .. 130 { |
| 54 | let k32: u32 = count % 32; |
| 55 | let k64 = (count % 64) as u64; |
| 56 | let left32 = |
| 57 | ((x as u64 << k32 as u64) |
| 58 | | (x as u64 >> (32 - k32) as u64)) as u32; |
| 59 | let right32 = |
| 60 | ((x as u64 >> k32 as u64) |
| 61 | | (x as u64 << (32 - k32) as u64)) as u32; |
| 62 | let left64 = value if k64 == 0 else (value << k64) | (value >> (64 - k64)); |
| 63 | let right64 = value if k64 == 0 else (value >> k64) | (value << (64 - k64)); |
| 64 | assert bits::rotateLeft32(x, count) == left32; |
| 65 | assert bits::rotateRight32(x, count) == right32; |
| 66 | assert bits::rotateLeft64(value, count) == left64; |
| 67 | assert bits::rotateRight64(value, count) == right64; |
| 68 | } |
| 69 | assert bits::rotateLeft32(x, mem::U32_MAX) == bits::rotateRight32(x, 1); |
| 70 | assert bits::rotateLeft64(value, mem::U32_MAX) == bits::rotateRight64(value, 1); |
| 71 | } |
| 72 | assert bits::leadingZeros32(0) == 32; |
| 73 | assert bits::leadingZeros64(0) == 64; |
| 74 | assert bits::trailingZeros32(0) == 32; |
| 75 | assert bits::trailingZeros64(0) == 64; |
| 76 | assert bits::popCount32(0) == 0; |
| 77 | assert bits::popCount64(0) == 0; |
| 78 | assert bits::popCount32(mem::U32_MAX) == 32; |
| 79 | assert bits::popCount64(mem::U64_MAX) == 64; |
| 80 | } |