测试返回错误的haskell函数

Question

Hi I have a similar to the following haskell function

test :: Int -> Bool
test 1  = error "shouldnt have been 1"
test 2  = error "shouldnt have been 2"
test 11 = error "shouldnt have been 11"
test 77 = error "shouldnt have been 77"
test _  = True

I have a testing scheme to test bad inputs to make sure they return the correct error

tc1 = test 1
tc2 = test 2
tc3 = test 11
tc4 = test 77

allTests = [tc1, tc2, tc3, tc4]

But the problem is that when I run allTests in ghci, I only get the first error. I would like to have a list of all the errors

How can this be done or some way I can catch the errors?

Answer 1

You could try to use catch from Control.Exception , but that's still an awkward way to achieve the goal.

It'd be better to use a pure data type to capture errors, as they're easier to compose and collect. Normally, you'd use Either for that, but in this particular case, the success case would carry no information, so the type would be Either String () , which is isomorphic to Maybe String . Rewriting test to return Maybe String is trivial:

test :: Int -> Maybe String
test 1  = Just "shouldnt have been 1"
test 2  = Just "shouldnt have been 2"
test 11 = Just "shouldnt have been 11"
test 77 = Just "shouldnt have been 77"
test _  = Nothing

tc1 = test 1
tc2 = test 2
tc3 = test 11
tc4 = test 77
tc5 = test 5

I added a tc5 value in order to demonstrate what happens when a test succeeds.

You can evaluate all of those test cases, but if you want only the failure cases, you can use catMaybes from Data.Maybe :

allTests = catMaybes [tc1, tc2, tc3, tc4, tc5]

Here's the result of running allTests :

*Q46376632> allTests
["shouldnt have been 1",
 "shouldnt have been 2",
 "shouldnt have been 11",
 "shouldnt have been 77"]

---

If you can't change the function you're testing, you can try something like the following, but it's hardly elegant:

tc1 = catch (print $ test 1) (\err -> print (err :: SomeException))
tc2 = catch (print $ test 2) (\err -> print (err :: SomeException))
tc3 = catch (print $ test 11) (\err -> print (err :: SomeException))
tc4 = catch (print $ test 77) (\err -> print (err :: SomeException))
tc5 = catch (print $ test 5) (\err -> print (err :: SomeException))

allTests = sequence_ [tc1, tc2, tc3, tc4, tc5]

When running it, you get output like this:

*Q46376632> allTests
shouldnt have been 1
CallStack (from HasCallStack):
  error, called at 46376632.hs:14:10 in main:Q46376632
shouldnt have been 2
CallStack (from HasCallStack):
  error, called at 46376632.hs:15:10 in main:Q46376632
shouldnt have been 11
CallStack (from HasCallStack):
  error, called at 46376632.hs:16:11 in main:Q46376632
shouldnt have been 77
CallStack (from HasCallStack):
  error, called at 46376632.hs:17:11 in main:Q46376632
True

At this point, you'd probably be better of using a proper testing framework.