2019-12-30 17:31:56 +01:00
|
|
|
--------------------------------------------------------------------------------
|
2019-09-02 19:56:25 +02:00
|
|
|
module Xanthous.DataSpec (main, test) where
|
2019-12-30 17:31:56 +01:00
|
|
|
--------------------------------------------------------------------------------
|
2020-01-09 05:01:22 +01:00
|
|
|
import Test.Prelude hiding (Right, Left, Down, toList, all)
|
2019-08-31 19:17:27 +02:00
|
|
|
import Data.Group
|
2020-01-09 05:01:22 +01:00
|
|
|
import Data.Foldable (toList, all)
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
import Xanthous.Data
|
2019-12-30 17:31:56 +01:00
|
|
|
--------------------------------------------------------------------------------
|
2019-08-31 19:17:27 +02:00
|
|
|
|
|
|
|
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
|
2019-09-29 16:54:52 +02:00
|
|
|
, 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
|
2019-10-13 18:37:08 +02:00
|
|
|
, testProperty "diffPositions is add inverse" $ \(pos₁ :: Position) pos₂ ->
|
2019-09-29 16:54:52 +02:00
|
|
|
diffPositions pos₁ pos₂ == addPositions pos₁ (invert pos₂)
|
2019-10-06 19:13:00 +02:00
|
|
|
, testGroup "isUnit"
|
|
|
|
[ testProperty "double direction is never unit" $ \dir ->
|
|
|
|
not . isUnit $ move dir (asPosition dir)
|
|
|
|
, testCase "examples" $ do
|
2019-10-13 18:37:08 +02:00
|
|
|
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"
|
2019-10-06 19:13:00 +02:00
|
|
|
]
|
2019-08-31 19:17:27 +02:00
|
|
|
]
|
2019-12-30 17:31:56 +01:00
|
|
|
|
2019-08-31 19:17:27 +02:00
|
|
|
, testGroup "Direction"
|
|
|
|
[ testProperty "opposite is involutive" $ \(dir :: Direction) ->
|
|
|
|
opposite (opposite dir) == dir
|
|
|
|
, testProperty "opposite provides inverse" $ \dir ->
|
2019-12-30 17:31:56 +01:00
|
|
|
invert (asPosition dir) === asPosition (opposite dir)
|
2019-09-29 16:54:52 +02:00
|
|
|
, testProperty "asPosition isUnit" $ \dir ->
|
|
|
|
dir /= Here ==> isUnit (asPosition dir)
|
2019-08-31 19:17:27 +02:00
|
|
|
, testGroup "Move"
|
2020-01-09 05:01:22 +01:00
|
|
|
[ 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
|
2019-08-31 19:17:27 +02:00
|
|
|
]
|
|
|
|
]
|
2019-12-30 17:31:56 +01:00
|
|
|
|
|
|
|
, testGroup "Corner"
|
|
|
|
[ testGroup "instance Opposite"
|
2019-12-31 17:28:51 +01:00
|
|
|
[ testProperty "involutive" $ \(corner :: Corner) ->
|
2019-12-30 17:31:56 +01:00
|
|
|
opposite (opposite corner) === corner
|
|
|
|
]
|
|
|
|
]
|
|
|
|
|
|
|
|
, testGroup "Edge"
|
|
|
|
[ testGroup "instance Opposite"
|
2019-12-31 17:28:51 +01:00
|
|
|
[ testProperty "involutive" $ \(edge :: Edge) ->
|
2019-12-30 17:31:56 +01:00
|
|
|
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)
|
|
|
|
]
|
|
|
|
]
|
2020-01-09 05:01:22 +01:00
|
|
|
|
|
|
|
, 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
|
|
|
|
]
|
|
|
|
]
|
2021-06-19 21:40:11 +02:00
|
|
|
|
|
|
|
, testGroup "units"
|
|
|
|
[ testGroup "unit suffixes"
|
|
|
|
[ testCase "density"
|
2021-06-30 02:35:43 +02:00
|
|
|
$ tshow (10000 :: Grams `Per` Cubic Meters) @?= "10000.0 g/m³"
|
|
|
|
, testCase "volume"
|
|
|
|
$ tshow (5 :: Cubic Meters) @?= "5.0 m³"
|
|
|
|
, testCase "area"
|
|
|
|
$ tshow (5 :: Square Meters) @?= "5.0 m²"
|
2021-06-19 21:40:11 +02:00
|
|
|
]
|
|
|
|
]
|
2019-08-31 19:17:27 +02:00
|
|
|
]
|