perga/tests/ParserTests.hs

module ParserTests (tests) where

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
        ]