conspire 0.7.7

The Rust interface to conspire.
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

use super::{Sizes, attribute, data_layout, dataspace, datatype, fill_value, filter_pipeline};
use crate::io::netcdf::format::{NC_INT, Storage};

const SIZES: Sizes = Sizes {
    offset: 8,
    length: 8,
};

#[test]
fn datatype_endianness() {
    let le = datatype(&[0x10, 0x08, 0, 0, 4, 0, 0, 0]);
    assert!(le.little_endian && le.class == 0 && le.size == 4);
    let be = datatype(&[0x10, 0x01, 0, 0, 4, 0, 0, 0]);
    assert!(!be.little_endian);
}

#[test]
fn dataspace_scalar_and_simple() {
    assert_eq!(dataspace(&[2, 0, 0, 0]), Vec::<u64>::new());
    let mut d = vec![2, 1, 0, 0];
    d.extend(7u64.to_le_bytes());
    assert_eq!(dataspace(&d), [7]);
}

#[test]
#[should_panic(expected = "unsupported dataspace version")]
fn dataspace_rejects_v1() {
    dataspace(&[1, 0, 0, 0]);
}

#[test]
#[should_panic(expected = "unsupported data layout message version")]
fn data_layout_rejects_old_version() {
    data_layout(&SIZES, &[2, 1, 0]);
}

#[test]
#[should_panic(expected = "unsupported data layout class")]
fn data_layout_rejects_compact_class() {
    data_layout(&SIZES, &[3, 0, 0, 0]);
}

#[test]
fn data_layout_unallocated_chunked_is_fill() {
    let mut d = vec![3, 2, 2];
    d.extend([0xFF; 8]);
    d.extend([4, 0, 0, 0, 8, 0, 0, 0]);
    assert!(matches!(data_layout(&SIZES, &d), super::RawLayout::Fill));
}

#[test]
fn fill_value_versions() {
    assert_eq!(
        fill_value(&[3, 0x2a, 4, 0, 0, 0, 9, 9, 9, 9]),
        Some(vec![9; 4])
    );
    assert_eq!(fill_value(&[3, 0x00, 0, 0, 0, 0]), None);
    assert_eq!(
        fill_value(&[2, 2, 2, 1, 4, 0, 0, 0, 7, 7, 7, 7]),
        Some(vec![7; 4])
    );
    assert_eq!(fill_value(&[2, 2, 2, 0]), None);
}

#[test]
#[should_panic(expected = "unsupported fill value message version")]
fn fill_value_rejects_unknown_version() {
    fill_value(&[9, 0]);
}

#[test]
#[should_panic(expected = "unsupported filter pipeline version")]
fn filter_pipeline_rejects_v1() {
    filter_pipeline(&[1, 1, 0, 0, 0, 0, 0, 0]);
}

#[test]
#[should_panic(expected = "unsupported HDF5 filter")]
fn filter_pipeline_rejects_unknown_filter() {
    filter_pipeline(&[2, 1, 99, 0, 0, 0, 0, 0]);
}

#[test]
#[should_panic(expected = "unsupported attribute message version")]
fn attribute_rejects_old_version() {
    attribute(&[1, 0, 0, 0, 0, 0, 0, 0]);
}

#[test]
fn parse_ignores_unknown_object_header_messages() {
    let mut b = b"OHDR".to_vec();
    b.extend([2, 0x00, 32]);
    b.extend([0x01, 12, 0, 0]);
    b.extend([2, 1, 0, 0]);
    b.extend(3u64.to_le_bytes());
    b.extend([0x03, 8, 0, 0]);
    b.extend([0x00, 0x00, 0, 0, 4, 0, 0, 0]);
    b.extend([0xFF, 0, 0, 0]);

    let mut dims = Vec::new();
    let mut vars = Vec::new();
    super::parse(&b, &SIZES, "u", 0, &mut dims, &mut vars);

    assert_eq!(vars.len(), 1);
    assert_eq!(vars[0].xtype, NC_INT);
    assert!(matches!(&vars[0].storage, Storage::Hdf5 { shape, .. } if *shape == [3]));
}