efx-core 1.1.1

Core parser and AST for EFx proc-macro
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

use efx_core::attr::{parse_bool, parse_color_rgba, parse_enum, parse_f32, Rgba};

fn rgba(r: u8, g: u8, b: u8, a: u8) -> Rgba {
    Rgba { r, g, b, a }
}

#[test]
fn parse_bool_ok() {
    assert!(parse_bool("b", "true").unwrap());
    assert!(!parse_bool("b", "false").unwrap());
    // case-insensitive and with spaces
    assert!(parse_bool("b", "  TrUe ").unwrap());
}

#[test]
fn parse_bool_err() {
    let e = parse_bool("b", "yes").unwrap_err();
    assert!(e.contains("expects boolean"));
}

#[test]
fn parse_f32_ok() {
    assert!((parse_f32("n", "14").unwrap() - 14.0).abs() < f32::EPSILON);
    assert!((parse_f32("n", "3.5").unwrap() - 3.5).abs() < f32::EPSILON);
    assert!((parse_f32("n", "  0.125 ").unwrap() - 0.125).abs() < f32::EPSILON);
}

#[test]
fn parse_f32_err() {
    let e = parse_f32("n", "abc").unwrap_err();
    assert!(e.contains("expects number"));
}

#[test]
fn parse_enum_ok() {
    let opts = ["left", "center", "right"];
    assert_eq!(parse_enum("align", "left", &opts).unwrap(), 0);
    assert_eq!(parse_enum("align", "CENTER", &opts).unwrap(), 1);
    assert_eq!(parse_enum("align", "Right", &opts).unwrap(), 2);
}

#[test]
fn parse_enum_err() {
    let opts = ["left", "center", "right"];
    let e = parse_enum("align", "middle", &opts).unwrap_err();
    assert!(e.contains("invalid value"));
    assert!(e.contains("left|center|right"));
}

#[test]
fn parse_color_named_ok() {
    assert_eq!(
        parse_color_rgba("color", "red").unwrap(),
        rgba(255, 0, 0, 255)
    );
    assert_eq!(
        parse_color_rgba("color", "light_grey").unwrap(),
        rgba(192, 192, 192, 255)
    ); // алиасы
    assert_eq!(
        parse_color_rgba("color", "TRANSPARENT").unwrap(),
        rgba(0, 0, 0, 0)
    );
}

#[test]
fn parse_color_hex_ok() {
    assert_eq!(
        parse_color_rgba("color", "#112233").unwrap(),
        rgba(0x11, 0x22, 0x33, 0xFF)
    );
    assert_eq!(
        parse_color_rgba("color", "#AABBCCDD").unwrap(),
        rgba(0xAA, 0xBB, 0xCC, 0xDD)
    );
}

#[test]
fn parse_color_hex_err() {
    // Invalid length
    let e = parse_color_rgba("color", "#12345").unwrap_err();
    assert!(e.contains("expects color name"));

    // invalid characters
    let e = parse_color_rgba("color", "#GG0011").unwrap_err();
    assert!(e.contains("expects color name"));

    // without # - also an error
    let e = parse_color_rgba("color", "112233").unwrap_err();
    assert!(e.contains("expects color name"));
}