stream-fusion-0.1: tests/Properties/StreamVsSpecStream.hs
{-# OPTIONS_GHC -fglasgow-exts #-}
--
-- Must have rules off, otherwise the fusion rules will replace the rhs
-- with the lhs, and we only end up testing lhs == lhs
--
import System.IO
import Properties.Utils hiding (eqnotnull1, eqnotnull2, eqnotnull3
,eqfinite1, eqfinite2, eqfinite1)
import qualified Properties.Monomorphic.Stream as Test -- stream functions
import qualified Properties.Monomorphic.SpecStream as Spec -- H98
import qualified Data.Stream as Stream (Stream(Stream), Step(..), null, take, length)
--
-- Data.Stream <=> Spec.List
--
------------------------------------------------------------------------
-- * Basic interface
prop_cons = Test.cons `eq2` Spec.cons
prop_snoc = Test.snoc `eq2` Spec.snoc
prop_append = Test.append `eq2` (Spec.++)
prop_head = Test.head `eqnotnull1` Spec.head
prop_last = Test.last `eqnotnull1` Spec.last
prop_tail = Test.tail `eqnotnull1` Spec.tail
prop_init = Test.init `eqnotnull1` 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 `eqnotnull2` Spec.foldl1 -- n.b.
prop_foldl1' = Test.foldl1' `eqnotnull2` Spec.foldl1' -- n.b.
prop_foldr = Test.foldr `eq3` Spec.foldr
prop_foldr1 = Test.foldr1 `eqnotnull2` 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 `eqnotnull1` Spec.maximum
prop_minimum = Test.minimum `eqnotnull1` Spec.minimum
------------------------------------------------------------------------
-- * Building lists
-- ** Scans
prop_scanl = Test.scanl `eq3` Spec.scanl
prop_scanl1 = Test.scanl1 `eq2` Spec.scanl1
{-
prop_scanr1 = Test.scanr1 `eq2` Spec.scanr1
prop_scanr = Test.scanr `eq3` Spec.scanr
-}
------------------------------------------------------------------------
-- ** 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 `eq2` Spec.replicate
prop_cycle = \x -> not (Stream.null x) ==>
(Test.cycle `eqfinite1` Spec.cycle) x
------------------------------------------------------------------------
-- ** 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 -- no specific implementation
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 = \xs n -> n >= 0 && n < Stream.length xs ==>
((Test.!!) `eq2` (Spec.!!)) xs n
prop_findIndex = Test.findIndex `eq2` Spec.findIndex
prop_elemIndex = Test.elemIndex `eq2` Spec.elemIndex
prop_elemIndices = Test.elemIndices `eq2` Spec.elemIndices
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_zipWith = Test.zipWith `eq3` Spec.zipWith
prop_zipWith3 = Test.zipWith3 `eq4` Spec.zipWith3
{-
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_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
-- hmm?
{-
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
prop_insertBy = Test.insertBy `eq3` Spec.insertBy
-}
prop_maximumBy = Test.maximumBy `eqnotnull2` Spec.maximumBy
prop_minimumBy = Test.minimumBy `eqnotnull2` Spec.minimumBy
------------------------------------------------------------------------
-- * The \"generic\" operations
prop_genericLength = Test.genericLength `eq1` Spec.genericLength
prop_genericTake = \i -> i >= I 0 ==>
(Test.genericTake `eq2` Spec.genericTake) i
prop_genericDrop = \i -> i >= I 0 ==>
(Test.genericDrop `eq2` Spec.genericDrop) i
prop_genericIndex = \xs i -> i >= I 0 && i < Spec.genericLength xs ==>
(Test.genericIndex `eq2` Spec.genericIndex) xs i
prop_genericSplitAt = \i -> i >= I 0 ==>
(Test.genericSplitAt `eq2` Spec.genericSplitAt) i
--prop_genericReplicate = \i -> i >= I 0 ==>
-- (Test.genericReplicate `eq2` Spec.genericReplicate) i
------------------------------------------------------------------------
main = do
hSetBuffering stdout NoBuffering
putStrLn "Testing: Data.Stream <=> Spec.List"
putStrLn "==================================\n"
runTests "Basic interface" opts
[run prop_cons
,run prop_snoc
,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_foldr
,run prop_foldl1
,run prop_foldl1'
,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-- no specific implementation
,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_findIndex
,run prop_elemIndex
,run prop_elemIndices
,run prop_findIndices
]
runTests "Zipping" opts
[
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_unlines
,run prop_lines
,run prop_words
,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_genericIndex
,run prop_genericSplitAt
-- ,run prop_genericReplicate
]
------------------------------------------------------------------------
eqnotnull1 f g = \x -> (not (Stream.null x)) ==> eq1 f g x
eqnotnull2 f g = \x y -> (not (Stream.null y)) ==> eq2 f g x y
eqnotnull3 f g = \x y z -> (not (Stream.null z)) ==> eq3 f g x y z
eqfinite1 f g = \x -> forAll arbitrary $ \n -> Stream.take n (f x) == Stream.take n (g x)
eqfinite2 f g = \x y -> forAll arbitrary $ \n -> Stream.take n (f x y) == Stream.take n (g x y)
eqfinite3 f g = \x y z -> forAll arbitrary $ \n -> Stream.take n (f x y z) == Stream.take n (g x y z)