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

// Copyright 2023 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::{BoxedSlicePrefix, UnpackPrefixError},
    PackableExt,
};

#[test]
fn boxed_slice_prefix_from_boxed_slice_invalid_error() {
    let boxed_slice = vec![0u8; 16].into_boxed_slice();
    let prefixed = BoxedSlicePrefix::<u8, BoundedU32<1, 8>>::try_from(boxed_slice);

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

#[test]
fn boxed_slice_prefix_from_boxed_slice_truncated_error() {
    let boxed_slice = vec![0u8; 257].into_boxed_slice();
    let prefixed = BoxedSlicePrefix::<u8, u8>::try_from(boxed_slice);

    assert!(prefixed.is_err());
}

macro_rules! impl_packable_test_for_boxed_slice_prefix {
    ($packable_boxed_slice_prefix:ident, $ty:ty) => {
        #[test]
        fn $packable_boxed_slice_prefix() {
            assert_eq!(
                common::generic_test(
                    &<BoxedSlicePrefix<Option<u32>, $ty>>::try_from(vec![Some(0u32), None].into_boxed_slice()).unwrap()
                )
                .0
                .len(),
                core::mem::size_of::<$ty>()
                    + (core::mem::size_of::<u8>() + core::mem::size_of::<u32>())
                    + core::mem::size_of::<u8>()
            );
        }
    };
}

macro_rules! impl_packable_test_for_bounded_boxed_slice_prefix {
    ($packable_boxed_slice_prefix:ident, $packable_boxed_slice_prefix_invalid_length:ident, $ty:ty, $bounded:ident, $err:ident, $min:expr, $max:expr) => {
        #[test]
        fn $packable_boxed_slice_prefix() {
            assert_eq!(
                common::generic_test(
                    &<BoxedSlicePrefix<Option<u32>, $bounded<$min, $max>>>::try_from(
                        vec![Some(0u32), None].into_boxed_slice()
                    )
                    .unwrap()
                )
                .0
                .len(),
                core::mem::size_of::<$ty>()
                    + (core::mem::size_of::<u8>() + core::mem::size_of::<u32>())
                    + core::mem::size_of::<u8>()
            );
        }

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

            let mut bytes = vec![0u8; LEN + 1].into_boxed_slice();
            bytes[0] = LEN as u8;

            let prefixed = BoxedSlicePrefix::<u8, $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_boxed_slice_prefix!(packable_boxed_slice_prefix_u8, u8);
impl_packable_test_for_boxed_slice_prefix!(packable_boxed_slice_prefix_u16, u16);
impl_packable_test_for_boxed_slice_prefix!(packable_boxed_slice_prefix_u32, u32);
impl_packable_test_for_boxed_slice_prefix!(packable_boxed_slice_prefix_u64, u64);

impl_packable_test_for_bounded_boxed_slice_prefix!(
    packable_boxed_slice_prefix_bounded_u8,
    packable_boxed_slice_prefix_invalid_length_bounded_u8,
    u8,
    BoundedU8,
    InvalidBoundedU8,
    1,
    64
);
impl_packable_test_for_bounded_boxed_slice_prefix!(
    packable_boxed_slice_prefix_bounded_u16,
    packable_boxed_slice_prefix_invalid_length_bounded_u16,
    u16,
    BoundedU16,
    InvalidBoundedU16,
    1,
    64
);
impl_packable_test_for_bounded_boxed_slice_prefix!(
    packable_boxed_slice_prefix_bounded_u32,
    packable_boxed_slice_prefix_invalid_length_bounded_u32,
    u32,
    BoundedU32,
    InvalidBoundedU32,
    1,
    64
);
impl_packable_test_for_bounded_boxed_slice_prefix!(
    packable_boxed_slice_prefix_bounded_u64,
    packable_boxed_slice_prefix_invalid_length_bounded_u64,
    u64,
    BoundedU64,
    InvalidBoundedU64,
    1,
    64
);