257 lines
9.4 KiB
Elm
257 lines
9.4 KiB
Elm
module Test.Tools.RationalOrder exposing (..)
|
|
|
|
import Expect
|
|
import Fuzz exposing (Fuzzer)
|
|
import Internal.Tools.RationalOrder as RO exposing (RationalOrder(..))
|
|
import Test exposing (..)
|
|
|
|
|
|
fuzzer : Fuzzer RationalOrder
|
|
fuzzer =
|
|
Fuzz.map2 With Fuzz.int (Fuzz.lazy (\_ -> Fuzz.maybe fuzzer))
|
|
|
|
|
|
twoUnequal : Fuzzer ( RationalOrder, RationalOrder )
|
|
twoUnequal =
|
|
fuzzer
|
|
|> Fuzz.andThen
|
|
(\o ->
|
|
Fuzz.map2
|
|
(\o1 o2 ->
|
|
if RO.compare o1 o2 == LT then
|
|
( o1, o2 )
|
|
|
|
else
|
|
( o2, o1 )
|
|
)
|
|
(Fuzz.constant o)
|
|
(Fuzz.filter ((/=) o) fuzzer)
|
|
)
|
|
|
|
|
|
suite : Test
|
|
suite =
|
|
describe "RationalOrder"
|
|
[ describe "Semantic truths"
|
|
[ describe "After is always greater"
|
|
[ fuzz fuzzer
|
|
"Forwards"
|
|
(\o ->
|
|
Expect.equal LT (RO.compare o (RO.after o))
|
|
)
|
|
, fuzz fuzzer
|
|
"Backwards"
|
|
(\o ->
|
|
Expect.equal GT (RO.compare (RO.after o) o)
|
|
)
|
|
]
|
|
, describe "Before is always lesser"
|
|
[ fuzz fuzzer
|
|
"Forwards"
|
|
(\o ->
|
|
Expect.equal GT (RO.compare o (RO.before o))
|
|
)
|
|
, fuzz fuzzer
|
|
"Backwards"
|
|
(\o ->
|
|
Expect.equal LT (RO.compare (RO.before o) o)
|
|
)
|
|
]
|
|
, describe "Two unequal == two unequal"
|
|
[ fuzz twoUnequal
|
|
"Forwards"
|
|
(\( small, big ) ->
|
|
Expect.equal LT (RO.compare small big)
|
|
)
|
|
, fuzz twoUnequal
|
|
"Backwards"
|
|
(\( small, big ) ->
|
|
Expect.equal GT (RO.compare big small)
|
|
)
|
|
]
|
|
, describe "compare"
|
|
[ fuzz2 fuzzer
|
|
fuzzer
|
|
"EQ iff same value"
|
|
(\o1 o2 ->
|
|
Expect.equal
|
|
(o1 == o2)
|
|
(RO.compare o1 o2 == EQ)
|
|
)
|
|
, fuzz2 fuzzer
|
|
fuzzer
|
|
"LT iff opposite GT"
|
|
(\o1 o2 ->
|
|
Expect.equal
|
|
(RO.compare o1 o2 == LT)
|
|
(RO.compare o2 o1 == GT)
|
|
)
|
|
]
|
|
, describe "Between is always between"
|
|
[ fuzz twoUnequal
|
|
"Less than first - forwards"
|
|
(\( small, big ) ->
|
|
RO.between small big
|
|
|> RO.compare small
|
|
|> Expect.equal LT
|
|
)
|
|
, fuzz twoUnequal
|
|
"Less than first - backwards"
|
|
(\( small, big ) ->
|
|
small
|
|
|> RO.compare (RO.between small big)
|
|
|> Expect.equal GT
|
|
)
|
|
, fuzz twoUnequal
|
|
"Less than second - forwards"
|
|
(\( small, big ) ->
|
|
RO.between small big
|
|
|> RO.compare big
|
|
|> Expect.equal GT
|
|
)
|
|
, fuzz twoUnequal
|
|
"Less than second - backwards"
|
|
(\( small, big ) ->
|
|
big
|
|
|> RO.compare (RO.between small big)
|
|
|> Expect.equal LT
|
|
)
|
|
]
|
|
]
|
|
, describe "Between creates between"
|
|
[ test "With 0 Nothing <--> With 1 Nothing"
|
|
(\() ->
|
|
RO.between (With 0 Nothing) (With 1 Nothing)
|
|
|> Expect.equal (With 0 (Just (With 0 Nothing)))
|
|
)
|
|
, test "With 1 Nothing <--> With 0 Nothing"
|
|
(\() ->
|
|
RO.between (With 1 Nothing) (With 0 Nothing)
|
|
|> Expect.equal (With 0 (Just (With 0 Nothing)))
|
|
)
|
|
, test "With 0 is filled between With 1 Nothing"
|
|
(\() ->
|
|
With 0 Nothing
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> Expect.equal (With 0 (Just (With 5 Nothing)))
|
|
)
|
|
, test "Will start counting high level as soon as possible"
|
|
(\() ->
|
|
With 0 Nothing
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> Expect.equal (With 2 Nothing)
|
|
)
|
|
, test "Will start counting high level, then return lower level"
|
|
(\() ->
|
|
With 0 Nothing
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 1 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> RO.between (With 5 Nothing)
|
|
|> Expect.equal (With 4 (Just (With 6 Nothing)))
|
|
)
|
|
, fuzz2 fuzzer
|
|
fuzzer
|
|
"Between is commutative"
|
|
(\o1 o2 ->
|
|
Expect.equal (RO.between o1 o2) (RO.between o2 o1)
|
|
)
|
|
]
|
|
, describe "After"
|
|
[ fuzz Fuzz.int
|
|
"One more - level 1"
|
|
(\a ->
|
|
Expect.equal
|
|
(RO.after <| With a Nothing)
|
|
(With (a + 1) Nothing)
|
|
)
|
|
, fuzz2 Fuzz.int
|
|
Fuzz.int
|
|
"One more - level 2"
|
|
(\a b ->
|
|
Expect.equal
|
|
(RO.after <| With a <| Just <| With b Nothing)
|
|
(With (a + 1) Nothing)
|
|
)
|
|
, fuzz3 Fuzz.int
|
|
Fuzz.int
|
|
Fuzz.int
|
|
"One more - level 3"
|
|
(\a b c ->
|
|
Expect.equal
|
|
(RO.after <| With a <| Just <| With b <| Just <| With c Nothing)
|
|
(With (a + 1) Nothing)
|
|
)
|
|
]
|
|
, describe "Before"
|
|
[ fuzz Fuzz.int
|
|
"One less - level 1"
|
|
(\a ->
|
|
Expect.equal
|
|
(RO.before <| With a Nothing)
|
|
(With (a - 1) Nothing)
|
|
)
|
|
, fuzz2 Fuzz.int
|
|
Fuzz.int
|
|
"One less - level 2"
|
|
(\a b ->
|
|
Expect.equal
|
|
(RO.before <| With a <| Just <| With b Nothing)
|
|
(With (a - 1) Nothing)
|
|
)
|
|
, fuzz3 Fuzz.int
|
|
Fuzz.int
|
|
Fuzz.int
|
|
"One less - level 3"
|
|
(\a b c ->
|
|
Expect.equal
|
|
(RO.before <| With a <| Just <| With b <| Just <| With c Nothing)
|
|
(With (a - 1) Nothing)
|
|
)
|
|
]
|
|
, describe "Compare vs. list compare"
|
|
[ fuzz2
|
|
(Fuzz.listOfLengthBetween 1 32 Fuzz.int)
|
|
(Fuzz.listOfLengthBetween 1 32 Fuzz.int)
|
|
"Compares the same between normal lists and orders"
|
|
(\l1 l2 ->
|
|
Expect.equal
|
|
(Just <| Basics.compare l1 l2)
|
|
(Maybe.map2 RO.compare (RO.fromList l1) (RO.fromList l2))
|
|
)
|
|
, fuzz2 fuzzer
|
|
fuzzer
|
|
"Compares the same when converted to list"
|
|
(\o1 o2 ->
|
|
Expect.equal
|
|
(RO.compare o1 o2)
|
|
(Basics.compare (RO.toList o1) (RO.toList o2))
|
|
)
|
|
]
|
|
]
|