{-# OPTIONS_GHC -fglasgow-exts #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE TypeOperators #-} -- -- 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 System.Environment import Properties.Utils import qualified Data.Array.Vector as Test import qualified Properties.Monomorphic.UVector as Test -- stream functions import qualified Properties.Monomorphic.Base as Spec -- Data.List import Data.Array.Vector.Stream import Data.Array.Vector.Prim.Hyperstrict import Data.Array.Vector -- -- Data.Stream <=> Data.List -- ------------------------------------------------------------------------ -- * Basic interface prop_cons = Test.cons `eq2` (Spec.cons) prop_snoc = Test.snoc `eq2` (\xs x -> xs Spec.++ [x]) prop_empty = Test.empty `eq0` (Spec.empty) prop_singleton = Test.singleton `eq1` (\x -> Spec.cons x []) prop_head = Test.head `eqnotnull1` Spec.head prop_append = Test.append `eq2` (Spec.++) prop_tail = Test.tail `eqnotnull1` Spec.tail prop_null = Test.null `eq1` Spec.null prop_init = Test.init `eqnotnull1` Spec.init prop_last = Test.last `eqnotnull1` Spec.last 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_foldl1 = Test.foldl1 `eqnotnull2` Spec.foldl1 -- n.b. {- prop_foldl' = Test.foldl' `eq3` Spec.foldl' 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 = (\f x xs -> Test.snoc (Test.scanl f x xs) x) `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 = \x -> x >= 0 ==> Test.replicate x `eq1` Spec.replicate x {- prop_cycle = \x -> not (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 < Test.length xs ==> (Test.index `eq2` Spec.index) 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 -- prop_unlines = Test.unlines `eq1` Spec.unlines -- prop_lines = Test.lines `eq1` Spec.lines {- prop_words = Test.words `eq1` Spec.words 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 x <- getArgs let opts' = case x of [n] -> opts { no_of_tests = read n } _ -> opts hSetBuffering stdout NoBuffering putStrLn "Testing: Data.Stream <=> Data.List" putStrLn "==================================\n" runTests "Extras" opts' [-- run prop_repeatU_model ] runTests "Basic interface" opts' [run prop_cons ,run prop_snoc ,run prop_empty ,run prop_singleton ,run prop_head ,run prop_append ,run prop_tail ,run prop_null ,run prop_init ,run prop_last ,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_foldr ,run prop_foldl1 -- ,run prop_foldl' -- ,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_filter ,run prop_find -- ,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_insertBy -- ,run prop_sortBy -- note issue here. 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 ] -}