stream-fusion-0.1: tests/Strictness/StreamListVsList.hs
--
-- Must have rules off, otherwise the fusion rules will replace the rhs
-- with the lhs, and we only end up testing lhs == lhs
--
import Prelude hiding (null)
import Strictness.Utils
import System.IO
import qualified Strictness.Monomorphic.StreamList as Test -- our stream implementation
import qualified Strictness.Monomorphic.List as Spec -- our list implementation
--
-- Data.Stream <=> Data.List.Stream
--
------------------------------------------------------------------------
-- * Basic interface
prop_append = Test.append `eq2` (Spec.++)
prop_head = Test.head `eq1` Spec.head
prop_last = Test.last `eq1` Spec.last
prop_tail = Test.tail `eq1` Spec.tail
prop_init = Test.init `eq1` Spec.init
prop_null = Test.null `eq1` Spec.null
prop_length = Test.length `eq1` Spec.length
------------------------------------------------------------------------
-- * List transformations
prop_map = Test.map `eq2` Spec.map
--prop_reverse = Test.reverse `eq1` Spec.reverse
prop_intersperse = Test.intersperse `eq2` Spec.intersperse
prop_intercalate = Test.intercalate `eq2` Spec.intercalate
--prop_transpose = Test.transpose `eq1` Spec.transpose
------------------------------------------------------------------------
-- * Reducing lists (folds)
prop_foldl = Test.foldl `eq3` Spec.foldl
prop_foldl' = Test.foldl' `eq3` Spec.foldl'
prop_foldl1 = Test.foldl1 `eq2` Spec.foldl1
prop_foldl1' = Test.foldl1' `eq2` Spec.foldl1'
prop_foldr = Test.foldr `eq3` Spec.foldr
prop_foldr1 = Test.foldr1 `eq2` Spec.foldr1
------------------------------------------------------------------------
-- ** Special folds
prop_concat = Test.concat `eq1` Spec.concat
prop_concatMap = Test.concatMap `eq2` Spec.concatMap
prop_and = Test.and `eq1` Spec.and
prop_or = Test.or `eq1` Spec.or
prop_any = Test.any `eq2` Spec.any
prop_all = Test.all `eq2` Spec.all
prop_sum = Test.sum `eq1` Spec.sum
prop_product = Test.product `eq1` Spec.product
prop_maximum = Test.maximum `eq1` Spec.maximum
prop_minimum = Test.minimum `eq1` Spec.minimum
------------------------------------------------------------------------
-- * Building lists
-- ** Scans
prop_scanl = Test.scanl `eq3` Spec.scanl
prop_scanl1 = Test.scanl1 `eq2` Spec.scanl1
--prop_scanr = Test.scanr `eq3` Spec.scanr
--prop_scanr1 = Test.scanr1 `eq2` Spec.scanr1
------------------------------------------------------------------------
-- ** Accumulating maps
--prop_mapAccumL = Test.mapAccumL `eq3` Spec.mapAccumL
--prop_mapAccumR = Test.mapAccumR `eq3` Spec.mapAccumR
------------------------------------------------------------------------
-- ** Infinite lists
prop_iterate = Test.iterate `eqfinite2` Spec.iterate
prop_repeat = Test.repeat `eqfinite1` Spec.repeat
prop_replicate = Test.replicate `eqfinite2` Spec.replicate
prop_cycle = Test.cycle `eqfinite1` Spec.cycle
------------------------------------------------------------------------
-- ** Unfolding
prop_unfoldr = Test.unfoldr `eqfinite2` Spec.unfoldr
------------------------------------------------------------------------
-- * Sublists
-- ** Extracting sublists
prop_take = Test.take `eq2` Spec.take
prop_drop = Test.drop `eq2` Spec.drop
prop_splitAt = Test.splitAt `eq2` Spec.splitAt
prop_takeWhile = Test.takeWhile `eq2` Spec.takeWhile
prop_dropWhile = Test.dropWhile `eq2` Spec.dropWhile
--prop_span = Test.span `eq2` Spec.span
--prop_break = Test.break `eq2` Spec.break
--prop_group = Test.group `eq1` Spec.group
--prop_inits = Test.inits `eq1` Spec.inits
--prop_tails = Test.tails `eq1` Spec.tails
------------------------------------------------------------------------
-- * Predicates
prop_isPrefixOf = Test.isPrefixOf `eq2` Spec.isPrefixOf
--prop_isSuffixOf = Test.isSuffixOf `eq2` Spec.isSuffixOf
--prop_isInfixOf = Test.isInfixOf `eq2` Spec.isInfixOf
------------------------------------------------------------------------
-- * Searching lists
-- ** Searching by equality
prop_elem = Test.elem `eq2` Spec.elem
--prop_notElem = Test.notElem `eq2` Spec.notElem
prop_lookup = Test.lookup `eq2` Spec.lookup
------------------------------------------------------------------------
-- ** Searching with a predicate
prop_find = Test.find `eq2` Spec.find
prop_filter = Test.filter `eq2` Spec.filter
--prop_partition = Test.partition `eq2` Spec.partition
------------------------------------------------------------------------
-- * Indexing lists
prop_index = (Test.!!) `eq2` (Spec.!!)
prop_elemIndex = Test.elemIndex `eq2` Spec.elemIndex
prop_elemIndices = Test.elemIndices `eq2` Spec.elemIndices
prop_findIndex = Test.findIndex `eq2` Spec.findIndex
prop_findIndices = Test.findIndices `eq2` Spec.findIndices
------------------------------------------------------------------------
-- * Zipping and unzipping lists
prop_zip = Test.zip `eq2` Spec.zip
prop_zip3 = Test.zip3 `eq3` Spec.zip3
prop_zip4 = Test.zip4 `eq4` Spec.zip4
--prop_zip5 = Test.zip5 `eq5` Spec.zip5
--prop_zip6 = Test.zip6 `eq6` Spec.zip6
--prop_zip7 = Test.zip7 `eq7` Spec.zip7
prop_zipWith = Test.zipWith `eq3` Spec.zipWith
prop_zipWith3 = Test.zipWith3 `eq4` Spec.zipWith3
prop_zipWith4 = Test.zipWith4 `eq5` Spec.zipWith4
--prop_zipWith5 = Test.zipWith5 `eq6` Spec.zipWith5
--prop_zipWith6 = Test.zipWith6 `eq7` Spec.zipWith6
--prop_zipWith7 = Test.zipWith7 `eq8` Spec.zipWith7
------------------------------------------------------------------------
prop_unzip = Test.unzip `eq1` Spec.unzip
--prop_unzip3 = Test.unzip3 `eq1` Spec.unzip3
--prop_unzip4 = Test.unzip4 `eq1` Spec.unzip4
--prop_unzip5 = Test.unzip5 `eq1` Spec.unzip5
--prop_unzip6 = Test.unzip6 `eq1` Spec.unzip6
--prop_unzip7 = Test.unzip7 `eq1` Spec.unzip7
------------------------------------------------------------------------
-- * Special lists
-- ** Functions on strings
--prop_lines = Test.lines `eq1` Spec.lines
--prop_words = Test.words `eq1` Spec.words
--prop_unlines = Test.unlines `eq1` Spec.unlines
--prop_unwords = Test.unwords `eq1` Spec.unwords
------------------------------------------------------------------------
-- ** \"Set\" operations
--prop_nub = Test.nub `eq1` Spec.nub
--prop_delete = Test.delete `eq2` Spec.delete
--prop_difference = (Test.\\) `eq2` (Spec.\\)
--prop_union = Test.union `eq2` Spec.union
--prop_intersect = Test.intersect `eq2` Spec.intersect
------------------------------------------------------------------------
-- ** Ordered lists
--prop_sort = Test.sort `eq1` Spec.sort
--prop_insert = Test.insert `eq2` Spec.insert
------------------------------------------------------------------------
-- * Generalized functions
-- ** The \"By\" operations
-- *** User-supplied equality (replacing an Eq context)
--prop_nubBy = Test.nubBy `eq2` Spec.nubBy
--prop_deleteBy = Test.deleteBy `eq3` Spec.deleteBy
--prop_deleteFirstsBy = Test.deleteFirstsBy `eq3` Spec.deleteFirstsBy
--prop_unionBy = Test.unionBy `eq3` Spec.unionBy
--prop_intersectBy = Test.intersectBy `eq3` Spec.intersectBy
--prop_groupBy = Test.groupBy `eq2` Spec.groupBy
------------------------------------------------------------------------
-- *** User-supplied comparison (replacing an Ord context)
--prop_sortBy = Test.sortBy `eq2` Spec.sortBy --need to generate total orders
prop_insertBy = Test.insertBy `eq3` Spec.insertBy
prop_maximumBy = Test.maximumBy `eq2` Spec.maximumBy
prop_minimumBy = Test.minimumBy `eq2` Spec.minimumBy
------------------------------------------------------------------------
-- * The \"generic\" operations
prop_genericLength = Test.genericLength `eq1` Spec.genericLength
prop_genericTake = Test.genericTake `eq2` Spec.genericTake
prop_genericDrop = Test.genericDrop `eq2` Spec.genericDrop
prop_genericSplitAt = Test.genericSplitAt `eq2` Spec.genericSplitAt
prop_genericIndex = Test.genericIndex `eq2` Spec.genericIndex
prop_genericReplicate = Test.genericReplicate `eqfinite2` Spec.genericReplicate
------------------------------------------------------------------------
main = do
hSetBuffering stdout NoBuffering
putStrLn "Testing Data.Stream <=> Data.List.Stream"
putStrLn "========================================\n"
runTests "Basic interface" opts
[run prop_append
,run prop_head
,run prop_last
,run prop_tail
,run prop_init
,run prop_null
,run prop_length
]
runTests "List transformations" opts
[run prop_map
-- ,run prop_reverse
,run prop_intersperse
,run prop_intercalate
-- ,run prop_transpose
]
runTests "Reducing lists (folds)" opts
[run prop_foldl
,run prop_foldl'
,run prop_foldl1
,run prop_foldl1'
,run prop_foldr
,run prop_foldr1
]
runTests "Special folds" opts
[run prop_concat
,run prop_concatMap
,run prop_and
,run prop_or
,run prop_any
,run prop_all
,run prop_sum
,run prop_product
,run prop_maximum
,run prop_minimum
]
runTests "Scans" opts
[run prop_scanl
,run prop_scanl1
-- ,run prop_scanr
-- ,run prop_scanr1
]
runTests "Accumulating maps" opts
[--run prop_mapAccumL
-- ,run prop_mapAccumR
]
runTests "Infinite lists" opts
[run prop_iterate
,run prop_repeat
,run prop_replicate
,run prop_cycle
]
runTests "Unfolding" opts
[run prop_unfoldr
]
runTests "Extracting sublists" opts
[run prop_take
,run prop_drop
,run prop_splitAt
,run prop_takeWhile
,run prop_dropWhile
-- ,run prop_span
-- ,run prop_break
-- ,run prop_group
-- ,run prop_inits
-- ,run prop_tails
]
runTests "Predicates" opts
[run prop_isPrefixOf
-- ,run prop_isSuffixOf
-- ,run prop_isInfixOf
]
runTests "Searching by equality" opts
[run prop_elem
-- ,run prop_notElem
,run prop_lookup
]
runTests "Searching by a predicate" opts
[run prop_find
,run prop_filter
-- ,run prop_partition
]
runTests "Indexing lists" opts
[run prop_index
,run prop_elemIndex
,run prop_elemIndices
,run prop_findIndex
,run prop_findIndices
]
runTests "Zipping" opts { testDepth = 6, maxTests = 100000 }
[run prop_zip
,run prop_zip3
,run prop_zip4
-- ,run prop_zip5
-- ,run prop_zip6
-- ,run prop_zip7
,run prop_zipWith
,run prop_zipWith3
,run prop_zipWith4
-- ,run prop_zipWith5
-- ,run prop_zipWith6
-- ,run prop_zipWith7
]
runTests "Unzipping" opts
[run prop_unzip
-- ,run prop_unzip3
-- ,run prop_unzip4
-- ,run prop_unzip5
-- ,run prop_unzip6
-- ,run prop_unzip7
]
-- runTests "Functions on strings" opts
-- [run prop_lines
-- ,run prop_words
-- ,run prop_unlines
-- ,run prop_unwords
-- ]
runTests "\"Set\" operations" opts
[--run prop_nub
--,run prop_delete
--,run prop_difference
--,run prop_union
--,run prop_intersect
]
runTests "Ordered lists" opts
[--run prop_sort
-- ,run prop_insert
]
runTests "Eq style \"By\" operations" opts
[--run prop_nubBy
-- ,run prop_deleteBy
-- ,run prop_deleteFirstsBy
-- ,run prop_unionBy
-- ,run prop_intersectBy
-- ,run prop_groupBy
]
runTests "Ord style \"By\" operations" opts
[--run prop_sortBy -- note issue here.
run prop_insertBy
,run prop_maximumBy
,run prop_minimumBy
]
runTests "The \"generic\" operations" opts
[run prop_genericLength
,run prop_genericTake
,run prop_genericDrop
,run prop_genericSplitAt
,run prop_genericIndex
,run prop_genericReplicate
]