facet-reflect 0.43.2

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

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

use facet::Facet;
use facet_reflect::{Partial, ReflectError};
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();
    assert!(matches!(
        partial.build(),
        Err(ReflectError::UninitializedField { .. })
    ));
}

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

    let partial: Partial<'_> = Partial::alloc::<FooBar>().unwrap();
    assert!(matches!(
        partial.build(),
        Err(ReflectError::UninitializedValue { .. })
    ));

    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();
    assert!(matches!(
        partial.build(),
        Err(ReflectError::UninitializedEnumField { .. })
    ));
}

#[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(ReflectError::UninitializedValue { .. })),
        "Expected UninitializedValue error, got {res:?}"
    );
}

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

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

#[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().map(|_| ());
    assert!(
        matches!(res, Err(ReflectError::UninitializedValue { .. })),
        "Expected UninitializedValue error, got {res:?}"
    );
}