72 lines
1.9 KiB
Haskell
72 lines
1.9 KiB
Haskell
module ParserTests (tests) where
|
|
|
|
import Data.Text (Text)
|
|
import qualified Data.Text as T
|
|
import Expr (Expr (..))
|
|
import Parser (pAll)
|
|
import Test.HUnit
|
|
|
|
ident :: Expr
|
|
ident =
|
|
Abs "A" Star $
|
|
Abs "x" (Var 0 "A") $
|
|
Var 0 "x"
|
|
|
|
ident1 :: Test
|
|
ident1 =
|
|
TestCase $
|
|
assertEqual
|
|
"ident 1"
|
|
(Right ident)
|
|
(pAll "lambda (A : *) . lambda (x : A) . x")
|
|
|
|
ident2 :: Test
|
|
ident2 =
|
|
TestCase $
|
|
assertEqual
|
|
"ident 2"
|
|
(Right ident)
|
|
(pAll "fun (A : *) (x : A) => x")
|
|
|
|
double :: Expr
|
|
double =
|
|
Abs "A" Star $
|
|
Abs "B" Star $
|
|
Abs "f" (Pi "" (Var 1 "A") (Var 1 "B")) $
|
|
Abs "g" (Pi "" (Var 2 "A") (Var 2 "B")) $
|
|
Abs "x" (Var 3 "A") $
|
|
App (Var 2 "f") (Var 0 "x")
|
|
|
|
doubleTest :: Test
|
|
doubleTest =
|
|
TestCase $
|
|
assertEqual
|
|
"double"
|
|
(Right double)
|
|
(pAll "fun (A B : *) (f g : A -> B) (x : A) => f x")
|
|
|
|
theorem :: Expr
|
|
theorem =
|
|
Abs "S" Star $
|
|
Abs "P" (Pi "" (Var 0 "S") Star) $
|
|
Abs "Q" (Pi "" (Var 1 "S") Star) $
|
|
Abs "HP" (Pi "x" (Var 2 "S") (App (Var 2 "P") (Var 0 "x"))) $
|
|
Abs "H" (Pi "x" (Var 3 "S") (Pi "" (App (Var 3 "P") (Var 0 "x")) (App (Var 3 "Q") (Var 1 "x")))) $
|
|
Abs "x" (Var 4 "S") (App (App (Var 1 "H") (Var 0 "x")) (App (Var 2 "HP") (Var 0 "x")))
|
|
|
|
theoremTest :: Test
|
|
theoremTest =
|
|
TestCase $
|
|
assertEqual
|
|
"theorem"
|
|
(Right theorem)
|
|
(pAll "fun (S : *) (P Q : S -> *) (HP : ∏ (x : S) . P x) (H : forall (x : S), P x -> Q x) (x : S) => H x (HP x)")
|
|
|
|
tests :: Test
|
|
tests =
|
|
TestList
|
|
[ TestLabel "ident1" ident1
|
|
, TestLabel "ident2" ident2
|
|
, TestLabel "double" doubleTest
|
|
, TestLabel "theorem" theoremTest
|
|
]
|