git.iko.soy/streamly
on master help sign in
Refactor WSerial ops into a separate test suite.
80daa14Pranay Sashank
streamly.cabal+8
compare with master
unifiedsplit
@@ -592,6 +592,14 @@ test-suite Prelude.Serial
592 other-modules: Streamly.Test.Common
592 other-modules: Streamly.Test.Common
593 , Streamly.Test.Prelude
593 , Streamly.Test.Prelude
594
594
595+test-suite Prelude.WSerial
596+ import: test-options, prelude-test-options
597+ type: exitcode-stdio-1.0
598+ main-is: Streamly/Test/Prelude/WSerial.hs
599+ ghc-options: -main-is Streamly.Test.Prelude.WSerial.main
600+ other-modules: Streamly.Test.Common
601+ , Streamly.Test.Prelude
602+
595test-suite array-test
603test-suite array-test
596 import: test-options
604 import: test-options
597 type: exitcode-stdio-1.0
605 type: exitcode-stdio-1.0
test/Prop.hs+1−71
@@ -9,7 +9,6 @@ import Control.Exception
9 BlockedIndefinitelyOnSTM(..), Handler(..))
9 BlockedIndefinitelyOnSTM(..), Handler(..))
10import Control.Monad (when, forM_, replicateM_)
10import Control.Monad (when, forM_, replicateM_)
11import Data.IORef (readIORef, modifyIORef, newIORef)
11import Data.IORef (readIORef, modifyIORef, newIORef)
12−import Data.List (sort)
13import GHC.Word (Word8)
12import GHC.Word (Word8)
14
13
15import Test.Hspec.QuickCheck
14import Test.Hspec.QuickCheck
@@ -20,15 +19,11 @@ import Test.QuickCheck.Monadic (monadicIO, run)
20import Test.Hspec as H
19import Test.Hspec as H
21
20
22import Streamly
21import Streamly
23−import Streamly as S
24import qualified Streamly.Prelude as S
22import qualified Streamly.Prelude as S
25
23
26import Streamly.Test.Common
24import Streamly.Test.Common
27import Streamly.Test.Prelude
25import Streamly.Test.Prelude
28
26
29−sortEq :: Ord a => [a] -> [a] -> Bool
30−sortEq a b = sort a == sort b
31−
32-------------------------------------------------------------------------------
27-------------------------------------------------------------------------------
33-- Concurrent generation
28-- Concurrent generation
34-------------------------------------------------------------------------------
29-------------------------------------------------------------------------------
@@ -259,10 +254,6 @@ zipAsyncMonadic constr eq t (a, b) = withMaxSuccess maxTestCount $
259 listEquals eq stream1 list
254 listEquals eq stream1 list
260 listEquals eq stream2 list
255 listEquals eq stream2 list
261
256
262−-------------------------------------------------------------------------------
263−-- Tests for S.groupsBy
264−-------------------------------------------------------------------------------
265−
266main :: IO ()
257main :: IO ()
267main = hspec
258main = hspec
268 $ H.parallel
259 $ H.parallel
@@ -270,34 +261,6 @@ main = hspec
270 $ modifyMaxSuccess (const 10)
261 $ modifyMaxSuccess (const 10)
271#endif
262#endif
272 $ do
263 $ do
273− let folded :: IsStream t => [a] -> t IO a
274− folded = serially . (\xs ->
275− case xs of
276− [x] -> return x -- singleton stream case
277− _ -> S.foldMapWith (<>) return xs
278− )
279−
280− let makeCommonOps :: IsStream t => (t m a -> c) -> [(String, t m a -> c)]
281− makeCommonOps t =
282− [ ("default", t)
283−#ifndef COVERAGE_BUILD
284− , ("rate AvgRate 10000", t . avgRate 10000)
285− , ("rate Nothing", t . rate Nothing)
286− , ("maxBuffer 0", t . maxBuffer 0)
287− , ("maxThreads 0", t . maxThreads 0)
288− , ("maxThreads 1", t . maxThreads 1)
289− , ("maxThreads -1", t . maxThreads (-1))
290−#endif
291− ]
292−
293− let makeOps :: IsStream t => (t m a -> c) -> [(String, t m a -> c)]
294− makeOps t = makeCommonOps t ++
295− [
296−#ifndef COVERAGE_BUILD
297− ("maxBuffer 1", t . maxBuffer 1)
298−#endif
299− ]
300−
301 -- For concurrent application test we need a buffer of at least size 2 to
264 -- For concurrent application test we need a buffer of at least size 2 to
302 -- allow two threads to run.
265 -- allow two threads to run.
303 let makeConcurrentAppOps :: IsStream t
266 let makeConcurrentAppOps :: IsStream t
@@ -309,19 +272,6 @@ main = hspec
309#endif
272#endif
310 ]
273 ]
311
274
312− let mapOps spec = mapM_ (\(desc, f) -> describe desc $ spec f)
313− let serialOps :: IsStream t => ((SerialT IO a -> t IO a) -> Spec) -> Spec
314− serialOps spec = mapOps spec $ makeOps serially
315−#ifndef COVERAGE_BUILD
316− <> [("rate AvgRate 0.00000001", serially . avgRate 0.00000001)]
317− <> [("maxBuffer -1", serially . maxBuffer (-1))]
318−#endif
319− let wSerialOps :: IsStream t => ((WSerialT IO a -> t IO a) -> Spec) -> Spec
320− wSerialOps spec = mapOps spec $ makeOps wSerially
321−#ifndef COVERAGE_BUILD
322− <> [("rate AvgRate 0.00000001", wSerially . avgRate 0.00000001)]
323− <> [("maxBuffer (-1)", wSerially . maxBuffer (-1))]
324−#endif
325 let asyncOps :: IsStream t => ((AsyncT IO a -> t IO a) -> Spec) -> Spec
275 let asyncOps :: IsStream t => ((AsyncT IO a -> t IO a) -> Spec) -> Spec
326 asyncOps spec = mapOps spec $ makeOps asyncly
276 asyncOps spec = mapOps spec $ makeOps asyncly
327#ifndef COVERAGE_BUILD
277#ifndef COVERAGE_BUILD
@@ -365,7 +315,6 @@ main = hspec
365 zipAsyncOps spec = mapOps spec $ makeOps zipAsyncly
315 zipAsyncOps spec = mapOps spec $ makeOps zipAsyncly
366
316
367 describe "Construction" $ do
317 describe "Construction" $ do
368− wSerialOps $ prop "wSerially replicateM" . constructWithReplicateM
369 aheadOps $ prop "aheadly replicateM" . constructWithReplicateM
318 aheadOps $ prop "aheadly replicateM" . constructWithReplicateM
370 asyncOps $ prop "asyncly replicateM" . constructWithReplicateM
319 asyncOps $ prop "asyncly replicateM" . constructWithReplicateM
371 wAsyncOps $ prop "wAsyncly replicateM" . constructWithReplicateM
320 wAsyncOps $ prop "wAsyncly replicateM" . constructWithReplicateM
@@ -381,8 +330,6 @@ main = hspec
381 -- XXX add tests for fromIndices
330 -- XXX add tests for fromIndices
382
331
383 describe "Functor operations" $ do
332 describe "Functor operations" $ do
384− wSerialOps $ functorOps S.fromFoldable "wSerially" (==)
385− wSerialOps $ functorOps folded "wSerially folded" (==)
386 aheadOps $ functorOps S.fromFoldable "aheadly" (==)
333 aheadOps $ functorOps S.fromFoldable "aheadly" (==)
387 aheadOps $ functorOps folded "aheadly folded" (==)
334 aheadOps $ functorOps folded "aheadly folded" (==)
388 asyncOps $ functorOps S.fromFoldable "asyncly" sortEq
335 asyncOps $ functorOps S.fromFoldable "asyncly" sortEq
@@ -397,7 +344,6 @@ main = hspec
397 zipAsyncOps $ functorOps folded "zipAsyncly folded" (==)
344 zipAsyncOps $ functorOps folded "zipAsyncly folded" (==)
398
345
399 describe "Semigroup operations" $ do
346 describe "Semigroup operations" $ do
400− wSerialOps $ semigroupOps "wSerially" (==)
401 aheadOps $ semigroupOps "aheadly" (==)
347 aheadOps $ semigroupOps "aheadly" (==)
402 asyncOps $ semigroupOps "asyncly" sortEq
348 asyncOps $ semigroupOps "asyncly" sortEq
403 wAsyncOps $ semigroupOps "wAsyncly" sortEq
349 wAsyncOps $ semigroupOps "wAsyncly" sortEq
@@ -406,8 +352,6 @@ main = hspec
406 zipAsyncOps $ semigroupOps "zipAsyncly" (==)
352 zipAsyncOps $ semigroupOps "zipAsyncly" (==)
407
353
408 describe "Applicative operations" $ do
354 describe "Applicative operations" $ do
409− wSerialOps $ prop "wSerially applicative" . applicativeOps S.fromFoldable sortEq
410− wSerialOps $ prop "wSerially applicative folded" . applicativeOps folded sortEq
411 aheadOps $ prop "aheadly applicative" . applicativeOps S.fromFoldable (==)
355 aheadOps $ prop "aheadly applicative" . applicativeOps S.fromFoldable (==)
412 aheadOps $ prop "aheadly applicative folded" . applicativeOps folded (==)
356 aheadOps $ prop "aheadly applicative folded" . applicativeOps folded (==)
413 asyncOps $ prop "asyncly applicative" . applicativeOps S.fromFoldable sortEq
357 asyncOps $ prop "asyncly applicative" . applicativeOps S.fromFoldable sortEq
@@ -426,8 +370,6 @@ main = hspec
426 -- We test only the serial zip with serial streams and the parallel
370 -- We test only the serial zip with serial streams and the parallel
427 -- stream, because the rate setting in these streams can slow down
371 -- stream, because the rate setting in these streams can slow down
428 -- zipAsync.
372 -- zipAsync.
429− wSerialOps $ prop "zip monadic wSerially" . zipMonadic S.fromFoldable (==)
430− wSerialOps $ prop "zip monadic wSerially folded" . zipMonadic folded (==)
431 aheadOps $ prop "zip monadic aheadly" . zipAsyncMonadic S.fromFoldable (==)
373 aheadOps $ prop "zip monadic aheadly" . zipAsyncMonadic S.fromFoldable (==)
432 aheadOps $ prop "zip monadic aheadly folded" . zipAsyncMonadic folded (==)
374 aheadOps $ prop "zip monadic aheadly folded" . zipAsyncMonadic folded (==)
433 asyncOps $ prop "zip monadic asyncly" . zipAsyncMonadic S.fromFoldable (==)
375 asyncOps $ prop "zip monadic asyncly" . zipAsyncMonadic S.fromFoldable (==)
@@ -443,25 +385,21 @@ main = hspec
443 -- describe "Merge operations" $ do
385 -- describe "Merge operations" $ do
444
386
445 describe "Monad operations" $ do
387 describe "Monad operations" $ do
446− wSerialOps $ prop "wSerially monad then" . monadThen S.fromFoldable sortEq
447 aheadOps $ prop "aheadly monad then" . monadThen S.fromFoldable (==)
388 aheadOps $ prop "aheadly monad then" . monadThen S.fromFoldable (==)
448 asyncOps $ prop "asyncly monad then" . monadThen S.fromFoldable sortEq
389 asyncOps $ prop "asyncly monad then" . monadThen S.fromFoldable sortEq
449 wAsyncOps $ prop "wAsyncly monad then" . monadThen S.fromFoldable sortEq
390 wAsyncOps $ prop "wAsyncly monad then" . monadThen S.fromFoldable sortEq
450 parallelOps $ prop "parallely monad then" . monadThen S.fromFoldable sortEq
391 parallelOps $ prop "parallely monad then" . monadThen S.fromFoldable sortEq
451
392
452− wSerialOps $ prop "wSerially monad then folded" . monadThen folded sortEq
453 aheadOps $ prop "aheadly monad then folded" . monadThen folded (==)
393 aheadOps $ prop "aheadly monad then folded" . monadThen folded (==)
454 asyncOps $ prop "asyncly monad then folded" . monadThen folded sortEq
394 asyncOps $ prop "asyncly monad then folded" . monadThen folded sortEq
455 wAsyncOps $ prop "wAsyncly monad then folded" . monadThen folded sortEq
395 wAsyncOps $ prop "wAsyncly monad then folded" . monadThen folded sortEq
456 parallelOps $ prop "parallely monad then folded" . monadThen folded sortEq
396 parallelOps $ prop "parallely monad then folded" . monadThen folded sortEq
457
397
458− wSerialOps $ prop "wSerially monad bind" . monadBind S.fromFoldable sortEq
459 aheadOps $ prop "aheadly monad bind" . monadBind S.fromFoldable (==)
398 aheadOps $ prop "aheadly monad bind" . monadBind S.fromFoldable (==)
460 asyncOps $ prop "asyncly monad bind" . monadBind S.fromFoldable sortEq
399 asyncOps $ prop "asyncly monad bind" . monadBind S.fromFoldable sortEq
461 wAsyncOps $ prop "wAsyncly monad bind" . monadBind S.fromFoldable sortEq
400 wAsyncOps $ prop "wAsyncly monad bind" . monadBind S.fromFoldable sortEq
462 parallelOps $ prop "parallely monad bind" . monadBind S.fromFoldable sortEq
401 parallelOps $ prop "parallely monad bind" . monadBind S.fromFoldable sortEq
463
402
464− wSerialOps $ prop "wSerially monad bind folded" . monadBind folded sortEq
465 aheadOps $ prop "aheadly monad bind folded" . monadBind folded (==)
403 aheadOps $ prop "aheadly monad bind folded" . monadBind folded (==)
466 asyncOps $ prop "asyncly monad bind folded" . monadBind folded sortEq
404 asyncOps $ prop "asyncly monad bind folded" . monadBind folded sortEq
467 wAsyncOps $ prop "wAsyncly monad bind folded" . monadBind folded sortEq
405 wAsyncOps $ prop "wAsyncly monad bind folded" . monadBind folded sortEq
@@ -493,7 +431,7 @@ main = hspec
493 forOps (mkOps parallely) $ concurrentOps folded "parallely folded" sortEq
431 forOps (mkOps parallely) $ concurrentOps folded "parallely folded" sortEq
494
432
495 describe "Concurrent application" $ do
433 describe "Concurrent application" $ do
496− serialOps $ prop "serial" . concurrentApplication (==)
434+-- serialOps $ prop "serial" . concurrentApplication (==)
497 asyncOps $ prop "async" . concurrentApplication sortEq
435 asyncOps $ prop "async" . concurrentApplication sortEq
498 aheadOps $ prop "ahead" . concurrentApplication (==)
436 aheadOps $ prop "ahead" . concurrentApplication (==)
499 parallelConcurrentAppOps $
437 parallelConcurrentAppOps $
@@ -505,7 +443,6 @@ main = hspec
505 concurrentFoldlApplication
443 concurrentFoldlApplication
506
444
507 describe "Stream transform and combine operations" $ do
445 describe "Stream transform and combine operations" $ do
508− wSerialOps $ transformCombineOpsCommon S.fromFoldable "wSerially" sortEq
509 aheadOps $ transformCombineOpsCommon S.fromFoldable "aheadly" (==)
446 aheadOps $ transformCombineOpsCommon S.fromFoldable "aheadly" (==)
510 asyncOps $ transformCombineOpsCommon S.fromFoldable "asyncly" sortEq
447 asyncOps $ transformCombineOpsCommon S.fromFoldable "asyncly" sortEq
511 wAsyncOps $ transformCombineOpsCommon S.fromFoldable "wAsyncly" sortEq
448 wAsyncOps $ transformCombineOpsCommon S.fromFoldable "wAsyncly" sortEq
@@ -513,7 +450,6 @@ main = hspec
513 zipSerialOps $ transformCombineOpsCommon S.fromFoldable "zipSerially" (==)
450 zipSerialOps $ transformCombineOpsCommon S.fromFoldable "zipSerially" (==)
514 zipAsyncOps $ transformCombineOpsCommon S.fromFoldable "zipAsyncly" (==)
451 zipAsyncOps $ transformCombineOpsCommon S.fromFoldable "zipAsyncly" (==)
515
452
516− wSerialOps $ transformCombineOpsCommon folded "wSerially" sortEq
517 aheadOps $ transformCombineOpsCommon folded "aheadly" (==)
453 aheadOps $ transformCombineOpsCommon folded "aheadly" (==)
518 asyncOps $ transformCombineOpsCommon folded "asyncly" sortEq
454 asyncOps $ transformCombineOpsCommon folded "asyncly" sortEq
519 wAsyncOps $ transformCombineOpsCommon folded "wAsyncly" sortEq
455 wAsyncOps $ transformCombineOpsCommon folded "wAsyncly" sortEq
@@ -530,7 +466,6 @@ main = hspec
530 zipAsyncOps $ transformCombineOpsOrdered folded "zipAsyncly" (==)
466 zipAsyncOps $ transformCombineOpsOrdered folded "zipAsyncly" (==)
531
467
532 describe "Stream elimination operations" $ do
468 describe "Stream elimination operations" $ do
533− wSerialOps $ eliminationOps S.fromFoldable "wSerially"
534 aheadOps $ eliminationOps S.fromFoldable "aheadly"
469 aheadOps $ eliminationOps S.fromFoldable "aheadly"
535 asyncOps $ eliminationOps S.fromFoldable "asyncly"
470 asyncOps $ eliminationOps S.fromFoldable "asyncly"
536 wAsyncOps $ eliminationOps S.fromFoldable "wAsyncly"
471 wAsyncOps $ eliminationOps S.fromFoldable "wAsyncly"
@@ -538,7 +473,6 @@ main = hspec
538 zipSerialOps $ eliminationOps S.fromFoldable "zipSerially"
473 zipSerialOps $ eliminationOps S.fromFoldable "zipSerially"
539 zipAsyncOps $ eliminationOps S.fromFoldable "zipAsyncly"
474 zipAsyncOps $ eliminationOps S.fromFoldable "zipAsyncly"
540
475
541− wSerialOps $ eliminationOps folded "wSerially folded"
542 aheadOps $ eliminationOps folded "aheadly folded"
476 aheadOps $ eliminationOps folded "aheadly folded"
543 asyncOps $ eliminationOps folded "asyncly folded"
477 asyncOps $ eliminationOps folded "asyncly folded"
544 wAsyncOps $ eliminationOps folded "wAsyncly folded"
478 wAsyncOps $ eliminationOps folded "wAsyncly folded"
@@ -546,7 +480,6 @@ main = hspec
546 zipSerialOps $ eliminationOps folded "zipSerially folded"
480 zipSerialOps $ eliminationOps folded "zipSerially folded"
547 zipAsyncOps $ eliminationOps folded "zipAsyncly folded"
481 zipAsyncOps $ eliminationOps folded "zipAsyncly folded"
548
482
549− wSerialOps $ eliminationOpsWord8 S.fromFoldable "wSerially"
550 aheadOps $ eliminationOpsWord8 S.fromFoldable "aheadly"
483 aheadOps $ eliminationOpsWord8 S.fromFoldable "aheadly"
551 asyncOps $ eliminationOpsWord8 S.fromFoldable "asyncly"
484 asyncOps $ eliminationOpsWord8 S.fromFoldable "asyncly"
552 wAsyncOps $ eliminationOpsWord8 S.fromFoldable "wAsyncly"
485 wAsyncOps $ eliminationOpsWord8 S.fromFoldable "wAsyncly"
@@ -554,7 +487,6 @@ main = hspec
554 zipSerialOps $ eliminationOpsWord8 S.fromFoldable "zipSerially"
487 zipSerialOps $ eliminationOpsWord8 S.fromFoldable "zipSerially"
555 zipAsyncOps $ eliminationOpsWord8 S.fromFoldable "zipAsyncly"
488 zipAsyncOps $ eliminationOpsWord8 S.fromFoldable "zipAsyncly"
556
489
557− wSerialOps $ eliminationOpsWord8 folded "wSerially folded"
558 aheadOps $ eliminationOpsWord8 folded "aheadly folded"
490 aheadOps $ eliminationOpsWord8 folded "aheadly folded"
559 asyncOps $ eliminationOpsWord8 folded "asyncly folded"
491 asyncOps $ eliminationOpsWord8 folded "asyncly folded"
560 wAsyncOps $ eliminationOpsWord8 folded "wAsyncly folded"
492 wAsyncOps $ eliminationOpsWord8 folded "wAsyncly folded"
@@ -565,12 +497,10 @@ main = hspec
565 -- XXX Add a test where we chain all transformation APIs and make sure that
497 -- XXX Add a test where we chain all transformation APIs and make sure that
566 -- the state is being passed through all of them.
498 -- the state is being passed through all of them.
567 describe "Stream serial elimination operations" $ do
499 describe "Stream serial elimination operations" $ do
568− wSerialOps $ eliminationOpsOrdered S.fromFoldable "wSerially"
569 aheadOps $ eliminationOpsOrdered S.fromFoldable "aheadly"
500 aheadOps $ eliminationOpsOrdered S.fromFoldable "aheadly"
570 zipSerialOps $ eliminationOpsOrdered S.fromFoldable "zipSerially"
501 zipSerialOps $ eliminationOpsOrdered S.fromFoldable "zipSerially"
571 zipAsyncOps $ eliminationOpsOrdered S.fromFoldable "zipAsyncly"
502 zipAsyncOps $ eliminationOpsOrdered S.fromFoldable "zipAsyncly"
572
503
573− wSerialOps $ eliminationOpsOrdered folded "wSerially folded"
574 aheadOps $ eliminationOpsOrdered folded "aheadly folded"
504 aheadOps $ eliminationOpsOrdered folded "aheadly folded"
575 zipSerialOps $ eliminationOpsOrdered folded "zipSerially folded"
505 zipSerialOps $ eliminationOpsOrdered folded "zipSerially folded"
576 zipAsyncOps $ eliminationOpsOrdered folded "zipAsyncly folded"
506 zipAsyncOps $ eliminationOpsOrdered folded "zipAsyncly folded"
test/Streamly/Test/Common.hs+3
@@ -15,6 +15,9 @@ module Streamly.Test.Common
15import Control.Monad (when)
15import Control.Monad (when)
16import Control.Monad.IO.Class (MonadIO(..))
16import Control.Monad.IO.Class (MonadIO(..))
17import Data.List ((\\))
17import Data.List ((\\))
18+#if __GLASGOW_HASKELL__ < 808
19+import Data.Semigroup ((<>))
20+#endif
18import Test.QuickCheck (counterexample)
21import Test.QuickCheck (counterexample)
19import Test.QuickCheck.Monadic (PropertyM, assert, monitor)
22import Test.QuickCheck.Monadic (PropertyM, assert, monitor)
20
23
test/Streamly/Test/Prelude.hs+48−14
@@ -43,12 +43,18 @@ module Streamly.Test.Prelude
43 -- * Default values
43 -- * Default values
44 , maxTestCount
44 , maxTestCount
45 , maxStreamLen
45 , maxStreamLen
46+ -- * Helper operations
47+ , folded
48+ , makeCommonOps
49+ , makeOps
50+ , mapOps
51+ , sortEq
46 ) where
52 ) where
47
53
48import Control.Applicative (ZipList(..), liftA2)
54import Control.Applicative (ZipList(..), liftA2)
49import Control.Monad (replicateM)
55import Control.Monad (replicateM)
50import Data.Function ((&))
56import Data.Function ((&))
51−import Data.IORef (IORef, modifyIORef, modifyIORef', newIORef, readIORef)
57+import Data.IORef (IORef, modifyIORef', newIORef, readIORef)
52import Data.List
58import Data.List
53 ( deleteBy
59 ( deleteBy
54 , elemIndex
60 , elemIndex
@@ -69,22 +75,14 @@ import Data.List
69 , stripPrefix
75 , stripPrefix
70 )
76 )
71import Data.Maybe (mapMaybe)
77import Data.Maybe (mapMaybe)
78+#if __GLASGOW_HASKELL__ < 808
79+import Data.Semigroup ((<>))
80+#endif
72import GHC.Word (Word8)
81import GHC.Word (Word8)
73import Test.Hspec.QuickCheck
82import Test.Hspec.QuickCheck
74import Test.Hspec
83import Test.Hspec
75−import Test.QuickCheck
84+import Test.QuickCheck (Property, choose, forAll, withMaxSuccess)
76− ( Gen
77− , Property
78− , arbitrary
79− , choose
80− , elements
81− , forAll
82− , frequency
83− , listOf
84− , vectorOf
85− , withMaxSuccess
86− )
87−import Test.QuickCheck.Monadic (PropertyM, assert, monadicIO, run)
85+import Test.QuickCheck.Monadic (assert, monadicIO, run)
88
86
89import Streamly
87import Streamly
90import Streamly.Prelude ((.:), nil)
88import Streamly.Prelude ((.:), nil)
@@ -729,3 +727,39 @@ zipMonadic constr eq t (a, b) = withMaxSuccess maxTestCount $
729 (S.zipWithM (curry return) (constr a) (constr b)))
727 (S.zipWithM (curry return) (constr a) (constr b)))
730 let list = getZipList $ (,) <$> ZipList a <*> ZipList b
728 let list = getZipList $ (,) <$> ZipList a <*> ZipList b
731 listEquals eq stream1 list
729 listEquals eq stream1 list
730+
731+-------------------------------------------------------------------------------
732+-- Helper operations
733+-------------------------------------------------------------------------------
734+
735+folded :: IsStream t => [a] -> t IO a
736+folded =
737+ serially .
738+ (\xs ->
739+ case xs of
740+ [x] -> return x -- singleton stream case
741+ _ -> S.foldMapWith (<>) return xs)
742+
743+makeCommonOps :: IsStream t => (t m a -> c) -> [(String, t m a -> c)]
744+makeCommonOps t =
745+ [ ("default", t)
746+#ifndef COVERAGE_BUILD
747+ , ("rate AvgRate 10000", t . avgRate 10000)
748+ , ("rate Nothing", t . rate Nothing)
749+ , ("maxBuffer 0", t . maxBuffer 0)
750+ , ("maxThreads 0", t . maxThreads 0)
751+ , ("maxThreads 1", t . maxThreads 1)
752+ , ("maxThreads -1", t . maxThreads (-1))
753+#endif
754+ ]
755+
756+makeOps :: IsStream t => (t m a -> c) -> [(String, t m a -> c)]
757+makeOps t = makeCommonOps t ++
758+ [
759+#ifndef COVERAGE_BUILD
760+ ("maxBuffer 1", t . maxBuffer 1)
761+#endif
762+ ]
763+
764+mapOps :: (a -> Spec) -> [(String, a)] -> Spec
765+mapOps spec = mapM_ (\(desc, f) -> describe desc $ spec f)
test/Streamly/Test/Prelude/Serial.hs+3−31
@@ -10,6 +10,9 @@
10module Streamly.Test.Prelude.Serial where
10module Streamly.Test.Prelude.Serial where
11
11
12import Data.List (intercalate)
12import Data.List (intercalate)
13+#if __GLASGOW_HASKELL__ < 808
14+import Data.Semigroup ((<>))
15+#endif
13import Test.Hspec.QuickCheck
16import Test.Hspec.QuickCheck
14import Test.QuickCheck
17import Test.QuickCheck
15 ( Gen
18 ( Gen
@@ -27,10 +30,8 @@ import Test.QuickCheck.Monadic (assert, monadicIO, run)
27import Test.Hspec as H
30import Test.Hspec as H
28
31
29import Streamly
32import Streamly
30−import Streamly as S
31import qualified Streamly.Prelude as S
33import qualified Streamly.Prelude as S
32import qualified Streamly.Data.Fold as FL
34import qualified Streamly.Data.Fold as FL
33−import qualified Streamly.Internal.Data.Fold as FL
34
35
35import Streamly.Test.Common
36import Streamly.Test.Common
36import Streamly.Test.Prelude
37import Streamly.Test.Prelude
@@ -151,35 +152,6 @@ main = hspec
151 $ modifyMaxSuccess (const 10)
152 $ modifyMaxSuccess (const 10)
152#endif
153#endif
153 $ do
154 $ do
154− let folded :: IsStream t => [a] -> t IO a
155− folded = serially . (\xs ->
156− case xs of
157− [x] -> return x -- singleton stream case
158− _ -> S.foldMapWith (<>) return xs
159− )
160−
161− let makeCommonOps :: IsStream t => (t m a -> c) -> [(String, t m a -> c)]
162− makeCommonOps t =
163− [ ("default", t)
164−#ifndef COVERAGE_BUILD
165− , ("rate AvgRate 10000", t . avgRate 10000)
166− , ("rate Nothing", t . rate Nothing)
167− , ("maxBuffer 0", t . maxBuffer 0)
168− , ("maxThreads 0", t . maxThreads 0)
169− , ("maxThreads 1", t . maxThreads 1)
170− , ("maxThreads -1", t . maxThreads (-1))
171−#endif
172− ]
173−
174− let makeOps :: IsStream t => (t m a -> c) -> [(String, t m a -> c)]
175− makeOps t = makeCommonOps t ++
176− [
177−#ifndef COVERAGE_BUILD
178− ("maxBuffer 1", t . maxBuffer 1)
179−#endif
180− ]
181−
182− let mapOps spec = mapM_ (\(desc, f) -> describe desc $ spec f)
183 let serialOps :: IsStream t => ((SerialT IO a -> t IO a) -> Spec) -> Spec
155 let serialOps :: IsStream t => ((SerialT IO a -> t IO a) -> Spec) -> Spec
184 serialOps spec = mapOps spec $ makeOps serially
156 serialOps spec = mapOps spec $ makeOps serially
185#ifndef COVERAGE_BUILD
157#ifndef COVERAGE_BUILD
test/Streamly/Test/Prelude/WSerial.hsnew file+79
@@ -0,0 +1,79 @@
1+-- |
2+-- Module : Streamly.Test.Prelude.WSerial
3+-- Copyright : (c) 2020 Composewell Technologies
4+--
5+-- License : BSD-3-Clause
6+-- Maintainer : streamly@composewell.com
7+-- Stability : experimental
8+-- Portability : GHC
9+
10+module Streamly.Test.Prelude.WSerial where
11+
12+#if __GLASGOW_HASKELL__ < 808
13+import Data.Semigroup ((<>))
14+#endif
15+import Test.Hspec.QuickCheck
16+import Test.Hspec as H
17+
18+import Streamly
19+import qualified Streamly.Prelude as S
20+
21+import Streamly.Test.Prelude
22+
23+main :: IO ()
24+main = hspec
25+ $ H.parallel
26+#ifdef COVERAGE_BUILD
27+ $ modifyMaxSuccess (const 10)
28+#endif
29+ $ do
30+ let wSerialOps :: IsStream t => ((WSerialT IO a -> t IO a) -> Spec) -> Spec
31+ wSerialOps spec = mapOps spec $ makeOps wSerially
32+#ifndef COVERAGE_BUILD
33+ <> [("rate AvgRate 0.00000001", wSerially . avgRate 0.00000001)]
34+ <> [("maxBuffer (-1)", wSerially . maxBuffer (-1))]
35+#endif
36+
37+ describe "Construction" $ do
38+ wSerialOps $ prop "wSerially replicateM" . constructWithReplicateM
39+
40+ describe "Functor operations" $ do
41+ wSerialOps $ functorOps S.fromFoldable "wSerially" (==)
42+ wSerialOps $ functorOps folded "wSerially folded" (==)
43+
44+ describe "Semigroup operations" $ do
45+ wSerialOps $ semigroupOps "wSerially" (==)
46+
47+ describe "Applicative operations" $ do
48+ wSerialOps $ prop "wSerially applicative" . applicativeOps S.fromFoldable sortEq
49+ wSerialOps $ prop "wSerially applicative folded" . applicativeOps folded sortEq
50+
51+ -- XXX add tests for indexed/indexedR
52+ describe "Zip operations" $ do
53+ -- We test only the serial zip with serial streams and the parallel
54+ -- stream, because the rate setting in these streams can slow down
55+ -- zipAsync.
56+ wSerialOps $ prop "zip monadic wSerially" . zipMonadic S.fromFoldable (==)
57+ wSerialOps $ prop "zip monadic wSerially folded" . zipMonadic folded (==)
58+
59+ describe "Monad operations" $ do
60+ wSerialOps $ prop "wSerially monad then" . monadThen S.fromFoldable sortEq
61+ wSerialOps $ prop "wSerially monad then folded" . monadThen folded sortEq
62+ wSerialOps $ prop "wSerially monad bind" . monadBind S.fromFoldable sortEq
63+ wSerialOps $ prop "wSerially monad bind folded" . monadBind folded sortEq
64+
65+ describe "Stream transform and combine operations" $ do
66+ wSerialOps $ transformCombineOpsCommon S.fromFoldable "wSerially" sortEq
67+ wSerialOps $ transformCombineOpsCommon folded "wSerially" sortEq
68+
69+ describe "Stream elimination operations" $ do
70+ wSerialOps $ eliminationOps S.fromFoldable "wSerially"
71+ wSerialOps $ eliminationOps folded "wSerially folded"
72+ wSerialOps $ eliminationOpsWord8 S.fromFoldable "wSerially"
73+ wSerialOps $ eliminationOpsWord8 folded "wSerially folded"
74+
75+ -- XXX Add a test where we chain all transformation APIs and make sure that
76+ -- the state is being passed through all of them.
77+ describe "Stream serial elimination operations" $ do
78+ wSerialOps $ eliminationOpsOrdered S.fromFoldable "wSerially"
79+ wSerialOps $ eliminationOpsOrdered folded "wSerially folded"