ltk_ritobin 0.12.0

Ritobin text format parser and writer for League Toolkit
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

use ltk_hash::{HashAlgorithm, HashWidth};
use ltk_meta::PropertyKind as K;

use super::*;
use crate::rito;

#[test]
fn a_type_prints_its_ritobin_spelling() {
    let xxh3 = ScalarType::Hash(HashType::new(HashWidth::W8, HashAlgorithm::Xxh3));
    let cases = [
        (rito!(U32), "u32"),
        (rito!(Hash), "hash"),
        (rito!(Container[String]), "list[string]"),
        (rito!(UnorderedContainer[Embedded]), "list2[embed]"),
        (rito!(Optional[Vector3]), "option[vec3]"),
        (rito!(Map[Hash, Struct]), "map[hash,pointer]"),
        (RitoType::list(xxh3), "list[hash[u64,xxh3]]"),
        (RitoType::from_property_kind(K::Container), "list"),
    ];
    for (rito, text) in cases {
        assert_eq!(rito.to_string(), text);
    }
}

#[test]
fn a_map_with_one_usable_subtype_has_neither() {
    let bare = RitoType::from_property_kind(K::Map);
    assert_eq!(
        RitoType::from_parts(K::Map, [Some(K::Container), Some(K::U32)]),
        bare
    );
    assert_eq!(RitoType::from_parts(K::Map, [Some(K::U32), None]), bare);
    assert_eq!(bare.to_string(), "map");
}

#[test]
fn a_missing_subtype_matches_any_subtype() {
    let bare = RitoType::from_property_kind(K::Container);
    assert!(bare.equivalent_to(&rito!(Container[U32])));
    assert!(rito!(Container[U32]).equivalent_to(&bare));
    assert!(!rito!(Container[U32]).equivalent_to(&rito!(Container[U8])));
    assert!(!bare.equivalent_to(&RitoType::from_property_kind(K::UnorderedContainer)));
}

#[test]
fn hash_types_compare_in_full() {
    let xxh3 = ScalarType::Hash(HashType::new(HashWidth::W8, HashAlgorithm::Xxh3));
    assert!(!RitoType::from(xxh3).equivalent_to(&rito!(Hash)));
    assert!(RitoType::from(xxh3)
        .with_default_hash_types()
        .equivalent_to(&rito!(Hash)));
}

#[test]
fn a_type_from_parts_rejects_a_shape_ritobin_has_no_spelling_for() {
    use BadContainerType as C;
    use BadRitoType as R;
    let cases = [
        (
            (K::Container, [None, None]),
            R::BadScalarType(BadScalarType(K::Container)),
        ),
        (
            (K::U32, [Some(K::U8), None]),
            R::BadContainerType(C::NonContainerBase { got: K::U32 }),
        ),
        (
            (K::Container, [Some(K::Map), None]),
            R::BadContainerType(C::NonScalarSubtype {
                base: K::Container,
                got: K::Map,
            }),
        ),
        (
            (K::Optional, [Some(K::U8), Some(K::U8)]),
            R::BadContainerType(C::BadSubtypeCount {
                base: K::Optional,
                got: 2,
                expected: 1,
            }),
        ),
        (
            (K::Map, [Some(K::U32), None]),
            R::BadContainerType(C::BadSubtypeCount {
                base: K::Map,
                got: 1,
                expected: 2,
            }),
        ),
        (
            (K::Map, [Some(K::Embedded), Some(K::U32)]),
            R::BadContainerType(C::BadMapKey { got: K::Embedded }),
        ),
    ];
    for ((base, subtypes), error) in cases {
        assert_eq!(RitoType::try_from_parts(base, subtypes), Err(error));
    }
}

#[test]
fn a_type_from_parts_leaves_out_a_subtype_that_does_not_fit() {
    assert_eq!(
        RitoType::from_parts(K::Container, [Some(K::Map), None]),
        RitoType::from_property_kind(K::Container)
    );
    assert_eq!(
        RitoType::from_parts(K::U32, [Some(K::U8), None]),
        rito!(U32)
    );
}