indicio 0.16.0

Indicio provides a framework for emitting clues that may be used for debugging.
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

#![allow(clippy::excessive_precision)]
#![allow(clippy::approx_constant)]

use indicio::{Map, Value, value};

#[test]
fn value_bool() {
    assert_eq!(Value::Bool(true), value!(true));
    assert_eq!(Value::Bool(false), value!(false));
}

#[test]
fn value_i64() {
    assert_eq!(Value::I64(i64::MIN), value!(-9223372036854775808i64));
    assert_eq!(Value::I64(i64::MAX), value!(9223372036854775807i64));
}

#[test]
fn value_u64() {
    assert_eq!(Value::U64(u64::MAX), value!(18446744073709551615u64));
}

#[test]
fn value_f64() {
    assert_eq!(
        Value::F64(std::f64::consts::PI),
        value!(3.14159265358979323846264338327950288_f64)
    );
}

#[test]
fn value_string() {
    assert_eq!(Value::String("foo".to_string()), value!("foo"));
}

#[test]
fn value_array() {
    assert_eq!(Value::Array(vec![].into()), value!([]));
    assert_eq!(
        Value::Array(
            vec![
                Value::Bool(false),
                Value::Bool(true),
                Value::Array(
                    vec![
                        Value::String("hello".to_string()),
                        Value::String("world".to_string())
                    ]
                    .into()
                )
            ]
            .into()
        ),
        value!([false, true, ["hello", "world"]])
    );
}

#[test]
fn value_object() {
    assert_eq!(Value::Object(vec![].into_iter().collect()), value!({}));
    assert_eq!(
        Value::Object(
            vec![
                ("hello".to_string(), Value::String("world".to_string())),
                (
                    "consts".to_string(),
                    Value::Array(
                        vec![Value::F64(2.718281828459045), Value::F64(3.141592653589793)].into()
                    )
                ),
                (
                    "recursive".to_string(),
                    Value::Object(
                        vec![
                            ("hello".to_string(), Value::String("world".to_string())),
                            (
                                "consts".to_string(),
                                Value::Array(
                                    vec![
                                        Value::F64(2.718281828459045),
                                        Value::F64(3.141592653589793)
                                    ]
                                    .into()
                                )
                            ),
                        ]
                        .into_iter()
                        .collect()
                    )
                ),
            ]
            .into_iter()
            .collect()
        ),
        value!({
            hello: "world",
            consts: [
                2.71828182845904523536028747135266250_f64,
                3.14159265358979323846264338327950288_f64,
            ],
            recursive: {
                hello: "world",
                consts: [
                    2.71828182845904523536028747135266250_f64,
                    3.14159265358979323846264338327950288_f64,
                ],
            }
        })
    );
}

#[test]
fn map_lookup_returns_first_duplicate_key() {
    let mut map = Map::default();
    map.insert("key".to_string(), Value::I64(1));
    map.insert("key".to_string(), Value::I64(2));

    assert_eq!(2, map.len());
    assert!(!map.is_empty());
    assert_eq!(Some(&Value::I64(1)), map.get("key"));
    assert_eq!(
        vec![
            ("key".to_string(), Value::I64(1)),
            ("key".to_string(), Value::I64(2)),
        ],
        map.entries()
            .iter()
            .cloned()
            .map(indicio::MapEntry::into_pair)
            .collect::<Vec<_>>()
    );
}

#[test]
fn display_escapes_string_values_and_object_keys() {
    let mut map = Map::default();
    map.insert("a\n\"b".to_string(), Value::String("x\t\\\r".to_string()));

    assert_eq!(
        "{\"a\\n\\\"b\": \"x\\t\\\\\\r\"}",
        Value::Object(map).to_string()
    );
}

#[test]
fn value_accessors_report_kinds() {
    let value = value!({
        enabled: true,
        signed: -1i64,
        unsigned: 1u64,
        nested: ["value"],
    });

    assert_eq!(indicio::ValueKind::Object, value.kind());
    assert_eq!(Some(true), value.lookup("enabled").and_then(Value::as_bool));
    assert_eq!(Some(-1), value.lookup("signed").and_then(Value::as_i64));
    assert_eq!(Some(1), value.lookup("unsigned").and_then(Value::as_u64));
    assert_eq!(
        Some("value"),
        value
            .lookup_path(&["nested"])
            .and_then(Value::as_array)
            .and_then(|values| values.first())
            .and_then(Value::as_str)
    );
}