packable 0.11.0

A crate for packing and unpacking binary representations.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

// Copyright 2022 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

mod common;

use packable::{
    bounded::{
        BoundedU16, BoundedU32, BoundedU64, BoundedU8, InvalidBoundedU16, InvalidBoundedU32, InvalidBoundedU64,
        InvalidBoundedU8, TryIntoBoundedU32Error,
    },
    error::UnpackError,
    prefix::{StringPrefix, UnpackPrefixError},
    PackableExt,
};

#[test]
fn packable_string_prefix_from_string_invalid_error() {
    // This measures 16 bytes.
    let string = String::from("yellow submarine");
    let prefixed = StringPrefix::<BoundedU32<1, 8>>::try_from(string);

    assert!(matches!(prefixed, Err(TryIntoBoundedU32Error::Invalid(16))));
}

#[test]
fn packable_string_prefix_from_string_truncated_error() {
    // This measures 257 bytes.
    let string = String::from(
        "In the town where I was born lived a man who sailed to sea and he told us of his life in the land of submarines. So we sailed on to the sun til we found a sea of green and we lived beneath the waves in our yellow submarine. We all live in a yellow submarine",
    );
    let prefixed = StringPrefix::<u8>::try_from(string);

    assert!(prefixed.is_err());
}

macro_rules! impl_packable_test_for_string_prefix {
    ($packable_string_prefix:ident, $packable_string_prefix_invalid_length:ident, $ty:ty) => {
        #[test]
        fn $packable_string_prefix() {
            assert_eq!(
                common::generic_test(&<StringPrefix<$ty>>::try_from(String::from("yellow submarine")).unwrap())
                    .0
                    .len(),
                core::mem::size_of::<$ty>() + 16 * core::mem::size_of::<u8>()
            );
        }
    };
}

macro_rules! impl_packable_test_for_bounded_string_prefix {
    ($packable_string_prefix:ident, $packable_string_prefix_invalid_length:ident, $ty:ty, $bounded:ident, $err:ident, $min:expr, $max:expr) => {
        #[test]
        fn $packable_string_prefix() {
            assert_eq!(
                common::generic_test(
                    &<StringPrefix<$bounded<$min, $max>>>::try_from(String::from("yellow submarine")).unwrap()
                )
                .0
                .len(),
                core::mem::size_of::<$ty>() + 16 * core::mem::size_of::<u8>()
            );
        }

        #[test]
        fn $packable_string_prefix_invalid_length() {
            const LEN: usize = $max + 1;

            let mut bytes = vec![0; LEN + 1];
            bytes[0] = LEN as u8;

            let prefixed = StringPrefix::<$bounded<$min, $max>>::unpack_bytes_verified(bytes, &());

            const LEN_AS_TY: $ty = LEN as $ty;

            assert!(matches!(
                prefixed,
                Err(UnpackError::Packable(UnpackPrefixError::Prefix($err(LEN_AS_TY)))),
            ));
        }
    };
}

impl_packable_test_for_string_prefix!(packable_string_prefix_u8, packable_string_prefix_invalid_length_u8, u8);
impl_packable_test_for_string_prefix!(
    packable_string_prefix_u16,
    packable_string_prefix_invalid_length_u16,
    u16
);
impl_packable_test_for_string_prefix!(
    packable_string_prefix_u32,
    packable_string_prefix_invalid_length_u32,
    u32
);
impl_packable_test_for_string_prefix!(
    packable_string_prefix_u64,
    packable_string_prefix_invalid_length_u64,
    u64
);

impl_packable_test_for_bounded_string_prefix!(
    packable_string_prefix_bounded_u8,
    packable_string_prefix_invalid_length_bounded_u8,
    u8,
    BoundedU8,
    InvalidBoundedU8,
    1,
    64
);
impl_packable_test_for_bounded_string_prefix!(
    packable_string_prefix_bounded_u16,
    packable_string_prefix_invalid_length_bounded_u16,
    u16,
    BoundedU16,
    InvalidBoundedU16,
    1,
    64
);
impl_packable_test_for_bounded_string_prefix!(
    packable_string_prefix_bounded_u32,
    packable_string_prefix_invalid_length_bounded_u32,
    u32,
    BoundedU32,
    InvalidBoundedU32,
    1,
    64
);
impl_packable_test_for_bounded_string_prefix!(
    packable_string_prefix_bounded_u64,
    packable_string_prefix_invalid_length_bounded_u64,
    u64,
    BoundedU64,
    InvalidBoundedU64,
    1,
    64
);