-- | A model for unit testing

module Hydra.Testing where

import qualified Hydra.Core as Core
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

-- | One of two evaluation styles: eager or lazy
data EvaluationStyle = 
  EvaluationStyleEager  |
  EvaluationStyleLazy 
  deriving (EvaluationStyle -> EvaluationStyle -> Bool
(EvaluationStyle -> EvaluationStyle -> Bool)
-> (EvaluationStyle -> EvaluationStyle -> Bool)
-> Eq EvaluationStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EvaluationStyle -> EvaluationStyle -> Bool
== :: EvaluationStyle -> EvaluationStyle -> Bool
$c/= :: EvaluationStyle -> EvaluationStyle -> Bool
/= :: EvaluationStyle -> EvaluationStyle -> Bool
Eq, Eq EvaluationStyle
Eq EvaluationStyle =>
(EvaluationStyle -> EvaluationStyle -> Ordering)
-> (EvaluationStyle -> EvaluationStyle -> Bool)
-> (EvaluationStyle -> EvaluationStyle -> Bool)
-> (EvaluationStyle -> EvaluationStyle -> Bool)
-> (EvaluationStyle -> EvaluationStyle -> Bool)
-> (EvaluationStyle -> EvaluationStyle -> EvaluationStyle)
-> (EvaluationStyle -> EvaluationStyle -> EvaluationStyle)
-> Ord EvaluationStyle
EvaluationStyle -> EvaluationStyle -> Bool
EvaluationStyle -> EvaluationStyle -> Ordering
EvaluationStyle -> EvaluationStyle -> EvaluationStyle
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EvaluationStyle -> EvaluationStyle -> Ordering
compare :: EvaluationStyle -> EvaluationStyle -> Ordering
$c< :: EvaluationStyle -> EvaluationStyle -> Bool
< :: EvaluationStyle -> EvaluationStyle -> Bool
$c<= :: EvaluationStyle -> EvaluationStyle -> Bool
<= :: EvaluationStyle -> EvaluationStyle -> Bool
$c> :: EvaluationStyle -> EvaluationStyle -> Bool
> :: EvaluationStyle -> EvaluationStyle -> Bool
$c>= :: EvaluationStyle -> EvaluationStyle -> Bool
>= :: EvaluationStyle -> EvaluationStyle -> Bool
$cmax :: EvaluationStyle -> EvaluationStyle -> EvaluationStyle
max :: EvaluationStyle -> EvaluationStyle -> EvaluationStyle
$cmin :: EvaluationStyle -> EvaluationStyle -> EvaluationStyle
min :: EvaluationStyle -> EvaluationStyle -> EvaluationStyle
Ord, ReadPrec [EvaluationStyle]
ReadPrec EvaluationStyle
Int -> ReadS EvaluationStyle
ReadS [EvaluationStyle]
(Int -> ReadS EvaluationStyle)
-> ReadS [EvaluationStyle]
-> ReadPrec EvaluationStyle
-> ReadPrec [EvaluationStyle]
-> Read EvaluationStyle
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EvaluationStyle
readsPrec :: Int -> ReadS EvaluationStyle
$creadList :: ReadS [EvaluationStyle]
readList :: ReadS [EvaluationStyle]
$creadPrec :: ReadPrec EvaluationStyle
readPrec :: ReadPrec EvaluationStyle
$creadListPrec :: ReadPrec [EvaluationStyle]
readListPrec :: ReadPrec [EvaluationStyle]
Read, Int -> EvaluationStyle -> ShowS
[EvaluationStyle] -> ShowS
EvaluationStyle -> String
(Int -> EvaluationStyle -> ShowS)
-> (EvaluationStyle -> String)
-> ([EvaluationStyle] -> ShowS)
-> Show EvaluationStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EvaluationStyle -> ShowS
showsPrec :: Int -> EvaluationStyle -> ShowS
$cshow :: EvaluationStyle -> String
show :: EvaluationStyle -> String
$cshowList :: [EvaluationStyle] -> ShowS
showList :: [EvaluationStyle] -> ShowS
Show)

_EvaluationStyle :: Name
_EvaluationStyle = (String -> Name
Core.Name String
"hydra/testing.EvaluationStyle")

_EvaluationStyle_eager :: Name
_EvaluationStyle_eager = (String -> Name
Core.Name String
"eager")

_EvaluationStyle_lazy :: Name
_EvaluationStyle_lazy = (String -> Name
Core.Name String
"lazy")

-- | A simple test case with an input and an expected output
data TestCase = 
  TestCase {
    TestCase -> Maybe String
testCaseDescription :: (Maybe String),
    TestCase -> EvaluationStyle
testCaseEvaluationStyle :: EvaluationStyle,
    TestCase -> Term
testCaseInput :: Core.Term,
    TestCase -> Term
testCaseOutput :: Core.Term}
  deriving (TestCase -> TestCase -> Bool
(TestCase -> TestCase -> Bool)
-> (TestCase -> TestCase -> Bool) -> Eq TestCase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TestCase -> TestCase -> Bool
== :: TestCase -> TestCase -> Bool
$c/= :: TestCase -> TestCase -> Bool
/= :: TestCase -> TestCase -> Bool
Eq, Eq TestCase
Eq TestCase =>
(TestCase -> TestCase -> Ordering)
-> (TestCase -> TestCase -> Bool)
-> (TestCase -> TestCase -> Bool)
-> (TestCase -> TestCase -> Bool)
-> (TestCase -> TestCase -> Bool)
-> (TestCase -> TestCase -> TestCase)
-> (TestCase -> TestCase -> TestCase)
-> Ord TestCase
TestCase -> TestCase -> Bool
TestCase -> TestCase -> Ordering
TestCase -> TestCase -> TestCase
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TestCase -> TestCase -> Ordering
compare :: TestCase -> TestCase -> Ordering
$c< :: TestCase -> TestCase -> Bool
< :: TestCase -> TestCase -> Bool
$c<= :: TestCase -> TestCase -> Bool
<= :: TestCase -> TestCase -> Bool
$c> :: TestCase -> TestCase -> Bool
> :: TestCase -> TestCase -> Bool
$c>= :: TestCase -> TestCase -> Bool
>= :: TestCase -> TestCase -> Bool
$cmax :: TestCase -> TestCase -> TestCase
max :: TestCase -> TestCase -> TestCase
$cmin :: TestCase -> TestCase -> TestCase
min :: TestCase -> TestCase -> TestCase
Ord, ReadPrec [TestCase]
ReadPrec TestCase
Int -> ReadS TestCase
ReadS [TestCase]
(Int -> ReadS TestCase)
-> ReadS [TestCase]
-> ReadPrec TestCase
-> ReadPrec [TestCase]
-> Read TestCase
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TestCase
readsPrec :: Int -> ReadS TestCase
$creadList :: ReadS [TestCase]
readList :: ReadS [TestCase]
$creadPrec :: ReadPrec TestCase
readPrec :: ReadPrec TestCase
$creadListPrec :: ReadPrec [TestCase]
readListPrec :: ReadPrec [TestCase]
Read, Int -> TestCase -> ShowS
[TestCase] -> ShowS
TestCase -> String
(Int -> TestCase -> ShowS)
-> (TestCase -> String) -> ([TestCase] -> ShowS) -> Show TestCase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TestCase -> ShowS
showsPrec :: Int -> TestCase -> ShowS
$cshow :: TestCase -> String
show :: TestCase -> String
$cshowList :: [TestCase] -> ShowS
showList :: [TestCase] -> ShowS
Show)

_TestCase :: Name
_TestCase = (String -> Name
Core.Name String
"hydra/testing.TestCase")

_TestCase_description :: Name
_TestCase_description = (String -> Name
Core.Name String
"description")

_TestCase_evaluationStyle :: Name
_TestCase_evaluationStyle = (String -> Name
Core.Name String
"evaluationStyle")

_TestCase_input :: Name
_TestCase_input = (String -> Name
Core.Name String
"input")

_TestCase_output :: Name
_TestCase_output = (String -> Name
Core.Name String
"output")

-- | A collection of test cases with a name and optional description
data TestGroup = 
  TestGroup {
    TestGroup -> String
testGroupName :: String,
    TestGroup -> Maybe String
testGroupDescription :: (Maybe String),
    TestGroup -> [TestGroup]
testGroupSubgroups :: [TestGroup],
    TestGroup -> [TestCase]
testGroupCases :: [TestCase]}
  deriving (TestGroup -> TestGroup -> Bool
(TestGroup -> TestGroup -> Bool)
-> (TestGroup -> TestGroup -> Bool) -> Eq TestGroup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TestGroup -> TestGroup -> Bool
== :: TestGroup -> TestGroup -> Bool
$c/= :: TestGroup -> TestGroup -> Bool
/= :: TestGroup -> TestGroup -> Bool
Eq, Eq TestGroup
Eq TestGroup =>
(TestGroup -> TestGroup -> Ordering)
-> (TestGroup -> TestGroup -> Bool)
-> (TestGroup -> TestGroup -> Bool)
-> (TestGroup -> TestGroup -> Bool)
-> (TestGroup -> TestGroup -> Bool)
-> (TestGroup -> TestGroup -> TestGroup)
-> (TestGroup -> TestGroup -> TestGroup)
-> Ord TestGroup
TestGroup -> TestGroup -> Bool
TestGroup -> TestGroup -> Ordering
TestGroup -> TestGroup -> TestGroup
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TestGroup -> TestGroup -> Ordering
compare :: TestGroup -> TestGroup -> Ordering
$c< :: TestGroup -> TestGroup -> Bool
< :: TestGroup -> TestGroup -> Bool
$c<= :: TestGroup -> TestGroup -> Bool
<= :: TestGroup -> TestGroup -> Bool
$c> :: TestGroup -> TestGroup -> Bool
> :: TestGroup -> TestGroup -> Bool
$c>= :: TestGroup -> TestGroup -> Bool
>= :: TestGroup -> TestGroup -> Bool
$cmax :: TestGroup -> TestGroup -> TestGroup
max :: TestGroup -> TestGroup -> TestGroup
$cmin :: TestGroup -> TestGroup -> TestGroup
min :: TestGroup -> TestGroup -> TestGroup
Ord, ReadPrec [TestGroup]
ReadPrec TestGroup
Int -> ReadS TestGroup
ReadS [TestGroup]
(Int -> ReadS TestGroup)
-> ReadS [TestGroup]
-> ReadPrec TestGroup
-> ReadPrec [TestGroup]
-> Read TestGroup
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TestGroup
readsPrec :: Int -> ReadS TestGroup
$creadList :: ReadS [TestGroup]
readList :: ReadS [TestGroup]
$creadPrec :: ReadPrec TestGroup
readPrec :: ReadPrec TestGroup
$creadListPrec :: ReadPrec [TestGroup]
readListPrec :: ReadPrec [TestGroup]
Read, Int -> TestGroup -> ShowS
[TestGroup] -> ShowS
TestGroup -> String
(Int -> TestGroup -> ShowS)
-> (TestGroup -> String)
-> ([TestGroup] -> ShowS)
-> Show TestGroup
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TestGroup -> ShowS
showsPrec :: Int -> TestGroup -> ShowS
$cshow :: TestGroup -> String
show :: TestGroup -> String
$cshowList :: [TestGroup] -> ShowS
showList :: [TestGroup] -> ShowS
Show)

_TestGroup :: Name
_TestGroup = (String -> Name
Core.Name String
"hydra/testing.TestGroup")

_TestGroup_name :: Name
_TestGroup_name = (String -> Name
Core.Name String
"name")

_TestGroup_description :: Name
_TestGroup_description = (String -> Name
Core.Name String
"description")

_TestGroup_subgroups :: Name
_TestGroup_subgroups = (String -> Name
Core.Name String
"subgroups")

_TestGroup_cases :: Name
_TestGroup_cases = (String -> Name
Core.Name String
"cases")