-- -- 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 ]