bit-string 0.2.0

A compact owned bit string type with editing, matching, and bitwise operations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use super::Bits;
use crate::WORD_BITS;

#[test]
fn sets_selected_bit_to_true() {
    let cases = [
        0,
        1,
        WORD_BITS - 1,
        WORD_BITS,
        WORD_BITS + 1,
        WORD_BITS * 2 - 1,
    ];

    for index in cases {
        let mut bits = [0u64; 2];

        Bits::set_bit(&mut bits, index, true);

        let word = index / WORD_BITS;
        let offset = index % WORD_BITS;

        assert_eq!(bits[word], 1u64 << offset, "index={index}");
    }
}

#[test]
fn sets_selected_bit_to_false() {
    let cases = [
        0,
        1,
        WORD_BITS - 1,
        WORD_BITS,
        WORD_BITS + 1,
        WORD_BITS * 2 - 1,
    ];

    for index in cases {
        let mut bits = [u64::MAX; 2];

        Bits::set_bit(&mut bits, index, false);

        let word = index / WORD_BITS;
        let offset = index % WORD_BITS;

        assert_eq!(bits[word] & (1u64 << offset), 0, "index={index}");
    }
}

#[test]
fn preserves_unselected_bits_when_setting_true() {
    let mut bits = [0b1010u64, 0b0101u64];

    Bits::set_bit(&mut bits, 0, true);
    Bits::set_bit(&mut bits, WORD_BITS + 1, true);

    assert_eq!(bits[0], 0b1011);
    assert_eq!(bits[1], 0b0111);
}

#[test]
fn preserves_unselected_bits_when_setting_false() {
    let mut bits = [0b1111u64, 0b1111u64];

    Bits::set_bit(&mut bits, 1, false);
    Bits::set_bit(&mut bits, WORD_BITS + 2, false);

    assert_eq!(bits[0], 0b1101);
    assert_eq!(bits[1], 0b1011);
}

#[test]
fn setting_same_value_is_idempotent() {
    let mut bits = [0u64; 2];

    Bits::set_bit(&mut bits, WORD_BITS + 3, true);
    let once = bits;

    Bits::set_bit(&mut bits, WORD_BITS + 3, true);
    assert_eq!(bits, once);

    Bits::set_bit(&mut bits, WORD_BITS + 3, false);
    let cleared = bits;

    Bits::set_bit(&mut bits, WORD_BITS + 3, false);
    assert_eq!(bits, cleared);
}