matched_enums_macro 1.3.0

Contains the macro for matchable enums.
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

extern crate alloc;

use alloc::collections::BTreeMap;
use alloc::string::{String, ToString};

use quote::quote;
use rstest::rstest;
use syn::ItemEnum;

use super::Variant;

#[rstest::fixture]
fn variants() -> BTreeMap<String, syn::Variant> {
    syn::parse2::<ItemEnum>(quote! {
        #[derive(Matched)]
        #[matched_enum(value_types=[i8, u16])]
        enum Foo {
            NoAttributes,

            #[matches = 0..1]
            NonListAttributeType,

            #[matches(true, i_hope_this_keyword_does_not_exist)]
            InvalidAttributeValue,

            #[matches(true)]
            #[matches(true)]
            MultipleDefaultMatchers,

            #[matches(true)]
            #[matches(true, bind=u16)]
            OneDefaultMatcherOneBoundMatcher,

            #[matches(true, bind=u16)]
            #[matches(true, bind=u16)]
            MultipleBoundMatchersOnOneType,

            #[matches(true, bind=isize)]
            MatcherBoundToUnsupportedType,
        }
    })
    .unwrap()
    .variants
    .iter()
    .map(|variant| (variant.ident.to_string(), variant.clone()))
    .collect()
}

#[rstest]
#[case("NoAttributes", true)]
#[case("NonListAttributeType", false)]
#[case("InvalidAttributeValue", false)]
#[case("MultipleDefaultMatchers", false)]
#[case("OneDefaultMatcherOneBoundMatcher", true)]
#[case("MultipleBoundMatchersOnOneType", false)]
#[case("MatcherBoundToUnsupportedType", true)]
fn test_attribute(
    variants: BTreeMap<String, syn::Variant>,
    #[case] name: &'static str,
    #[case] should_pass: bool,
) {
    let variant = variants.get(name).unwrap().clone();
    assert!(Variant::try_from(variant).is_ok() == should_pass);
}