1 files changed, 147 insertions, 0 deletions

diff --git a/src/tests.rs b/src/tests.rs
new file mode 100644
index 0000000..5132223
--- /dev/null
+++ b/src/tests.rs
@@ -0,0 +1,147 @@
+use crate::*;
+
+#[test]
+fn mev_cycle() {
+    Dcel::<u32>::new(|mut dcel| {
+        let body = dcel.new_body();
+        let op = dcel.mevvlfs(*body, [0, 1]).unwrap();
+        let op2 = dcel.mev(*op.shell, *op.loop_, *op.vertices[1], 2);
+        let op3 = dcel.mev(*op.shell, *op.loop_, *op2.new_vertex, 3);
+        dcel.melf(*op.shell, [*op3.new_vertex, *op.vertices[0]], *op.loop_);
+
+        let mut vertices = op
+            .loop_
+            .iter_half_edges(&dcel)
+            .map(|x| *x.origin().data())
+            .peekable();
+
+        assert!((0..4)
+            .cycle()
+            .skip(*vertices.peek().unwrap() as _)
+            .take(4)
+            .eq(vertices));
+    })
+}
+
+#[test]
+fn kemh_mekh() {
+    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
+    enum Vert {
+        Inner(u8),
+        Outer(u8),
+    }
+    use Vert::*;
+
+    impl Vert {
+        fn flip(self) -> Self {
+            match self {
+                Outer(x) => Inner(x),
+                Inner(x) => Outer(x),
+            }
+        }
+
+        fn is_outer(self) -> bool {
+            match self {
+                Outer(_) => true,
+                Inner(_) => false,
+            }
+        }
+
+        fn either(self) -> u8 {
+            match self {
+                Outer(x) => x,
+                Inner(x) => x,
+            }
+        }
+    }
+
+    Dcel::<Vert>::new(|mut dcel| {
+        let body = dcel.new_body();
+        let Kevvlfs {
+            shell,
+            loop_: loop_0,
+            vertices: [inner_0, inner_1],
+            ..
+        } = dcel.mevvlfs(*body, [Inner(0), Inner(1)]).unwrap();
+
+        let inner_2 = dcel.mev(*shell, *loop_0, *inner_1, Inner(2)).new_vertex;
+        let mut outer_loop = dcel.melf(*shell, [*inner_0, *inner_2], *loop_0).new_loop;
+
+        let Mev {
+            new_vertex: outer_0,
+            edge,
+            ..
+        } = dcel.mev(*shell, *outer_loop, *inner_0, Outer(0));
+
+        let outer_1 = dcel.mev(*shell, *outer_loop, *outer_0, Outer(1)).new_vertex;
+        let outer_2 = dcel.mev(*shell, *outer_loop, *outer_1, Outer(2)).new_vertex;
+
+        let loop_2 = dcel
+            .melf(*shell, [*outer_0, *outer_2], *outer_loop)
+            .new_loop;
+        if edge.lens(&dcel).half_edges()[0].loop_().eq(*loop_2) {
+            outer_loop = loop_2;
+        }
+
+        let mut kemh = Kemh::new(*shell, edge, *outer_loop, *inner_0);
+
+        for i in 0..10 {
+            struct State {
+                seen: u8,
+                last: Option<Vert>,
+            }
+
+            let mut st = State {
+                seen: 0,
+                last: None,
+            };
+
+            for v in outer_loop
+                .iter_half_edges(&dcel)
+                .map(|x| *x.origin().data())
+            {
+                let mut s = 1u8 << v.either();
+                if v.is_outer() {
+                    s <<= 4;
+                }
+                if st.seen & s == 0 {
+                    st.seen |= s;
+                } else {
+                    assert_eq!(v.either(), 0);
+                    assert_eq!(st.seen & (s << 3), 0);
+                    st.seen |= s << 3;
+                }
+
+                if let Some(last) = st.last {
+                    if v.either() == 0 {
+                        assert!(
+                            last == v.flip()
+                                || (last.is_outer() == v.is_outer() && last.either() != 0)
+                        );
+                    } else {
+                        assert_eq!(last.is_outer(), v.is_outer());
+                    }
+                }
+
+                st.last = Some(v);
+            }
+
+            assert_eq!(st.seen, 255);
+
+            let mekh = kemh.apply(&mut dcel).unwrap();
+
+            for (loop_, outer) in [(*outer_loop, true), (*mekh.hole_loop, false)] {
+                let mut seen = 0;
+                for v in loop_.iter_half_edges(&dcel).map(|x| *x.origin().data()) {
+                    let s = 1 << v.either();
+                    assert_eq!(v.is_outer(), outer);
+                    assert_eq!(seen & s, 0);
+                    seen |= s;
+                }
+                assert_eq!(seen, 7);
+            }
+
+            kemh = mekh.apply(&mut dcel).unwrap();
+        }
+    })
+}