[rustc.git] / compiler / rustc_transmute / src / layout / tree / tests.rs

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));
        }
    }
}
Commit	Line	Data
064997fb FG	1	use super::Tree;
	2
	3	#[derive(Debug, Hash, Eq, PartialEq, Clone, Copy)]
	4	pub enum Def {
	5	Visible,
	6	Invisible,
	7	}
	8
	9	impl super::Def for Def {}
	10
	11	mod prune {
	12	use super::*;
	13
	14	mod should_simplify {
	15	use super::*;
	16
	17	#[test]
	18	fn seq_1() {
	19	let layout: Tree<Def, !> = Tree::def(Def::Visible).then(Tree::from_bits(0x00));
	20	assert_eq!(layout.prune(&\|d\| matches!(d, Def::Visible)), Tree::from_bits(0x00));
	21	}
	22
	23	#[test]
	24	fn seq_2() {
	25	let layout: Tree<Def, !> =
	26	Tree::from_bits(0x00).then(Tree::def(Def::Visible)).then(Tree::from_bits(0x01));
	27
	28	assert_eq!(
	29	layout.prune(&\|d\| matches!(d, Def::Visible)),
	30	Tree::from_bits(0x00).then(Tree::from_bits(0x01))
	31	);
	32	}
	33	}
	34
	35	mod should_reject {
	36	use super::*;
	37
	38	#[test]
	39	fn invisible_def() {
	40	let layout: Tree<Def, !> = Tree::def(Def::Invisible);
	41	assert_eq!(layout.prune(&\|d\| matches!(d, Def::Visible)), Tree::uninhabited());
	42	}
	43
	44	#[test]
	45	fn invisible_def_in_seq_len_2() {
	46	let layout: Tree<Def, !> = Tree::def(Def::Visible).then(Tree::def(Def::Invisible));
	47	assert_eq!(layout.prune(&\|d\| matches!(d, Def::Visible)), Tree::uninhabited());
	48	}
	49
	50	#[test]
	51	fn invisible_def_in_seq_len_3() {
	52	let layout: Tree<Def, !> =
	53	Tree::def(Def::Visible).then(Tree::from_bits(0x00)).then(Tree::def(Def::Invisible));
	54	assert_eq!(layout.prune(&\|d\| matches!(d, Def::Visible)), Tree::uninhabited());
	55	}
	56	}
	57
	58	mod should_accept {
	59	use super::*;
	60
	61	#[test]
	62	fn visible_def() {
	63	let layout: Tree<Def, !> = Tree::def(Def::Visible);
	64	assert_eq!(layout.prune(&\|d\| matches!(d, Def::Visible)), Tree::unit());
65	}
66
67	#[test]
68	fn visible_def_in_seq_len_2() {
69	let layout: Tree<Def, !> = Tree::def(Def::Visible).then(Tree::def(Def::Visible));
70	assert_eq!(layout.prune(&\|d\| matches!(d, Def::Visible)), Tree::unit());
71	}
72
73	#[test]
74	fn visible_def_in_seq_len_3() {
75	let layout: Tree<Def, !> =
76	Tree::def(Def::Visible).then(Tree::from_bits(0x00)).then(Tree::def(Def::Visible));
77	assert_eq!(layout.prune(&\|d\| matches!(d, Def::Visible)), Tree::from_bits(0x00));
78	}
79	}
80	}