status: working, IO not yet implemented

test/Test.hs

@@ -0,0 +1,52 @@
+{-# LANGUAGE TemplateHaskell #-}
+
+module Test (tests) where
+
+import CombParse
+import Distribution.TestSuite (Progress (Finished), Result (Error, Fail, Pass), Test (Group, Test))
+import Test.TemplateStuff (mkSimpleCheck)
+
+mkSimpleCheck "checkStr" 'parseVal "\"Str\"" [p|Str "Str"|] "parse a Str"
+mkSimpleCheck "checkNumb" 'parseVal "69420" [p|Numb 69420|] "parse a Numb"
+mkSimpleCheck "checkId" 'parseVal "x" [p|Id "x"|] "parse an Id"
+mkSimpleCheck "checkI" 'parseExpr "I x" [p|Comb (Var (Id "I")) (Var (Id "x"))|] "parse \"I x\""
+mkSimpleCheck "checkK" 'parseExpr "K x y" [p|Comb (Comb (Var (Id "K")) (Var (Id "x"))) (Var (Id "y"))|] "parse \"K x y\""
+mkSimpleCheck "checkS" 'parseExpr "S x y" [p|Comb (Comb (Var (Id "S")) (Var (Id "x"))) (Var (Id "y"))|] "parse \"S x y\""
+mkSimpleCheck "checkIimpl" 'parseExpr "S K x" [p|Comb (Comb (Var (Id "S")) (Var (Id "K"))) (Var (Id "x"))|] "parse \"S K x\""
+mkSimpleCheck "checkMimpl" 'parseExpr "S I I" [p|Comb (Comb (Var (Id "S")) (Var (Id "I"))) (Var (Id "I"))|] "parse \"S I I\""
+mkSimpleCheck "checkNOTimpl" 'parseExpr "S (S I (K F)) (K T) b" [p|(Comb (Comb (Comb (Var (Id "S")) (Comb (Comb (Var (Id "S")) (Var (Id "I"))) (Comb (Var (Id "K")) (Var (Id "F"))))) (Comb (Var (Id "K")) (Var (Id "T")))) (Var (Id "b")))|] "parse \"S I I\""
+
+tests :: IO [Test]
+tests =
+  return
+    [ Group
+        "value"
+        False
+        ( map
+            Test
+            [ checkStr,
+              checkNumb,
+              checkId
+            ]
+        ),
+      Group
+        "Comb"
+        False
+        ( map
+            Test
+            [ checkI,
+              checkK,
+              checkS
+            ]
+        ),
+      Group
+        "complex"
+        False
+        ( map
+            Test
+            [ checkIimpl,
+              checkMimpl,
+              checkNOTimpl
+            ]
+        )
+    ]

test/Test/TemplateStuff.hs

@@ -0,0 +1,36 @@
+{-# LANGUAGE TemplateHaskell #-}
+
+module Test.TemplateStuff (mkSimpleCheck) where
+
+import Distribution.TestSuite (TestInstance (TestInstance, name, options, run, setOption, tags))
+import Language.Haskell.TH (Dec, Name, Pat, Q, conT, mkName, normalB, pprint, sigD, valD, varE, varP)
+
+mkSimpleCheck :: String -> Name -> String -> Q Pat -> String -> Q [Dec]
+mkSimpleCheck fn p str qv n = do
+  let funName = mkName fn
+  v <- qv
+  let strv = pprint v
+  sig <- sigD funName (conT ''TestInstance)
+  def <-
+    valD
+      (varP funName)
+      ( normalB
+          [|
+            TestInstance
+              { run =
+                  return $
+                    Finished
+                      ( case runParser $(varE p) str of
+                          Just $(pure v) -> Pass
+                          Just o -> Fail $ "expected " ++ strv ++ ", got " ++ show o ++ " instead"
+                          Nothing -> Error "runParser failed and returned no output"
+                      ),
+                name = n,
+                tags = [],
+                options = [],
+                setOption = const $ const $ Right $(varE funName)
+              }
+            |]
+      )
+      []
+  pure [sig, def]