mirx 0.44.0

MIRX binary image format — flat & chunk-based container for ahead-of-time UI assets
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

use super::*;

#[test]
fn native_and_unaligned_wire_maps_have_identical_access() {
    let regions = [
        Region::new(1, 1, 3, 4).unwrap(),
        Region::new(1, 1, 3, 4).unwrap(),
        Region::new(0, 0, 0, 0).unwrap(),
        Region::new(6, 8, 1, 1).unwrap(),
    ];
    let native = AtlasMap::new(7, 9, &regions).unwrap();
    let mut storage = [0x5a; 2 + 4 * ATLAS_REGION_LEN];
    for (record, region) in storage[1..].chunks_exact_mut(ATLAS_REGION_LEN).zip(regions) {
        record[0..4].copy_from_slice(&region.x().to_le_bytes());
        record[4..8].copy_from_slice(&region.y().to_le_bytes());
        record[8..12].copy_from_slice(&region.width().to_le_bytes());
        record[12..16].copy_from_slice(&region.height().to_le_bytes());
    }
    let wire_end = storage.len() - 1;
    let wire = AtlasMap::open(7, 9, &storage[1..wire_end]).unwrap();

    assert_eq!(storage[0], 0x5a);
    assert_eq!(storage[storage.len() - 1], 0x5a);
    for map in [native, wire] {
        assert_eq!((map.width(), map.height()), (7, 9));
        assert_eq!(map.len(), regions.len());
        assert_eq!(map.iter().collect::<alloc::vec::Vec<_>>(), regions);
        assert_eq!(map.get(regions.len()), None);
        assert_eq!(map.get(usize::MAX), None);
        let mut iter = map.iter();
        assert_eq!(iter.next(), Some(regions[0]));
        assert_eq!(iter.next_back(), Some(regions[3]));
        assert_eq!(iter.next(), Some(regions[1]));
        assert_eq!(iter.nth_back(0), Some(regions[2]));
        assert_eq!(iter.next(), None);
    }
}

#[test]
fn malformed_records_and_regions_are_rejected() {
    for size in 1..ATLAS_REGION_LEN {
        assert_eq!(
            AtlasMap::open(10, 10, &[0; ATLAS_REGION_LEN][..size]),
            Err(AtlasMapError::PartialRecord { byte_len: size })
        );
    }
    for region in [
        Region::new(7, 9, 0, 0).unwrap(),
        Region::new(7, 0, 0, 9).unwrap(),
        Region::new(0, 9, 7, 0).unwrap(),
    ] {
        assert_eq!(
            AtlasMap::new(10, 10, &[region]),
            Err(AtlasMapError::NonCanonicalEmpty { index: 0 })
        );
    }
    for region in [
        Region::new(9, 0, 2, 1).unwrap(),
        Region::new(0, 9, 1, 2).unwrap(),
    ] {
        assert_eq!(
            AtlasMap::new(10, 10, &[region]),
            Err(AtlasMapError::InvalidRegion {
                index: 0,
                error: RegionError::OutOfBounds,
            })
        );
    }
    for axis in [0, 4] {
        let mut bytes = [0; ATLAS_REGION_LEN];
        bytes[axis..axis + 4].copy_from_slice(&u32::MAX.to_le_bytes());
        bytes[8..12].copy_from_slice(&1_u32.to_le_bytes());
        bytes[12..16].copy_from_slice(&1_u32.to_le_bytes());
        assert_eq!(
            AtlasMap::open(u32::MAX, u32::MAX, &bytes),
            Err(AtlasMapError::InvalidRegion {
                index: 0,
                error: RegionError::CoordinateOverflow,
            })
        );
    }
}

#[test]
fn empty_map_retains_its_extent() {
    let map = AtlasMap::open(0, u32::MAX, &[]).unwrap();
    assert_eq!((map.width(), map.height()), (0, u32::MAX));
    assert!(map.is_empty());
}