I'm trying to do a property-based test for a chess game. I have set up the following typeclass
class Monad m => HasCheck m where
isCollision :: Coord -> m Bool
which checks if a given coordinate contains a collision or out of bounds.
Now I have a function that generates the moveset of allowed actions for a knight like the following
collisionKnightRule :: HasCheck m => Coord -> m (Set Coord)
collisionKnightRule =
Set.filterM isCollision . knightMoveSet
-- | Set of all moves, legal or not
knightMoveSet :: Coord -> Set Coord
knightMoveSet (x,y) =
Set.fromList
[ (x+2,y-1),(x+2,y+1),(x-2,y-1),(x-2,y+1)
, (x+1,y-2),(x+1,y+2),(x-1,y-2),(x-1,y+2)
]
knightMoves :: HasCheck m => Coord -> m (Set Coord)
knightMoves pos =
do let moveSet =
knightMoveSet pos
invalidMoves <- collisionKnightRule pos
return $ Set.difference moveSet invalidMoves
and an instance for the HasCheck class for an arbitrary coordinate
instance HasCheck Gen where
isCollision _ =
Quickcheck.arbitrary
and so afterwards to test this I want to ensure that the generated moveset is a proper subset of all possible moves.
knightSetProperty :: Piece.HasCheck Gen
=> (Int,Int)
-> Gen Bool
knightSetProperty position =
do moves <- Piece.knightMoves position
return $ moves `Set.isProperSubsetOf` (Piece.knightMoveSet position)
-- ... later on
it "Knight ruleset is subset" $
quickCheck knightSetProperty
Of course this fails because it could be that the knight can't move anywhere, which would mean that it's not a proper subset but the same set. However the error reported is not particularly helpful
*** Failed! Falsifiable (after 14 tests and 3 shrinks):
(0,0)
This is because quickcheck doesn't report the generated value of isCollision. Therefore I wonder, how can I make quickCheck report the generated value of isCollision?
Okay so I feel this should be solvable in another way. However I made the following solution that works inspired by the handler pattern.
I changed the HasCheck typeclass to a record, as follows:
data Handle = MakeHandle
{ isCollision :: Coord -> Bool
}
and then refactored all the code to use handle instead of HasCheck.
collisionKnightRule :: Handle -> Coord -> (Set Coord)
collisionKnightRule handle =
Set.filter (isCollision handle) . knightMoveSet
-- | Set of all moves, legal or not
knightMoveSet :: Coord -> Set Coord
knightMoveSet (x,y) =
Set.fromList
[ (x+2,y-1),(x+2,y+1),(x-2,y-1),(x-2,y+1)
, (x+1,y-2),(x+1,y+2),(x-1,y-2),(x-1,y+2)
]
-- | Set of illegal moves
knightRuleSet :: Handle -> Coord -> (Set Coord)
knightRuleSet =
collisionKnightRule
knightMoves :: Handle -> Coord -> (Set Coord)
knightMoves handle pos =
let
moveSet =
knightMoveSet pos
invalidMoves =
knightRuleSet handle pos
in
Set.difference moveSet invalidMoves
The disadvantage of this is I fear that for stateful code it can be easy to introduce an error where you pass in a handle that is out-of-date, I.E. having multiple sources of truths. An advantage is that this is probably easier for people new to Haskell to understand. We can now mock functions using the Quickcheck's Function typeclass and pass them as an argument to make a mockHandler:
knightSetProperty ::
Fun (Int,Int) Bool
-> (Int,Int)
-> Gen Bool
knightSetProperty (Fun _ isCollision) position =
let
handler =
Piece.MakeHandle isCollision
moveSet =
Piece.knightMoves handler position
in
return $ moveSet `Set.isProperSubsetOf` (Piece.knightMoveSet position)
Now this fails properly with a counterexample:
*** Failed! Falsifiable (after 53 tests and 74 shrinks):
{_->False}
(0,0)