{- |
Module : Main
Description : Stream merging tests
Copyright : Ivan Lazar Miljenovic
License : MIT
Maintainer : Ivan.Miljenovic@gmail.com
-}
module Main (main) where
import Streaming.Concurrent
import Data.ByteString.Streaming (fromStrict, toStrict_)
import Streaming.Prelude (each, toList_)
import qualified Data.ByteString as B
import Data.Function (on)
import Data.List (concat, sort)
import Data.Monoid (mconcat)
import Test.Hspec (describe, hspec)
import Test.Hspec.QuickCheck (prop)
import Test.QuickCheck (Positive(..), Property, ioProperty)
import Test.QuickCheck.Instances ()
--------------------------------------------------------------------------------
main :: IO ()
main = hspec $ do
describe "Merging retains all elements" $ do
prop "Stream" (mergeCheck :: [[Int]] -> Property)
prop "ByteString" mergeBSCheck
describe "Stream transformation" $ do
prop "map id" (streamMapCheckId :: Positive Int -> [Int] -> Property)
prop "map show" (streamMapCheck show :: Positive Int -> [Int] -> Property)
mergeCheck :: (Ord a) => [[a]] -> Property
mergeCheck ass = ioProperty (withMergedStreams unbounded
(map each ass)
(eqOn sort as . toList_))
where
as = concat ass
mergeBSCheck :: [B.ByteString] -> Property
mergeBSCheck bss = ioProperty (withMergedByteStrings unbounded
(map fromStrict bss)
(eqOn B.sort bs . toStrict_))
where
bs = mconcat bss
streamMapCheckId :: (Ord a) => Positive Int -> [a] -> Property
streamMapCheckId (Positive n) as =
ioProperty (withStreamMap n id (each as) (eqOn sort as . toList_))
streamMapCheck :: (Ord b) => (a -> b) -> Positive Int -> [a] -> Property
streamMapCheck f (Positive n) as =
ioProperty (withStreamMap n f (each as) (eqOn sort bs . toList_))
where
bs = map f as
eqOn :: (Eq b, Functor f) => (a -> b) -> a -> f a -> f Bool
eqOn f a = fmap (((==)`on`f) a)