lib/std/bits/tests.rad 3.2 KiB 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
}