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

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

use std::collections::BTreeMap;

use packable::{
    error::UnpackError,
    map::{UnpackMapError, UnpackOrderedMapError},
    PackableExt,
};

mod common;

#[test]
fn packable_btreemap() {
    assert_eq!(
        common::generic_test(&BTreeMap::from([(None, 1u32), (Some(0u32), 1), (Some(1u32), 2)]))
            .0
            .len(),
        core::mem::size_of::<u64>()
            + (core::mem::size_of::<u8>() + core::mem::size_of::<u32>())
            + 2 * (core::mem::size_of::<u8>() + 2 * core::mem::size_of::<u32>())
    );
}

#[test]
fn invalid_duplicate() {
    let bytes = [(1, 5), (2, 4), (3, 3), (3, 2), (4, 1)];
    let bytes = Vec::from_iter(
        bytes
            .len()
            .to_le_bytes()
            .into_iter()
            .chain(bytes.into_iter().flat_map(|(k, v)| [k, v])),
    );

    let prefixed = BTreeMap::<u8, u8>::unpack_bytes_verified(bytes, &());

    assert!(matches!(
        prefixed,
        Err(UnpackError::Packable(UnpackOrderedMapError::Map(
            UnpackMapError::DuplicateKey(3u8)
        ))),
    ));
}

#[test]
fn invalid_unordered() {
    let bytes = [(1, 4), (2, 3), (4, 1), (3, 2)];
    let bytes = Vec::from_iter(
        bytes
            .len()
            .to_le_bytes()
            .into_iter()
            .chain(bytes.into_iter().flat_map(|(k, v)| [k, v])),
    );

    let prefixed = BTreeMap::<u8, u8>::unpack_bytes_verified(bytes, &());

    assert!(matches!(
        prefixed,
        Err(UnpackError::Packable(UnpackOrderedMapError::Unordered)),
    ));
}