summaryrefslogtreecommitdiffstats
path: root/compiler/rustc_transmute/src/layout/tree/tests.rs
blob: 90515e92f7aef58724bcecc0acbc2a8ac6edda21 (plain)
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
use super::Tree;

#[derive(Debug, Hash, Eq, PartialEq, Clone, Copy)]
pub enum Def {
    Visible,
    Invisible,
}

impl super::Def for Def {}

mod prune {
    use super::*;

    mod should_simplify {
        use super::*;

        #[test]
        fn seq_1() {
            let layout: Tree<Def, !> = Tree::def(Def::Visible).then(Tree::from_bits(0x00));
            assert_eq!(layout.prune(&|d| matches!(d, Def::Visible)), Tree::from_bits(0x00));
        }

        #[test]
        fn seq_2() {
            let layout: Tree<Def, !> =
                Tree::from_bits(0x00).then(Tree::def(Def::Visible)).then(Tree::from_bits(0x01));

            assert_eq!(
                layout.prune(&|d| matches!(d, Def::Visible)),
                Tree::from_bits(0x00).then(Tree::from_bits(0x01))
            );
        }
    }

    mod should_reject {
        use super::*;

        #[test]
        fn invisible_def() {
            let layout: Tree<Def, !> = Tree::def(Def::Invisible);
            assert_eq!(layout.prune(&|d| matches!(d, Def::Visible)), Tree::uninhabited());
        }

        #[test]
        fn invisible_def_in_seq_len_2() {
            let layout: Tree<Def, !> = Tree::def(Def::Visible).then(Tree::def(Def::Invisible));
            assert_eq!(layout.prune(&|d| matches!(d, Def::Visible)), Tree::uninhabited());
        }

        #[test]
        fn invisible_def_in_seq_len_3() {
            let layout: Tree<Def, !> =
                Tree::def(Def::Visible).then(Tree::from_bits(0x00)).then(Tree::def(Def::Invisible));
            assert_eq!(layout.prune(&|d| matches!(d, Def::Visible)), Tree::uninhabited());
        }
    }

    mod should_accept {
        use super::*;

        #[test]
        fn visible_def() {
            let layout: Tree<Def, !> = Tree::def(Def::Visible);
            assert_eq!(layout.prune(&|d| matches!(d, Def::Visible)), Tree::unit());
        }

        #[test]
        fn visible_def_in_seq_len_2() {
            let layout: Tree<Def, !> = Tree::def(Def::Visible).then(Tree::def(Def::Visible));
            assert_eq!(layout.prune(&|d| matches!(d, Def::Visible)), Tree::unit());
        }

        #[test]
        fn visible_def_in_seq_len_3() {
            let layout: Tree<Def, !> =
                Tree::def(Def::Visible).then(Tree::from_bits(0x00)).then(Tree::def(Def::Visible));
            assert_eq!(layout.prune(&|d| matches!(d, Def::Visible)), Tree::from_bits(0x00));
        }
    }
}