There seem to be two major test frameworks in Haskell. The first one, HUnit, is based on the xUnit family. Create test cases which assert various properties of the functions you're testing, bundle them into a test suite and run them.

foo :: (Num a) => a -> a -> a -> a

foo a b c = a * b + c

test1 = TestCase (assertEqual "* has higher precedence" 26 (foo 2 10 6))

tests = TestList [TestLabel "Foo test" test1]

-- From the REPL

*Main> runTestTT tests

Cases: 1 Tried: 1 Errors: 0 Failures: 0

Counts {cases = 1, tried = 1, errors = 0, failures = 0}

Tests like this always feel a bit smelly - the only way to verify the test is to write the code again twice. Whilst measure twice cut once works for carpentry, it doesn't feel right for programming...

Enter an alternative testing framework, QuickCheck. The idea is simple, instead of testing arbitrary assertions about your code, specify the invariants associated with your function and let QuickCheck see if it can generate a failing test case.

As a simple example, let's say we write a function to add two numbers together:

addNum :: (Num a) => a -> a -> a

addNum a b = a + b

prop_AddNum a b = (addNum a b) >= b && (addNum a b) >= a

We specify the invariant that if we add numbers together the result is bigger than either argument. Running Quick Check shows that this is (obviously wrong!) and gives an example set of arguments that fail the test.

*Main> quickCheck prop_AddNum

Falsifiable, after 5 tests:

-1

-2

The convention is that the invariants are usually specified as beginning with "prop_" in case you're wondering where the weird naming comes from.

QuickCheck generates random instances satisfying the types and validates the properties. Generators exist for the basic types and can be extended to your own.

Taking an example from the ray tracing functions we can specify an invariant that the distance between any two points is constant after a linear transform.

square :: (Num a) => a -> a

square x = x * x

distance :: Point -> Point -> Float

distance p1 p2 = sqrt(square ((x p1)-(x p2)) + square ((y p1)-(y p2)))

prop_distance :: Point -> Point -> Float -> Float -> Bool

prop_distance p1 p2 d1 d2 = 0.001 > abs (distance p1 p2 -

distance (Point ((x p1) + d1) ((y p1) + d2))

(Point ((x p2) + d1) ((y p2) + d2)))

Note that the

`abs`

is just to deal with rounding errors that occur when dealing with floating point types results from the square root. The code won't compile as is, because QuickCheck doesn't know how to generate Point objects. We can solve this problem by creating an instance of `Arbitrary`

specialized (is that the right word?) for Point types.

instance Arbitrary Point where

arbitrary = do

x <- choose(1,1000) :: Gen Float

y <- choose(1,1000) :: Gen Float

return (Point x y)

`do`

is used to provide sequencing of statements. We can now run quickCheck and verify that the invariant holds.

*Main> quickCheck prop_distance

OK, passed 100 tests.

I'm still not quite understanding some aspects of this (e.g. why can't I write

`Point choose(1,1000) choose(1,1000)`

instead of sequencing?), but this is a pretty neat way of writing tests and definitely gives me further reason to try and understand Haskell in more depth.