ansiconst 0.2.1

Library for declaring nestable ANSI styles in const context
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

mod common;
use common::case::TestCase;

#[macro_export]
macro_rules! assert_eq_dbg {
    ($x:expr, $y:expr $(,)?     ) =>(assert_eq!(format!("{:?}", $x), format!("{:?}", $y)));
    ($x:expr, $y:expr, $($z:tt)+) =>(assert_eq!(format!("{:?}", $x), format!("{:?}", $y), $($z)*));
}

#[test]
fn test_one() {
    for test in TestCase::all() {
        assert_eq!(test.expect.is_empty(),      test.ansi.is_empty(),   "{:?}.is_empty()",   test.ansi);
        assert_eq!(test.expect.is_reset(),      test.ansi.is_reset(),   "{:?}.is_reset()",   test.ansi);
        assert_eq!(test.expect.is_no_ansi(),    test.ansi.is_no_ansi(), "{:?}.is_no_ansi()", test.ansi);
        assert_eq_dbg!(test.expect,             test.ansi);
        assert_eq_dbg!(test.expect.not(),       test.ansi.not());
        assert_eq_dbg!(test.expect.not().not(), test.ansi.not().not());
        assert_eq_dbg!(test.expect.important(), test.ansi.important());
    }
}

#[test]
fn test_combine() {
    // 1-attr + 1-attr
    for a in TestCase::all() {
        for b in TestCase::all() {
            check_all(a, b);
        }
    }

    // 2-attrs + 1-attr
    for a in TestCase::all() {
        for b in TestCase::all() {
            for c in TestCase::all() {
                check_all(a.add(c),       b);
                check_all(a.add(c),       b.not());
                check_all(a.not().add(c), b);
                check_all(a.not().add(c), b.not());
                check_all(a,              b.add(c));
                check_all(a.not(),        b.add(c));
                check_all(a,              b.not().add(c));
                check_all(a.not(),        b.not().add(c));
            }
        }
    }
}

fn check_all(a: TestCase, b: TestCase) {
    check_operations(a, b);
    check_operations(a, b.not());
    check_operations(a.not(), b);
    check_operations(a.not(), b.not());
}

fn check_operations(a: TestCase, b: TestCase) {
    check_add (a, b);
    check_then(a, b);
    check_transition(a, b);
}

fn check_add(a: TestCase, b: TestCase) {
    assert_eq_dbg!(
        a.expect.add(b.expect),
        a.ansi.add(b.ansi),
        "{:?}.add({:?})", a.ansi, b.ansi,
    );

    assert_eq_dbg!(
        a.expect.add(b.expect.important()),
        a.ansi.add(b.ansi.important()),
        "{:?}.add({:?}.important())", a.ansi, b.ansi,
    );

    assert_eq_dbg!(
        a.expect.important().add(b.expect),
        a.ansi.important().add(b.ansi),
        "{:?}.important().add({:?})", a.ansi, b.ansi,
    );

    assert_eq_dbg!(
        a.expect.important().add(b.expect.important()),
        a.ansi.important().add(b.ansi.important()),
        "{:?}.important().add({:?}.important())", a.ansi, b.ansi,
    );
}

fn check_then(a: TestCase, b: TestCase) {
    assert_eq_dbg!(
        a.expect.then(b.expect),
        a.ansi.then(b.ansi),
        "{:?}.then({:?})", a.ansi, b.ansi,
    );

    assert_eq_dbg!(
        a.expect.then(b.expect.important()),
        a.ansi.then(b.ansi.important()),
        "{:?}.then({:?}.important())", a.ansi, b.ansi,
    );

    assert_eq_dbg!(
        a.expect.important().then(b.expect),
        a.ansi.important().then(b.ansi),
        "{:?}.important().then({:?})", a.ansi, b.ansi,
    );

    assert_eq_dbg!(
        a.expect.important().then(b.expect.important()),
        a.ansi.important().then(b.ansi.important()),
        "{:?}.important().then({:?}.important())", a.ansi, b.ansi,
    );
}

fn check_transition(a: TestCase, b: TestCase) {
    assert_eq_dbg!(
        a.expect.transition(b.expect),
        a.ansi.transition(b.ansi),
        "{:?}.transition({:?})", a.ansi, b.ansi,
    );

    assert_eq_dbg!(
        a.expect.transition(b.expect.important()),
        a.ansi.transition(b.ansi.important()),
        "{:?}.transition({:?}.important())", a.ansi, b.ansi,
    );

    assert_eq_dbg!(
        a.expect.important().transition(b.expect),
        a.ansi.important().transition(b.ansi),
        "{:?}.important().transition({:?})", a.ansi, b.ansi,
    );

    assert_eq_dbg!(
        a.expect.important().transition(b.expect.important()),
        a.ansi.important().transition(b.ansi.important()),
        "{:?}.important().transition({:?}.important())", a.ansi, b.ansi,
    );
}