ic-storage 0.69.0

Governed stable allocation and collections for Internet Computer applications
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

use super::*;

#[test]
fn byte_codec_borrows_and_preserves_every_encoding() {
    for value in u8::MIN..=u8::MAX {
        let bytes = value.to_bytes_checked().unwrap();
        assert!(matches!(bytes, Cow::Borrowed(_)));
        assert_eq!(bytes.as_ref(), &[value]);
        assert_eq!(u8::from_bytes(bytes).unwrap(), value);
        let owned = value.into_bytes_checked().unwrap();
        assert_eq!(owned, [value]);
        assert_eq!(u8::from_bytes(Cow::Owned(owned)).unwrap(), value);
    }
    for bytes in [&[][..], &[0, 1][..]] {
        assert_eq!(
            u8::from_bytes(Cow::Borrowed(bytes)),
            Err(CodecError::Invalid("integer width"))
        );
    }
}

#[test]
fn boolean_codec_borrows_and_rejects_non_boolean_bytes() {
    for (value, byte) in [(false, 0), (true, 1)] {
        let bytes = value.to_bytes_checked().unwrap();
        assert!(matches!(bytes, Cow::Borrowed(_)));
        assert_eq!(bytes.as_ref(), &[byte]);
        assert_eq!(bool::from_bytes(bytes).unwrap(), value);
        let owned = value.into_bytes_checked().unwrap();
        assert_eq!(owned, [byte]);
        assert_eq!(bool::from_bytes(Cow::Owned(owned)).unwrap(), value);
    }
    for byte in 2..=u8::MAX {
        assert!(bool::from_bytes(Cow::Borrowed(&[byte])).is_err());
    }
    for bytes in [&[][..], &[0, 1][..]] {
        assert!(bool::from_bytes(Cow::Borrowed(bytes)).is_err());
    }
}

#[test]
fn canonical_bounds_distinguish_empty_variable_and_exact_width_records() {
    for (bound, accepted) in [
        (Bound::Unbounded, [true, true, true, true]),
        (
            Bound::Bounded {
                max_size: 2,
                is_fixed_size: false,
            },
            [true, true, true, false],
        ),
        (
            Bound::Bounded {
                max_size: 2,
                is_fixed_size: true,
            },
            [false, false, true, false],
        ),
        (
            Bound::Bounded {
                max_size: 0,
                is_fixed_size: true,
            },
            [true, false, false, false],
        ),
    ] {
        for (len, accepted) in accepted.into_iter().enumerate() {
            assert_eq!(bound.check(&vec![0; len]).is_ok(), accepted);
        }
    }
}