// Mart Lubbers s4109503
// Charlie Gerhardus s3050009
module skeleton10

import qualified Text
from Text import class Text, instance Text String
import StdOverloaded, StdBool, StdString, StdEnum, StdList

:: TestState = {s :: Int, f :: Int, p :: [String]}
:: TestResult :== (Bool, [String])
:: Test :== TestState -> TestState

class Testable a | Eq, Ord, toString a

instance * Test where
	(*) t1 t2 = \st.let st`=t1 st in t2 st`

EqualTo :: a -> (a -> TestResult) | Testable a
EqualTo q = \a.(q == a, ["(EqualTo ",toString q,")"])

LessThen :: a -> (a -> TestResult) | Testable a
LessThen q = \a.(q < a, ["(LessThen ",toString q,")"])

Not :: (a -> TestResult) -> (a -> TestResult) | Testable a
Not x = \r.let (v,p)=x r in (not v, ["(Not ":p++[")"]])

Is :: (a -> TestResult) -> (a -> TestResult)
Is x = \r.let (v,p)=x r in (v, ["(Is ":p++[")"]])

Either :: (a -> TestResult) (a -> TestResult) -> (a -> TestResult)
Either x1 x2 = \r.let (v1,p1)=x1 r in let(v2,p2)=x2 r in
	(v1 || v2, ["(Either ":p1++[" ":p2++[")"]]])

Contains :: a -> ([a] -> TestResult) | Testable a
Contains x = \r.(isMember x r, ["(Contains ",toString x,")"])

ContainsString :: String -> (String -> TestResult)
ContainsString s = \r.('Text'.indexOf s r <> -1,
	["(ContainsString ",toString s,")"])

AssertThat :: String a (a -> TestResult) -> Test
AssertThat msg q t = \st=:{s,f,p}.case t q of
	(True, _) = {st & s=s+1}
	(_, p`) = {st & f=f+1, 
		p=p++[toString (f+1),". AssertThat ",msg," ":p`++["\n"]]}

test :: Test -> String
test t = 'Text'.concat ["passes=", toString s, ", fails=", toString f, "\n":p]
	where {f,s,p}=t {s=0, f=0, p=[]}

Start = test (a1 * a2 * a3 * a4 * a5 * a6)
	where
		a1 = AssertThat "(2*2)" (2*2) (Is (EqualTo (2+2)))
		a2 = AssertThat "(3*3)" (3*3) (Is (EqualTo (3+3)))
		a3 = AssertThat "(length [0..3])" (length [0..3]) (Not (EqualTo 4))
		a4 = AssertThat "[0..3]" [0..3] (Contains 2)
		a5 = AssertThat "[0..3]" [0..3] (Contains 7)
		a6 = AssertThat "[0..3]" [0..3] (Either (EqualTo [1]) (Contains 7))
/*
passes=2, fails=4
1. AssertThat (3*3) (Is (EqualTo 6))
2. AssertThat (length [0..3]) (Not (EqualTo 4))
3. AssertThat [0..3] (Contains 7)
4. AssertThat [0..3] (Either (EqualTo ) (Contains 7))
*/