James Eversole
e6e18239a7
This update includes an update to `decodeResult` that makes string decoding far less aggressive. This also replaces the `!decode` REPL command with `!output` to allow users to switch output format on the fly. New tests are included for verifying decoding behavior; this group needs to be fleshed out further.
557 lines
20 KiB
Haskell
557 lines
20 KiB
Haskell
module Main where
|
|
|
|
import Eval
|
|
import FileEval
|
|
import Lexer
|
|
import Parser
|
|
import REPL
|
|
import Research
|
|
|
|
import Control.Exception (evaluate, try, SomeException)
|
|
import Control.Monad.IO.Class (liftIO)
|
|
import Data.List (isInfixOf)
|
|
import Test.Tasty
|
|
import Test.Tasty.HUnit
|
|
import Test.Tasty.QuickCheck
|
|
import Text.Megaparsec (runParser)
|
|
|
|
import qualified Data.Map as Map
|
|
import qualified Data.Set as Set
|
|
|
|
main :: IO ()
|
|
main = defaultMain tests
|
|
|
|
runTricu :: String -> String
|
|
runTricu s = show $ result (evalTricu Map.empty $ parseTricu s)
|
|
|
|
tests :: TestTree
|
|
tests = testGroup "Tricu Tests"
|
|
[ lexer
|
|
, parser
|
|
, simpleEvaluation
|
|
, lambdas
|
|
, providedLibraries
|
|
, fileEval
|
|
, modules
|
|
, demos
|
|
, decoding
|
|
]
|
|
|
|
lexer :: TestTree
|
|
lexer = testGroup "Lexer Tests"
|
|
[ testCase "Lex simple identifiers" $ do
|
|
let input = "x a b = a"
|
|
expect = Right [LIdentifier "x", LIdentifier "a", LIdentifier "b", LAssign, LIdentifier "a"]
|
|
runParser tricuLexer "" input @?= expect
|
|
|
|
, testCase "Lex Tree Calculus terms" $ do
|
|
let input = "t t t"
|
|
expect = Right [LKeywordT, LKeywordT, LKeywordT]
|
|
runParser tricuLexer "" input @?= expect
|
|
|
|
, testCase "Lex escaped characters in strings" $ do
|
|
let input = "\"hello\\nworld\""
|
|
expect = Right [LStringLiteral "hello\\nworld"]
|
|
runParser tricuLexer "" input @?= expect
|
|
|
|
, testCase "Lex mixed literals" $ do
|
|
let input = "t \"string\" 42"
|
|
expect = Right [LKeywordT, LStringLiteral "string", LIntegerLiteral 42]
|
|
runParser tricuLexer "" input @?= expect
|
|
|
|
, testCase "Lex invalid token" $ do
|
|
let input = "&invalid"
|
|
case runParser tricuLexer "" input of
|
|
Left _ -> return ()
|
|
Right _ -> assertFailure "Expected lexer to fail on invalid token"
|
|
|
|
, testCase "Drop trailing whitespace in definitions" $ do
|
|
let input = "x = 5 "
|
|
expect = [LIdentifier "x",LAssign,LIntegerLiteral 5]
|
|
case (runParser tricuLexer "" input) of
|
|
Left _ -> assertFailure "Failed to lex input"
|
|
Right i -> i @?= expect
|
|
|
|
, testCase "Error when using invalid characters in identifiers" $ do
|
|
case (runParser tricuLexer "" "!result = 5") of
|
|
Left _ -> return ()
|
|
Right _ -> assertFailure "Expected failure when trying to assign the value of !result"
|
|
]
|
|
|
|
parser :: TestTree
|
|
parser = testGroup "Parser Tests"
|
|
[ testCase "Error when assigning a value to T" $ do
|
|
let tokens = lexTricu "t = x"
|
|
case parseSingleExpr tokens of
|
|
Left _ -> return ()
|
|
Right _ -> assertFailure "Expected failure when trying to assign the value of T"
|
|
|
|
, testCase "Parse function definitions" $ do
|
|
let input = "x = (\\a b c : a)"
|
|
expect = SDef "x" [] (SLambda ["a"] (SLambda ["b"] (SLambda ["c"] (SVar "a"))))
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse nested Tree Calculus terms" $ do
|
|
let input = "t (t t) t"
|
|
expect = SApp (SApp TLeaf (SApp TLeaf TLeaf)) TLeaf
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse sequential Tree Calculus terms" $ do
|
|
let input = "t t t"
|
|
expect = SApp (SApp TLeaf TLeaf) TLeaf
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse mixed list literals" $ do
|
|
let input = "[t (\"hello\") t]"
|
|
expect = SList [TLeaf, SStr "hello", TLeaf]
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse function with applications" $ do
|
|
let input = "f = (\\x : t x)"
|
|
expect = SDef "f" [] (SLambda ["x"] (SApp TLeaf (SVar "x")))
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse nested lists" $ do
|
|
let input = "[t [(t t)]]"
|
|
expect = SList [TLeaf,SList [SApp TLeaf TLeaf]]
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse complex parentheses" $ do
|
|
let input = "t (t t (t t))"
|
|
expect = SApp TLeaf (SApp (SApp TLeaf TLeaf) (SApp TLeaf TLeaf))
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse empty list" $ do
|
|
let input = "[]"
|
|
expect = SList []
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse multiple nested lists" $ do
|
|
let input = "[[t t] [t (t t)]]"
|
|
expect = SList [SList [TLeaf,TLeaf],SList [TLeaf,SApp TLeaf TLeaf]]
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse whitespace variance" $ do
|
|
let input1 = "[t t]"
|
|
let input2 = "[ t t ]"
|
|
expect = SList [TLeaf, TLeaf]
|
|
parseSingle input1 @?= expect
|
|
parseSingle input2 @?= expect
|
|
|
|
, testCase "Parse string in list" $ do
|
|
let input = "[(\"hello\")]"
|
|
expect = SList [SStr "hello"]
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse parentheses inside list" $ do
|
|
let input = "[t (t t)]"
|
|
expect = SList [TLeaf,SApp TLeaf TLeaf]
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse nested parentheses in function body" $ do
|
|
let input = "f = (\\x : t (t (t t)))"
|
|
expect = SDef "f" [] (SLambda ["x"] (SApp TLeaf (SApp TLeaf (SApp TLeaf TLeaf))))
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse lambda abstractions" $ do
|
|
let input = "(\\a : a)"
|
|
expect = (SLambda ["a"] (SVar "a"))
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Parse multiple arguments to lambda abstractions" $ do
|
|
let input = "x = (\\a b : a)"
|
|
expect = SDef "x" [] (SLambda ["a"] (SLambda ["b"] (SVar "a")))
|
|
parseSingle input @?= expect
|
|
|
|
, testCase "Grouping T terms with parentheses in function application" $ do
|
|
let input = "x = (\\a : a)\nx (t)"
|
|
expect = [SDef "x" [] (SLambda ["a"] (SVar "a")),SApp (SVar "x") TLeaf]
|
|
parseTricu input @?= expect
|
|
|
|
, testCase "Comments 1" $ do
|
|
let input = "(t) (t) -- (t)"
|
|
expect = [SApp TLeaf TLeaf]
|
|
parseTricu input @?= expect
|
|
|
|
, testCase "Comments 2" $ do
|
|
let input = "(t) -- (t) -- (t)"
|
|
expect = [TLeaf]
|
|
parseTricu input @?= expect
|
|
]
|
|
|
|
simpleEvaluation :: TestTree
|
|
simpleEvaluation = testGroup "Evaluation Tests"
|
|
[ testCase "Evaluate single Leaf" $ do
|
|
let input = "t"
|
|
let ast = parseSingle input
|
|
(result $ evalSingle Map.empty ast) @?= Leaf
|
|
|
|
, testCase "Evaluate single Stem" $ do
|
|
let input = "t t"
|
|
let ast = parseSingle input
|
|
(result $ evalSingle Map.empty ast) @?= Stem Leaf
|
|
|
|
, testCase "Evaluate single Fork" $ do
|
|
let input = "t t t"
|
|
let ast = parseSingle input
|
|
(result $ evalSingle Map.empty ast) @?= Fork Leaf Leaf
|
|
|
|
, testCase "Evaluate nested Fork and Stem" $ do
|
|
let input = "t (t t) t"
|
|
let ast = parseSingle input
|
|
(result $ evalSingle Map.empty ast) @?= Fork (Stem Leaf) Leaf
|
|
|
|
, testCase "Evaluate `not` function" $ do
|
|
let input = "t (t (t t) (t t t)) t"
|
|
let ast = parseSingle input
|
|
(result $ evalSingle Map.empty ast) @?=
|
|
Fork (Fork (Stem Leaf) (Fork Leaf Leaf)) Leaf
|
|
|
|
, testCase "Environment updates with definitions" $ do
|
|
let input = "x = t\ny = x"
|
|
env = evalTricu Map.empty (parseTricu input)
|
|
Map.lookup "x" env @?= Just Leaf
|
|
Map.lookup "y" env @?= Just Leaf
|
|
|
|
, testCase "Variable substitution" $ do
|
|
let input = "x = t t\ny = t x\ny"
|
|
env = evalTricu Map.empty (parseTricu input)
|
|
(result env) @?= Stem (Stem Leaf)
|
|
|
|
, testCase "Multiline input evaluation" $ do
|
|
let input = "x = t\ny = t t\nx"
|
|
env = evalTricu Map.empty (parseTricu input)
|
|
(result env) @?= Leaf
|
|
|
|
, testCase "Evaluate string literal" $ do
|
|
let input = "\"hello\""
|
|
let ast = parseSingle input
|
|
(result $ evalSingle Map.empty ast) @?= ofString "hello"
|
|
|
|
, testCase "Evaluate list literal" $ do
|
|
let input = "[t (t t)]"
|
|
let ast = parseSingle input
|
|
(result $ evalSingle Map.empty ast) @?= ofList [Leaf, Stem Leaf]
|
|
|
|
, testCase "Evaluate empty list" $ do
|
|
let input = "[]"
|
|
let ast = parseSingle input
|
|
(result $ evalSingle Map.empty ast) @?= ofList []
|
|
|
|
, testCase "Evaluate variable dependency chain" $ do
|
|
let input = "x = t (t t)\n \
|
|
\ y = x\n \
|
|
\ z = y\n \
|
|
\ variablewithamuchlongername = z\n \
|
|
\ variablewithamuchlongername"
|
|
env = evalTricu Map.empty (parseTricu input)
|
|
(result env) @?= (Stem (Stem Leaf))
|
|
|
|
|
|
, testCase "Immutable definitions" $ do
|
|
let input = "x = t t\nx = t\nx"
|
|
env = evalTricu Map.empty (parseTricu input)
|
|
result <- try (evaluate (runTricu input)) :: IO (Either SomeException String)
|
|
case result of
|
|
Left _ -> return ()
|
|
Right _ -> assertFailure "Expected evaluation error"
|
|
|
|
|
|
, testCase "Apply identity to Boolean Not" $ do
|
|
let not = "(t (t (t t) (t t t)) t)"
|
|
let input = "x = (\\a : a)\nx " ++ not
|
|
env = evalTricu Map.empty (parseTricu input)
|
|
result env @?= Fork (Fork (Stem Leaf) (Fork Leaf Leaf)) Leaf
|
|
]
|
|
|
|
lambdas :: TestTree
|
|
lambdas = testGroup "Lambda Evaluation Tests"
|
|
[ testCase "Lambda Identity Function" $ do
|
|
let input = "id = (\\x : x)\nid t"
|
|
runTricu input @?= "Leaf"
|
|
|
|
, testCase "Lambda Constant Function (K combinator)" $ do
|
|
let input = "k = (\\x y : x)\nk t (t t)"
|
|
runTricu input @?= "Leaf"
|
|
|
|
, testCase "Lambda Application with Variable" $ do
|
|
let input = "id = (\\x : x)\nval = t t\nid val"
|
|
runTricu input @?= "Stem Leaf"
|
|
|
|
, testCase "Lambda Application with Multiple Arguments" $ do
|
|
let input = "apply = (\\f x y : f x y)\nk = (\\a b : a)\napply k t (t t)"
|
|
runTricu input @?= "Leaf"
|
|
|
|
, testCase "Nested Lambda Application" $ do
|
|
let input = "apply = (\\f x y : f x y)\nid = (\\x : x)\napply (\\f x : f x) id t"
|
|
runTricu input @?= "Leaf"
|
|
|
|
, testCase "Lambda with a complex body" $ do
|
|
let input = "f = (\\x : t (t x))\nf t"
|
|
runTricu input @?= "Stem (Stem Leaf)"
|
|
|
|
, testCase "Lambda returning a function" $ do
|
|
let input = "f = (\\x : (\\y : x))\ng = f t\ng (t t)"
|
|
runTricu input @?= "Leaf"
|
|
|
|
, testCase "Lambda with Shadowing" $ do
|
|
let input = "f = (\\x : (\\x : x))\nf t (t t)"
|
|
runTricu input @?= "Stem Leaf"
|
|
|
|
, testCase "Lambda returning another lambda" $ do
|
|
let input = "k = (\\x : (\\y : x))\nk_app = k t\nk_app (t t)"
|
|
runTricu input @?= "Leaf"
|
|
|
|
, testCase "Lambda with free variables" $ do
|
|
let input = "y = t t\nf = (\\x : y)\nf t"
|
|
runTricu input @?= "Stem Leaf"
|
|
|
|
, testCase "SKI Composition" $ do
|
|
let input = "s = (\\x y z : x z (y z))\nk = (\\x y : x)\ni = (\\x : x)\ncomp = s k i\ncomp t (t t)"
|
|
runTricu input @?= "Stem (Stem Leaf)"
|
|
|
|
, testCase "Lambda with multiple parameters and application" $ do
|
|
let input = "f = (\\a b c : t a b c)\nf t (t t) (t t t)"
|
|
runTricu input @?= "Stem Leaf"
|
|
|
|
, testCase "Lambda with nested application in the body" $ do
|
|
let input = "f = (\\x : t (t (t x)))\nf t"
|
|
runTricu input @?= "Stem (Stem (Stem Leaf))"
|
|
|
|
, testCase "Lambda returning a function and applying it" $ do
|
|
let input = "f = (\\x : (\\y : t x y))\ng = f t\ng (t t)"
|
|
runTricu input @?= "Fork Leaf (Stem Leaf)"
|
|
|
|
, testCase "Lambda applying a variable" $ do
|
|
let input = "id = (\\x : x)\na = t t\nid a"
|
|
runTricu input @?= "Stem Leaf"
|
|
|
|
, testCase "Nested lambda abstractions in the same expression" $ do
|
|
let input = "f = (\\x : (\\y : x y))\ng = (\\z : z)\nf g t"
|
|
runTricu input @?= "Leaf"
|
|
|
|
, testCase "Lambda applied to string literal" $ do
|
|
let input = "f = (\\x : x)\nf \"hello\""
|
|
runTricu input @?= "Fork (Fork Leaf (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork Leaf (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) (Fork (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork (Stem Leaf) Leaf))))))) Leaf))))"
|
|
|
|
|
|
, testCase "Lambda applied to integer literal" $ do
|
|
let input = "f = (\\x : x)\nf 42"
|
|
runTricu input @?= "Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) (Fork Leaf (Fork (Stem Leaf) Leaf)))))"
|
|
|
|
, testCase "Lambda applied to list literal" $ do
|
|
let input = "f = (\\x : x)\nf [t (t t)]"
|
|
runTricu input @?= "Fork Leaf (Fork (Stem Leaf) Leaf)"
|
|
|
|
, testCase "Lambda containing list literal" $ do
|
|
let input = "(\\a : [(a)]) 1"
|
|
runTricu input @?= "Fork (Fork (Stem Leaf) Leaf) Leaf"
|
|
]
|
|
|
|
providedLibraries :: TestTree
|
|
providedLibraries = testGroup "Library Tests"
|
|
[ testCase "Triage test Leaf" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "test t"
|
|
env = decodeResult $ result $ evalTricu library (parseTricu input)
|
|
env @?= "\"Leaf\""
|
|
|
|
, testCase "Triage test (Stem Leaf)" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "test (t t)"
|
|
env = decodeResult $ result $ evalTricu library (parseTricu input)
|
|
env @?= "\"Stem\""
|
|
|
|
, testCase "Triage test (Fork Leaf Leaf)" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "test (t t t)"
|
|
env = decodeResult $ result $ evalTricu library (parseTricu input)
|
|
env @?= "\"Fork\""
|
|
|
|
, testCase "Boolean NOT: true" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "not? true"
|
|
env = result $ evalTricu library (parseTricu input)
|
|
env @?= Leaf
|
|
|
|
, testCase "Boolean NOT: false" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "not? false"
|
|
env = result $ evalTricu library (parseTricu input)
|
|
env @?= Stem Leaf
|
|
|
|
|
|
, testCase "Boolean AND TF" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "and? (t t) (t)"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Leaf
|
|
|
|
, testCase "Boolean AND FT" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "and? (t) (t t)"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Leaf
|
|
|
|
, testCase "Boolean AND FF" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "and? (t) (t)"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Leaf
|
|
|
|
, testCase "Boolean AND TT" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "and? (t t) (t t)"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Stem Leaf
|
|
|
|
, testCase "List head" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "head [(t) (t t) (t t t)]"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Leaf
|
|
|
|
, testCase "List tail" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "head (tail (tail [(t) (t t) (t t t)]))"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Fork Leaf Leaf
|
|
|
|
, testCase "List map" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "head (tail (map (\\a : (t t t)) [(t) (t) (t)]))"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Fork Leaf Leaf
|
|
|
|
, testCase "Empty list check" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "emptyList? []"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Stem Leaf
|
|
|
|
, testCase "Non-empty list check" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "not? (emptyList? [(1) (2) (3)])"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Stem Leaf
|
|
|
|
, testCase "Concatenate strings" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "append \"Hello, \" \"world!\""
|
|
env = decodeResult $ result $ evalTricu library (parseTricu input)
|
|
env @?= "\"Hello, world!\""
|
|
|
|
, testCase "Verifying Equality" $ do
|
|
library <- evaluateFile "./lib/list.tri"
|
|
let input = "equal? (t t t) (t t t)"
|
|
env = evalTricu library (parseTricu input)
|
|
result env @?= Stem Leaf
|
|
]
|
|
|
|
fileEval :: TestTree
|
|
fileEval = testGroup "File evaluation tests"
|
|
[ testCase "Forks" $ do
|
|
res <- liftIO $ evaluateFileResult "./test/fork.tri"
|
|
res @?= Fork Leaf Leaf
|
|
|
|
, testCase "File ends with comment" $ do
|
|
res <- liftIO $ evaluateFileResult "./test/comments-1.tri"
|
|
res @?= Fork (Stem Leaf) Leaf
|
|
|
|
, testCase "Mapping and Equality" $ do
|
|
library <- liftIO $ evaluateFile "./lib/list.tri"
|
|
fEnv <- liftIO $ evaluateFileWithContext library "./test/map.tri"
|
|
(mainResult fEnv) @?= Stem Leaf
|
|
|
|
, testCase "Eval and decoding string" $ do
|
|
library <- liftIO $ evaluateFile "./lib/list.tri"
|
|
res <- liftIO $ evaluateFileWithContext library "./test/string.tri"
|
|
decodeResult (result res) @?= "\"String test!\""
|
|
]
|
|
|
|
modules :: TestTree
|
|
modules = testGroup "Test modules"
|
|
[ testCase "Detect cyclic dependencies" $ do
|
|
result <- try (liftIO $ evaluateFileResult "./test/cycle-1.tri") :: IO (Either SomeException T)
|
|
case result of
|
|
Left e -> do
|
|
let errorMsg = show e
|
|
if "Encountered cyclic import" `isInfixOf` errorMsg
|
|
then return ()
|
|
else assertFailure $ "Unexpected error: " ++ errorMsg
|
|
Right _ -> assertFailure "Expected cyclic dependencies"
|
|
, testCase "Module imports and namespacing" $ do
|
|
res <- liftIO $ evaluateFileResult "./test/namespace-A.tri"
|
|
res @?= Leaf
|
|
, testCase "Multiple imports" $ do
|
|
res <- liftIO $ evaluateFileResult "./test/vars-A.tri"
|
|
res @?= Leaf
|
|
, testCase "Error on unresolved variable" $ do
|
|
result <- try (liftIO $ evaluateFileResult "./test/unresolved-A.tri") :: IO (Either SomeException T)
|
|
case result of
|
|
Left e -> do
|
|
let errorMsg = show e
|
|
if "undefinedVar" `isInfixOf` errorMsg
|
|
then return ()
|
|
else assertFailure $ "Unexpected error: " ++ errorMsg
|
|
Right _ -> assertFailure "Expected unresolved variable error"
|
|
, testCase "Multi-level imports" $ do
|
|
res <- liftIO $ evaluateFileResult "./test/multi-level-A.tri"
|
|
res @?= Leaf
|
|
, testCase "Lambda expression namespaces" $ do
|
|
res <- liftIO $ evaluateFileResult "./test/lambda-A.tri"
|
|
res @?= Leaf
|
|
, testCase "Local namespace import chain" $ do
|
|
res <- liftIO $ evaluateFileResult "./test/local-ns/1.tri"
|
|
res @?= Fork (Stem Leaf) (Fork (Stem Leaf) Leaf)
|
|
]
|
|
|
|
|
|
-- All of our demo tests are also module tests
|
|
demos :: TestTree
|
|
demos = testGroup "Test provided demo functionality"
|
|
[ testCase "Structural equality demo" $ do
|
|
res <- liftIO $ evaluateFileResult "./demos/equality.tri"
|
|
decodeResult res @?= "t t"
|
|
, testCase "Convert values back to source code demo" $ do
|
|
res <- liftIO $ evaluateFileResult "./demos/toSource.tri"
|
|
decodeResult res @?= "\"(t (t (t t) (t t t)) (t t (t t t)))\""
|
|
, testCase "Determining the size of functions" $ do
|
|
res <- liftIO $ evaluateFileResult "./demos/size.tri"
|
|
decodeResult res @?= "454"
|
|
, testCase "Level Order Traversal demo" $ do
|
|
res <- liftIO $ evaluateFileResult "./demos/levelOrderTraversal.tri"
|
|
decodeResult res @?= "\"\n1 \n2 3 \n4 5 6 7 \n8 11 10 9 12 \""
|
|
]
|
|
|
|
decoding :: TestTree
|
|
decoding = testGroup "Decoding Tests"
|
|
[ testCase "Decode Leaf" $ do
|
|
decodeResult Leaf @?= "t"
|
|
|
|
, testCase "Decode list of non-ASCII numbers" $ do
|
|
let input = ofList [ofNumber 1, ofNumber 14, ofNumber 6]
|
|
decodeResult input @?= "[1, 14, 6]"
|
|
|
|
, testCase "Decode list of ASCII numbers as a string" $ do
|
|
let input = ofList [ofNumber 97, ofNumber 98, ofNumber 99]
|
|
decodeResult input @?= "\"abc\""
|
|
|
|
, testCase "Decode small number" $ do
|
|
decodeResult (ofNumber 42) @?= "42"
|
|
|
|
, testCase "Decode large number" $ do
|
|
decodeResult (ofNumber 9999) @?= "9999"
|
|
|
|
, testCase "Decode string in list" $ do
|
|
let input = ofList [ofString "hello", ofString "world"]
|
|
decodeResult input @?= "[\"hello\", \"world\"]"
|
|
|
|
, testCase "Decode mixed list with strings" $ do
|
|
let input = ofList [ofString "hello", ofNumber 42, ofString "world"]
|
|
decodeResult input @?= "[\"hello\", 42, \"world\"]"
|
|
|
|
, testCase "Decode nested lists with strings" $ do
|
|
let input = ofList [ofList [ofString "nested"], ofString "string"]
|
|
decodeResult input @?= "[[\"nested\"], \"string\"]"
|
|
] |