6266c5d32f
Rename my //users directory and all places that refer to glittershark to grfn, including nix references and documentation. This may require some extra attention inside of gerrit's database after it lands to allow me to actually push things. Change-Id: I4728b7ec2c60024392c1c1fa6e0d4a59b3e266fa Reviewed-on: https://cl.tvl.fyi/c/depot/+/2933 Tested-by: BuildkiteCI Reviewed-by: tazjin <mail@tazj.in> Reviewed-by: lukegb <lukegb@tvl.fyi> Reviewed-by: glittershark <grfn@gws.fyi>
98 lines
3.9 KiB
Haskell
98 lines
3.9 KiB
Haskell
--------------------------------------------------------------------------------
|
|
module Xanthous.DataSpec (main, test) where
|
|
--------------------------------------------------------------------------------
|
|
import Test.Prelude hiding (Right, Left, Down, toList, all)
|
|
import Data.Group
|
|
import Data.Foldable (toList, all)
|
|
--------------------------------------------------------------------------------
|
|
import Xanthous.Data
|
|
--------------------------------------------------------------------------------
|
|
|
|
main :: IO ()
|
|
main = defaultMain test
|
|
|
|
test :: TestTree
|
|
test = testGroup "Xanthous.Data"
|
|
[ testGroup "Position"
|
|
[ testBatch $ monoid @Position mempty
|
|
, testProperty "group laws" $ \(pos :: Position) ->
|
|
pos <> invert pos == mempty && invert pos <> pos == mempty
|
|
, testGroup "stepTowards laws"
|
|
[ testProperty "takes only one step" $ \src tgt ->
|
|
src /= tgt ==>
|
|
isUnit (src `diffPositions` (src `stepTowards` tgt))
|
|
-- , testProperty "moves in the right direction" $ \src tgt ->
|
|
-- stepTowards src tgt == move (directionOf src tgt) src
|
|
]
|
|
, testProperty "directionOf laws" $ \pos dir ->
|
|
directionOf pos (move dir pos) == dir
|
|
, testProperty "diffPositions is add inverse" $ \(pos₁ :: Position) pos₂ ->
|
|
diffPositions pos₁ pos₂ == addPositions pos₁ (invert pos₂)
|
|
, testGroup "isUnit"
|
|
[ testProperty "double direction is never unit" $ \dir ->
|
|
not . isUnit $ move dir (asPosition dir)
|
|
, testCase "examples" $ do
|
|
isUnit (Position @Int 1 1) @? "not . isUnit $ Position 1 1"
|
|
isUnit (Position @Int 0 (-1)) @? "not . isUnit $ Position 0 (-1)"
|
|
(not . isUnit) (Position @Int 1 13) @? "isUnit $ Position 1 13"
|
|
]
|
|
]
|
|
|
|
, testGroup "Direction"
|
|
[ testProperty "opposite is involutive" $ \(dir :: Direction) ->
|
|
opposite (opposite dir) == dir
|
|
, testProperty "opposite provides inverse" $ \dir ->
|
|
invert (asPosition dir) === asPosition (opposite dir)
|
|
, testProperty "asPosition isUnit" $ \dir ->
|
|
dir /= Here ==> isUnit (asPosition dir)
|
|
, testGroup "Move"
|
|
[ testCase "Up" $ move Up mempty @?= Position @Int 0 (-1)
|
|
, testCase "Down" $ move Down mempty @?= Position @Int 0 1
|
|
, testCase "Left" $ move Left mempty @?= Position @Int (-1) 0
|
|
, testCase "Right" $ move Right mempty @?= Position @Int 1 0
|
|
, testCase "UpLeft" $ move UpLeft mempty @?= Position @Int (-1) (-1)
|
|
, testCase "UpRight" $ move UpRight mempty @?= Position @Int 1 (-1)
|
|
, testCase "DownLeft" $ move DownLeft mempty @?= Position @Int (-1) 1
|
|
, testCase "DownRight" $ move DownRight mempty @?= Position @Int 1 1
|
|
]
|
|
]
|
|
|
|
, testGroup "Corner"
|
|
[ testGroup "instance Opposite"
|
|
[ testProperty "involutive" $ \(corner :: Corner) ->
|
|
opposite (opposite corner) === corner
|
|
]
|
|
]
|
|
|
|
, testGroup "Edge"
|
|
[ testGroup "instance Opposite"
|
|
[ testProperty "involutive" $ \(edge :: Edge) ->
|
|
opposite (opposite edge) === edge
|
|
]
|
|
]
|
|
|
|
, testGroup "Box"
|
|
[ testGroup "boxIntersects"
|
|
[ testProperty "True" $ \dims ->
|
|
boxIntersects (Box @Word (V2 1 1) (V2 2 2))
|
|
(Box (V2 2 2) dims)
|
|
, testProperty "False" $ \dims ->
|
|
not $ boxIntersects (Box @Word (V2 1 1) (V2 2 2))
|
|
(Box (V2 4 2) dims)
|
|
]
|
|
]
|
|
|
|
, testGroup "Neighbors"
|
|
[ testGroup "rotations"
|
|
[ testProperty "always has the same members"
|
|
$ \(neighs :: Neighbors Int) ->
|
|
all (\ns -> sort (toList ns) == sort (toList neighs))
|
|
$ rotations neighs
|
|
, testProperty "all rotations have the same rotations"
|
|
$ \(neighs :: Neighbors Int) ->
|
|
let rots = rotations neighs
|
|
in all (\ns -> sort (toList $ rotations ns) == sort (toList rots))
|
|
rots
|
|
]
|
|
]
|
|
]
|