{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TupleSections #-}
module Tests.Sequence (sequenceTests) where
import Control.Applicative
import Control.Comonad
import Control.Monad
import Data.Bifunctor
import Data.Functor.Identity
import Data.Ord
import Data.Sequence (Seq(..))
import Data.Sequence.NonEmpty (NESeq(..))
import Data.Tuple
import Hedgehog
import Test.Tasty
import Tests.Util
import qualified Data.Foldable as F
import qualified Data.List.NonEmpty as NE
import qualified Data.Semigroup.Foldable as F1
import qualified Data.Semigroup.Traversable as T1
import qualified Data.Sequence as Seq
import qualified Data.Sequence.NonEmpty as NESeq
import qualified Data.Sequence.NonEmpty.Internal as NESeq
import qualified Hedgehog.Gen as Gen
sequenceTests :: TestTree
sequenceTests = groupTree $$(discover)
prop_toSeqIso1 :: Property
prop_toSeqIso1 = property $ do
m0 <- forAll seqGen
tripping m0 NESeq.nonEmptySeq
(Identity . maybe Seq.empty NESeq.toSeq)
prop_toSeqIso2 :: Property
prop_toSeqIso2 = property $ do
m0 <- forAll $ Gen.maybe neSeqGen
tripping m0 (maybe Seq.empty NESeq.toSeq)
(Identity . NESeq.nonEmptySeq)
prop_read_show :: Property
prop_read_show = readShow neSeqGen
prop_read1_show1 :: Property
prop_read1_show1 = readShow1 neSeqGen
prop_show_show1 :: Property
prop_show_show1 = showShow1 neSeqGen
prop_cons :: Property
prop_cons = ttProp (GTVal :-> GTSeq :-> TTNESeq)
(:<|)
(:<||)
prop_snoc :: Property
prop_snoc = ttProp (GTSeq :-> GTVal :-> TTNESeq)
(:|>)
(:||>)
prop_insertSeqAt :: Property
prop_insertSeqAt = ttProp (GTIntKey :-> GTVal :-> GTSeq :-> TTNESeq)
Seq.insertAt
NESeq.insertSeqAt
prop_singleton :: Property
prop_singleton = ttProp (GTVal :-> TTNESeq)
Seq.singleton
NESeq.singleton
prop_consNE :: Property
prop_consNE = ttProp (GTVal :-> GTNESeq :-> TTNESeq)
(Seq.<|)
(NESeq.<|)
prop_snocNE :: Property
prop_snocNE = ttProp (GTNESeq :-> GTVal :-> TTNESeq)
(Seq.|>)
(NESeq.|>)
prop_append :: Property
prop_append = ttProp (GTNESeq :-> GTNESeq :-> TTNESeq)
(Seq.><)
(NESeq.><)
prop_appendL :: Property
prop_appendL = ttProp (GTNESeq :-> GTSeq :-> TTNESeq)
(Seq.><)
(NESeq.|><)
prop_appendR :: Property
prop_appendR = ttProp (GTSeq :-> GTNESeq :-> TTNESeq)
(Seq.><)
(NESeq.><|)
prop_fromList :: Property
prop_fromList = ttProp (GTNEList Nothing GTVal :-> TTNESeq)
Seq.fromList
NESeq.fromList
prop_fromFunction :: Property
prop_fromFunction = ttProp (GTSize :-> gf1 valGen :?> TTNESeq)
(Seq.fromFunction . (+ 1))
(NESeq.fromFunction . (+ 1))
prop_replicate :: Property
prop_replicate = ttProp (GTSize :-> GTVal :-> TTNESeq)
(Seq.replicate . (+ 1))
(NESeq.replicate . (+ 1))
prop_replicateA :: Property
prop_replicateA = ttProp (GTSize :-> GTVal :-> TTBazaar GTVal TTNESeq TTVal)
(\i x -> Seq.replicateA (i + 1) (x `More` Done id))
(\i x -> NESeq.replicateA (i + 1) (x `More` Done id))
prop_replicateA1 :: Property
prop_replicateA1 = ttProp (GTSize :-> GTVal :-> TTBazaar GTVal TTNESeq TTVal)
(\i x -> Seq.replicateA (i + 1) (x `More` Done id))
(\i x -> NESeq.replicateA1 (i + 1) (x `More` Done id))
prop_cycleTaking :: Property
prop_cycleTaking = ttProp (GTSize :-> GTNESeq :-> TTNESeq)
(Seq.cycleTaking . (* 5) . (+ 1))
(NESeq.cycleTaking . (* 5) . (+ 1))
prop_iterateN :: Property
prop_iterateN = ttProp (GTSize :-> gf1 valGen :?> GTVal :-> TTNESeq)
(Seq.iterateN . (+ 1))
(NESeq.iterateN . (+ 1))
prop_unfoldr :: Property
prop_unfoldr = ttProp ( GTSize
:-> gf1 ((,) <$> valGen <*> Gen.maybe intKeyGen)
:?> GTIntKey
:-> TTNESeqList
)
(\i f -> NE.unfoldr (limiter f) . (i,))
(\i f -> NESeq.unfoldr (limiter f) . (i,))
prop_unfoldl :: Property
prop_unfoldl = ttProp ( GTSize
:-> gf1 ((,) <$> valGen <*> Gen.maybe intKeyGen)
:?> GTIntKey
:-> TTNESeqList
)
(\i f -> NE.reverse . NE.unfoldr ( limiter f) . (i,))
(\i f -> NESeq.unfoldl (swap . limiter f) . (i,))
limiter
:: (a -> (b, Maybe a))
-> (Int, a)
-> (b, Maybe (Int, a))
limiter f (n, x) = second (go =<<) $ f x
where
go y
| n <= 0 = Nothing
| otherwise = Just (n - 1, y)
prop_head :: Property
prop_head = ttProp (GTNESeq :-> TTMaybe TTVal)
(\case x :<| _ -> Just x; Empty -> Nothing)
(Just . NESeq.head)
prop_tail :: Property
prop_tail = ttProp (GTNESeq :-> TTMaybe TTOther)
(\case _ :<| xs -> Just xs; Empty -> Nothing)
(Just . NESeq.tail)
prop_last :: Property
prop_last = ttProp (GTNESeq :-> TTMaybe TTVal)
(\case _ :|> x -> Just x; Empty -> Nothing)
(Just . NESeq.last)
prop_init :: Property
prop_init = ttProp (GTNESeq :-> TTMaybe TTOther)
(\case xs :|> _ -> Just xs; Empty -> Nothing)
(Just . NESeq.init)
prop_length :: Property
prop_length = ttProp (GTNESeq :-> TTOther)
Seq.length
NESeq.length
prop_scanl :: Property
prop_scanl = ttProp (gf2 valGen :?> GTVal :-> GTNESeq :-> TTNESeq)
Seq.scanl
NESeq.scanl
prop_scanl1 :: Property
prop_scanl1 = ttProp (gf2 valGen :?> GTNESeq :-> TTNESeq)
Seq.scanl1
NESeq.scanl1
prop_scanr :: Property
prop_scanr = ttProp (gf2 valGen :?> GTVal :-> GTNESeq :-> TTNESeq)
Seq.scanr
NESeq.scanr
prop_scanr1 :: Property
prop_scanr1 = ttProp (gf2 valGen :?> GTNESeq :-> TTNESeq)
Seq.scanl1
NESeq.scanl1
prop_tails :: Property
prop_tails = ttProp (GTNESeq :-> TTNESeq)
(Seq.filter (not . null) . Seq.tails)
(fmap NESeq.toSeq . NESeq.tails)
prop_inits :: Property
prop_inits = ttProp (GTNESeq :-> TTNESeq)
(Seq.filter (not . null) . Seq.inits)
(fmap NESeq.toSeq . NESeq.inits)
prop_chunksOf :: Property
prop_chunksOf = ttProp (GTSize :-> GTNESeq :-> TTNESeq)
(\i -> Seq.filter (not . null) . Seq.chunksOf (i + 1))
(\i -> fmap NESeq.toSeq . NESeq.chunksOf (i + 1))
prop_takeWhileL :: Property
prop_takeWhileL = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTOther)
Seq.takeWhileL
NESeq.takeWhileL
prop_takeWhileR :: Property
prop_takeWhileR = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTOther)
Seq.takeWhileR
NESeq.takeWhileR
prop_dropWhileL :: Property
prop_dropWhileL = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTOther)
Seq.dropWhileL
NESeq.dropWhileL
prop_dropWhileR :: Property
prop_dropWhileR = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTOther)
Seq.dropWhileR
NESeq.dropWhileR
prop_spanl :: Property
prop_spanl = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTThese TTNESeq TTNESeq)
Seq.spanl
NESeq.spanl
prop_spanr :: Property
prop_spanr = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTThese TTNESeq TTNESeq)
Seq.spanr
NESeq.spanr
prop_breakl :: Property
prop_breakl = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTThese TTNESeq TTNESeq)
Seq.breakl
NESeq.breakl
prop_breakr :: Property
prop_breakr = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTThese TTNESeq TTNESeq)
Seq.breakr
NESeq.breakr
prop_partition :: Property
prop_partition = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTThese TTNESeq TTNESeq)
Seq.partition
NESeq.partition
prop_filter :: Property
prop_filter = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTOther)
Seq.filter
NESeq.filter
prop_sort :: Property
prop_sort = ttProp (GTNESeq :-> TTNESeq)
Seq.sort
NESeq.sort
prop_sortBy :: Property
prop_sortBy = ttProp (gf1 valGen :?> GTNESeq :-> TTNESeq)
(Seq.sortBy . comparing)
(NESeq.sortBy . comparing)
prop_sortOn :: Property
prop_sortOn = ttProp (gf1 valGen :?> GTNESeq :-> TTNESeq)
NESeq.sortOnSeq
NESeq.sortOn
prop_unstableSort :: Property
prop_unstableSort = ttProp (GTNESeq :-> TTNESeq)
Seq.unstableSort
NESeq.unstableSort
prop_unstableSortBy :: Property
prop_unstableSortBy = ttProp (gf1 valGen :?> GTNESeq :-> TTNESeq)
(Seq.unstableSortBy . comparing)
(NESeq.unstableSortBy . comparing)
prop_unstableSortOn :: Property
prop_unstableSortOn = ttProp (gf1 valGen :?> GTNESeq :-> TTNESeq)
NESeq.unstableSortOnSeq
NESeq.unstableSortOn
prop_lookup :: Property
prop_lookup = ttProp (GTIntKey :-> GTNESeq :-> TTMaybe TTVal)
Seq.lookup
NESeq.lookup
prop_index :: Property
prop_index = ttProp (GTNESeq :-> GTIntKey :-> TTVal)
(\xs i -> xs `Seq.index` (i `mod` Seq.length xs ))
(\xs i -> xs `NESeq.index` (i `mod` NESeq.length xs))
prop_adjust :: Property
prop_adjust = ttProp (gf1 valGen :?> GTIntKey :-> GTNESeq :-> TTNESeq)
Seq.adjust
NESeq.adjust
prop_adjust' :: Property
prop_adjust' = ttProp (gf1 valGen :?> GTIntKey :-> GTNESeq :-> TTNESeq)
Seq.adjust'
NESeq.adjust'
prop_update :: Property
prop_update = ttProp (GTIntKey :-> GTVal :-> GTNESeq :-> TTNESeq)
Seq.update
NESeq.update
prop_take :: Property
prop_take = ttProp (GTIntKey :-> GTNESeq :-> TTOther)
Seq.take
NESeq.take
prop_drop :: Property
prop_drop = ttProp (GTIntKey :-> GTNESeq :-> TTOther)
Seq.drop
NESeq.drop
prop_insertAt :: Property
prop_insertAt = ttProp (GTIntKey :-> GTVal :-> GTNESeq :-> TTNESeq)
Seq.insertAt
NESeq.insertAt
prop_deleteAt :: Property
prop_deleteAt = ttProp (GTIntKey :-> GTNESeq :-> TTOther)
Seq.deleteAt
NESeq.deleteAt
prop_splitAt :: Property
prop_splitAt = ttProp (GTIntKey :-> GTNESeq :-> TTThese TTNESeq TTNESeq)
Seq.splitAt
NESeq.splitAt
prop_elemIndexL :: Property
prop_elemIndexL = ttProp (GTVal :-> GTNESeq :-> TTOther)
Seq.elemIndexL
NESeq.elemIndexL
prop_elemIndicesL :: Property
prop_elemIndicesL = ttProp (GTVal :-> GTNESeq :-> TTOther)
Seq.elemIndicesL
NESeq.elemIndicesL
prop_elemIndexR :: Property
prop_elemIndexR = ttProp (GTVal :-> GTNESeq :-> TTOther)
Seq.elemIndexR
NESeq.elemIndexR
prop_elemIndicesR :: Property
prop_elemIndicesR = ttProp (GTVal :-> GTNESeq :-> TTOther)
Seq.elemIndicesR
NESeq.elemIndicesR
prop_findIndexL :: Property
prop_findIndexL = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTOther)
Seq.findIndexL
NESeq.findIndexL
prop_findIndicesL :: Property
prop_findIndicesL = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTOther)
Seq.findIndicesL
NESeq.findIndicesL
prop_findIndexR :: Property
prop_findIndexR = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTOther)
Seq.findIndexR
NESeq.findIndexR
prop_findIndicesR :: Property
prop_findIndicesR = ttProp (gf1 Gen.bool :?> GTNESeq :-> TTOther)
Seq.findIndicesR
NESeq.findIndicesR
prop_foldMapWithIndex :: Property
prop_foldMapWithIndex = ttProp (gf2 valGen :?> GTNESeq :-> TTOther)
(\f -> Seq.foldMapWithIndex (\i -> (:[]) . f i))
(\f -> NESeq.foldMapWithIndex (\i -> (:[]) . f i))
prop_foldlWithIndex :: Property
prop_foldlWithIndex = ttProp (gf3 valGen :?> GTVal :-> GTNESeq :-> TTVal)
Seq.foldlWithIndex
NESeq.foldlWithIndex
prop_foldrWithIndex :: Property
prop_foldrWithIndex = ttProp (gf3 valGen :?> GTVal :-> GTNESeq :-> TTVal)
Seq.foldrWithIndex
NESeq.foldrWithIndex
prop_mapWithIndex :: Property
prop_mapWithIndex = ttProp (gf2 valGen :?> GTNESeq :-> TTNESeq)
Seq.mapWithIndex
NESeq.mapWithIndex
prop_traverseWithIndex :: Property
prop_traverseWithIndex = ttProp (gf2 valGen :?> GTNESeq :-> TTBazaar GTVal TTNESeq TTVal)
(\f -> Seq.traverseWithIndex (\k -> (`More` Done (f k))))
(\f -> NESeq.traverseWithIndex (\k -> (`More` Done (f k))))
prop_traverseWithIndex1 :: Property
prop_traverseWithIndex1 = ttProp (gf2 valGen :?> GTNESeq :-> TTBazaar GTVal TTNESeq TTVal)
(\f -> Seq.traverseWithIndex (\k -> (`More` Done (f k))))
(\f -> NESeq.traverseWithIndex1 (\k -> (`More` Done (f k))))
prop_reverse :: Property
prop_reverse = ttProp (GTNESeq :-> TTNESeq)
Seq.reverse
NESeq.reverse
prop_intersperse :: Property
prop_intersperse = ttProp (GTVal :-> GTNESeq :-> TTNESeq)
Seq.intersperse
NESeq.intersperse
prop_zip :: Property
prop_zip = ttProp (GTNESeq :-> GTNESeq :-> TTNESeq)
Seq.zip
NESeq.zip
prop_zipWith :: Property
prop_zipWith = ttProp (gf2 valGen :?> GTNESeq :-> GTNESeq :-> TTNESeq)
Seq.zipWith
NESeq.zipWith
prop_zip3 :: Property
prop_zip3 = ttProp (GTNESeq :-> GTNESeq :-> GTNESeq :-> TTNESeq)
Seq.zip3
NESeq.zip3
prop_zipWith3 :: Property
prop_zipWith3 = ttProp (gf3 valGen :?> GTNESeq :-> GTNESeq :-> GTNESeq :-> TTNESeq)
Seq.zipWith3
NESeq.zipWith3
prop_zip4 :: Property
prop_zip4 = ttProp (GTNESeq :-> GTNESeq :-> GTNESeq :-> GTNESeq :-> TTNESeq)
Seq.zip4
NESeq.zip4
prop_zipWith4 :: Property
prop_zipWith4 = ttProp (gf4 valGen :?> GTNESeq :-> GTNESeq :-> GTNESeq :-> GTNESeq :-> TTNESeq)
Seq.zipWith4
NESeq.zipWith4
prop_unzip :: Property
prop_unzip = ttProp (GTNESeq :-> GTNESeq :-> TTNESeq :*: TTNESeq)
(\xs -> NESeq.unzipSeq . Seq.zip xs)
(\xs -> NESeq.unzip . NESeq.zip xs)
prop_unzipWith :: Property
prop_unzipWith = ttProp ( gf1 ((,) <$> valGen <*> valGen)
:?> GTNESeq
:-> TTNESeq :*: TTNESeq
)
NESeq.unzipWithSeq
NESeq.unzipWith
prop_liftA2 :: Property
prop_liftA2 = ttProp (gf2 valGen :?> GTNESeq :-> GTNESeq :-> TTNESeq)
liftA2
liftA2
prop_liftM2 :: Property
prop_liftM2 = ttProp (gf2 valGen :?> GTNESeq :-> GTNESeq :-> TTNESeq)
liftM2
liftM2
prop_duplicate :: Property
prop_duplicate = ttProp (GTNESeqList :-> TTNESeqList)
duplicate
(fmap F1.toNonEmpty . duplicate)
prop_foldMap :: Property
prop_foldMap = ttProp (gf1 valGen :?> GTNESeq :-> TTOther)
(foldMap . fmap (:[]))
(foldMap . fmap (:[]))
prop_foldl :: Property
prop_foldl = ttProp (gf2 valGen :?> GTVal :-> GTNESeq :-> TTVal)
foldl
foldl
prop_foldr :: Property
prop_foldr = ttProp (gf2 valGen :?> GTVal :-> GTNESeq :-> TTVal)
foldr
foldr
prop_foldl' :: Property
prop_foldl' = ttProp (gf2 valGen :?> GTVal :-> GTNESeq :-> TTVal)
F.foldl'
F.foldl'
prop_foldr' :: Property
prop_foldr' = ttProp (gf2 valGen :?> GTVal :-> GTNESeq :-> TTVal)
F.foldr'
F.foldr'
prop_foldl1 :: Property
prop_foldl1 = ttProp (gf2 valGen :?> GTNESeq :-> TTVal)
foldl1
foldl1
prop_foldr1 :: Property
prop_foldr1 = ttProp (gf2 valGen :?> GTNESeq :-> TTVal)
foldr1
foldr1
prop_fold :: Property
prop_fold = ttProp (GTNESeq :-> TTVal)
F.fold
F.fold
prop_fold1 :: Property
prop_fold1 = ttProp (GTNESeq :-> TTVal)
F.fold
F1.fold1
prop_toList :: Property
prop_toList = ttProp (GTNESeq :-> TTOther)
F.toList
F.toList
prop_toNonEmpty :: Property
prop_toNonEmpty = ttProp (GTNESeq :-> TTNEList TTVal)
F.toList
F1.toNonEmpty
prop_sequenceA :: Property
prop_sequenceA = ttProp (GTNESeq :-> TTBazaar GTVal TTNESeq TTVal)
(sequenceA . fmap (`More` Done id))
(sequenceA . fmap (`More` Done id))
prop_sequence1 :: Property
prop_sequence1 = ttProp (GTNESeq :-> TTBazaar GTVal TTNESeq TTVal)
(sequenceA . fmap (`More` Done id))
(T1.sequence1 . fmap (`More` Done id))