facet-reflect 0.46.5

Build and manipulate values of arbitrary Facet types at runtime while respecting invariants - safe runtime reflection
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

use std::{collections::HashMap, sync::Arc};

use facet::Facet;
use facet_reflect::{Partial, ReflectErrorKind};
use facet_testhelpers::test;

// The order of these tests mirrors the Def enum

#[test]
fn scalar_uninit() {
    test_uninit::<u32>();
}

#[test]
fn struct_uninit() {
    #[derive(Facet)]
    struct FooBar {
        foo: u32,
    }

    let partial: Partial<'_> = Partial::alloc::<FooBar>().unwrap();
    let result = partial.build();
    assert!(
        matches!(
            result,
            Err(ref err) if matches!(err.kind, ReflectErrorKind::UninitializedField { .. })
        ),
        "Expected UninitializedField, got {result:?}"
    );
}

#[test]
fn enum_uninit() {
    #[derive(Facet)]
    #[repr(u8)]
    #[allow(dead_code)]
    enum FooBar {
        Foo,
        Bar { x: u32 },
    }

    let partial: Partial<'_> = Partial::alloc::<FooBar>().unwrap();
    let result = partial.build();
    assert!(
        matches!(
            result,
            Err(ref err) if matches!(err.kind, ReflectErrorKind::UninitializedValue { .. })
        ),
        "Expected UninitializedValue, got {result:?}"
    );

    let mut partial: Partial<'_> = Partial::alloc::<FooBar>().unwrap();
    partial = partial.select_variant_named("Foo").unwrap();
    assert!(partial.build().map(|_| ()).is_ok());

    let mut partial: Partial<'_> = Partial::alloc::<FooBar>().unwrap();
    partial = partial.select_variant_named("Bar").unwrap();
    let result = partial.build();
    assert!(
        matches!(
            result,
            Err(ref err) if matches!(err.kind, ReflectErrorKind::UninitializedField { .. })
        ),
        "Expected UninitializedField, got {result:?}"
    );
}

#[test]
fn map_uninit() {
    test_uninit::<HashMap<String, String>>();
}

#[test]
fn list_uninit() {
    test_uninit::<Vec<u8>>();
}

#[test]
fn array_uninit() {
    let partial: Partial<'_> = Partial::alloc::<[f32; 8]>().unwrap();
    let res = partial.build();
    assert!(
        matches!(res, Err(ref err) if matches!(err.kind, ReflectErrorKind::UninitializedValue { .. })),
        "Expected UninitializedValue error, got {res:?}"
    );
}

#[test]
fn slice_uninit() {
    test_uninit::<&[f32]>();
}

#[test]
fn option_uninit_defaults_to_none() {
    // Option<T> has an implicit default of None, so it should succeed
    let partial: Partial<'_> = Partial::alloc::<Option<u32>>().unwrap();
    let hv = partial.build().expect("Option<T> should default to None");
    let value: Option<u32> = hv.materialize().unwrap();
    assert_eq!(value, None);
}

#[test]
fn smart_pointer_uninit() {
    test_uninit::<Arc<u8>>();
}

fn test_uninit<T: Facet<'static>>() {
    let partial: Partial<'_> = Partial::alloc::<T>().unwrap();
    let res = partial.build();
    assert!(
        matches!(res, Err(ref err) if matches!(err.kind, ReflectErrorKind::UninitializedValue { .. })),
        "Expected UninitializedValue error, got {res:?}"
    );
}