miniserde-enum 0.1.3

Derive macros for miniserde on 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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use miniserde::{json, Serialize};
use miniserde_enum::Serialize_enum;

#[test]
fn test_internal() {
    #[serde(tag = "type")]
    #[derive(Serialize_enum)]
    enum Internal {
        A,
        #[serde(rename = "renamedB")]
        B,
        C {
            x: i32,
        },
    }
    use Internal::*;
    let example = [A, B, C { x: 2 }];
    let actual = json::to_string(&example[..]);
    let expected = r#"[{"type":"A"},{"type":"renamedB"},{"type":"C","x":2}]"#;
    assert_eq!(actual, expected);
}

#[test]
fn test_external() {
    #[derive(Serialize_enum)]
    enum External {
        A(i32),
        #[serde(rename = "renamedB")]
        B(i32, String),
        C {
            x: i32,
        },
        D,
    }
    use External::*;
    let example = [A(21), B(42, "everything".to_string()), C { x: 2 }, D];
    let actual = json::to_string(&example[..]);
    let expected = r#"[{"A":21},{"renamedB":[42,"everything"]},{"C":{"x":2}},"D"]"#;
    assert_eq!(actual, expected);
}

#[test]
fn test_untagged() {
    #[serde(untagged)]
    #[derive(Serialize_enum)]
    enum Untagged {
        A(i32),
        #[serde(rename = "renamedB")]
        B(i32, String),
        C {
            x: i32,
        },
        D,
    }
    use Untagged::*;
    let example = [A(21), B(42, "everything".to_string()), C { x: 2 }, D];
    let actual = json::to_string(&example[..]);
    let expected = r#"[21,[42,"everything"],{"x":2},"D"]"#;
    assert_eq!(actual, expected);
}

#[test]
fn generic_named() {
    #[derive(Serialize_enum)]
    enum Gen<T: Serialize> {
        A { t: T },
        B,
    }
    use Gen::*;
    let example = [A { t: "abc" }, B];
    let actual = json::to_string(&example[..]);
    let expected = r#"[{"A":{"t":"abc"}},"B"]"#;
    assert_eq!(actual, expected);
}

#[test]
fn generic_unnamed() {
    #[derive(Serialize_enum)]
    enum Gen<T: Serialize> {
        A(T),
        B,
    }
    use Gen::*;
    let example = [A("abc"), B];
    let actual = json::to_string(&example[..]);
    let expected = r#"[{"A":"abc"},"B"]"#;
    assert_eq!(actual, expected);
}