parser stuff

tests/Tests/Parser.idr

@@ -4,7 +4,9 @@ import Quox.Syntax
 import Quox.Parser
 import Quox.Lexer
 import Tests.Lexer
+import Quox.Pretty
 
+import TermImpls
 import Data.SnocVect
 import Text.Parser
 import TAP
@@ -50,21 +52,29 @@ Show a => ToInfo (Error a) where
   toInfo (ShouldFail got) = toInfo [("success", got)]
 
 
-parameters {c : Bool} (grm : Grammar c a) (input : String)
-  parses : (Show a, Eq a) => a -> Test
-  parses exp = test "\"\{input}\"" $ delay $
+parameters {c : Bool} (grm : Grammar c a) (note : String) (input : String)
+  parsesNote : (Show a, Eq a) => a -> Test
+  parsesNote exp = test "\"\{input}\"\{note}" $ delay $
     case lexParseAll grm input of
          Right got => if got == exp then Right ()
                                     else Left $ Unexpected exp got
          Left  err => Left $ Parser err
 
-  rejects : Show a => Test
-  rejects = test "\"\{input}\"  (reject)" $ do
+  rejectsNote : Show a => Test
+  rejectsNote = test "\"\{input}\"\{note}  (reject)" $ do
     case lexParseAll grm input of
          Left  err => Right ()
          Right val => Left $ ShouldFail val
 
+parameters {c : Bool} (grm : Grammar c a) (input : String)
+  parses : (Show a, Eq a) => a -> Test
+  parses = parsesNote grm "" input
+
+  rejects : Show a => Test
+  rejects = rejectsNote grm "" input
+
 tests = "parser" :- [
+  skip $
   "numbers" :-
   let parses = parses number
   in [
@@ -73,8 +83,9 @@ tests = "parser" :- [
     parses "1000" 1000
   ],
 
+  skip $
   "bound vars (x, y, z ⊢)" :-
-  let grm = bound [< "x", "y", "z"]
+  let grm = bound "test" [< "x", "y", "z"]
       parses = parses grm; rejects = rejects grm
   in [
     parses  "x" (V 2),
@@ -85,8 +96,9 @@ tests = "parser" :- [
     rejects "a"
   ],
 
+  skip $
   "bound or free vars (x, y, z ⊢)" :-
-  let parses = parses $ nameWith [< "x", "y", "z"]
+  let parses = parses $ nameWith {bound = [< "x", "y", "z"], avoid = [<]}
   in [
     parses "x"         (Left (V 2)),
     parses "y"         (Left (V 1)),
@@ -98,7 +110,8 @@ tests = "parser" :- [
     parses "x.a"       (Right (MakeName [< "x"]      (UN "a")))
   ],
 
-  "dimension (x, y, z ⊢)" :-
+  skip $
+  "dimension (x, y, z | · ⊢)" :-
   let grm = dimension [< "x", "y", "z"]
       parses = parses grm; rejects = rejects grm
   in [
@@ -107,5 +120,20 @@ tests = "parser" :- [
     rejects "2",
     parses  "x" (B (V 2)),
     rejects "a"
+  ],
+
+  "terms & elims (i, j | x, y, z ⊢)" :-
+  let dvars = [< "i", "j"]; tvars = [< "x", "y", "z"]
+      tgrm = term {dvars, tvars}; egrm = elim {dvars, tvars}
+      tparses  = parsesNote  tgrm "  (term)"
+      eparses  = parsesNote  egrm "  (elim)"
+      trejects = rejectsNote tgrm "  (term)"
+      erejects = rejectsNote egrm "  (elim)"
+  in [
+    eparses  "a"   (F "a"),
+    eparses  "x"   (BV 2),
+    trejects "a",
+    tparses  "[a]" (FT "a"),
+    tparses  "[x]" (BVT 2)
   ]
 ]