add basic tests

Author: basil-cow

tests/test/coherence.rs

@@ -13,6 +13,18 @@ fn two_impls_for_same_type() {
             "overlapping impls of trait `Foo`"
         }
     }
+
+    lowering_error! {
+        program {
+            trait Foo { }
+            struct Bar<const N> { }
+            impl Foo for Bar<3> { }
+            impl Foo for Bar<3> { }
+        }
+        error_msg {
+            "overlapping impls of trait `Foo`"
+        }
+    }
 }
 
 #[test]
@@ -38,6 +50,16 @@ fn concrete_impl_and_blanket_impl() {
             impl<T> Foo for T { }
         }
     }
+
+    lowering_success! {
+        program {
+            trait Foo { }
+            struct S {}
+            struct Bar<const N> { }
+            impl Foo for Bar<3> { }
+            impl<const N> Foo for Bar<N> { }
+        }
+    }
 }
 
 #[test]

tests/test/constants.rs

@@ -0,0 +1,138 @@
+//! Tests related to const generics.
+
+use super::*;
+
+#[test]
+fn single_impl() {
+    test! {
+        program {
+            struct S<const N> {}
+
+            trait Trait {}
+
+            impl Trait for S<3> {}
+        }
+
+        goal {
+            exists<const N> {
+                S<N>: Trait
+            }
+        } yields {
+            "Unique; substitution [?0 := 3], lifetime constraints []"
+        }
+
+        goal {
+            forall<const N> {
+                S<N>: Trait
+            }
+        } yields {
+            "No possible solution"
+        }
+
+    }
+}
+
+#[test]
+fn multi_impl() {
+    test! {
+        program {
+            struct S<const N> {}
+
+            trait Trait {}
+
+            impl Trait for S<3> {}
+            impl Trait for S<5> {}
+        }
+
+        goal {
+            exists<const N> {
+                S<N>: Trait
+            }
+        } yields {
+            "Ambiguous; no inference guidance"
+        }
+
+        goal {
+            forall<const N> {
+                S<N>: Trait
+            }
+        } yields {
+            "No possible solution"
+        }
+
+    }
+}
+
+#[test]
+fn generic_impl() {
+    test! {
+        program {
+            struct S<const N> {}
+
+            trait Trait {}
+
+            impl<const N> Trait for S<N> {}
+        }
+
+        goal {
+            exists<const N> {
+                S<N>: Trait
+            }
+        } yields {
+            "Unique; for<?U0> { substitution [?0 := ^0.0], lifetime constraints [] }"
+        }
+
+        goal {
+            forall<const N> {
+                S<N>: Trait
+            }
+        } yields {
+            "Unique; substitution [], lifetime constraints []"
+        }
+    }
+}
+
+#[test]
+fn placeholders_eq() {
+    test! {
+        program {}
+
+        goal {
+            forall<const C, const D> {
+                C = D
+            }
+        } yields {
+            "No possible solution"
+        }
+
+        goal {
+            exists<C> {
+                forall<D> {
+                    C = D
+                }
+            }
+        } yields {
+            "No possible solution"
+        }
+
+        goal {
+            forall<C> {
+                exists<D> {
+                    C = D
+                }
+            }
+        } yields {
+            "Unique; substitution [?0 := !1_0], lifetime constraints []"
+        }
+
+        goal {
+            forall<C1, C2> {
+                exists<D1, D2> {
+                    C1 = D1, C2 = D2, D1 = D2
+                }
+            }
+        } yields {
+            "No possible solution"
+        }
+    }
+}

tests/test/mod.rs

@@ -307,6 +307,7 @@ fn solve_goal(program_text: &str, goals: Vec<(&str, SolverChoice, TestGoal)>) {
 mod auto_traits;
 mod coherence_goals;
 mod coinduction;
+mod constants;
 mod cycle;
 mod existential_types;
 mod functions;