git.iko.soy/streamly
on master help sign in
Refactor ZipSerial ops into a separate test suite.
9cec13fPranay Sashank
streamly.cabal+8
compare with master
unifiedsplit
@@ -600,6 +600,14 @@ test-suite Prelude.WSerial
600 other-modules: Streamly.Test.Common
600 other-modules: Streamly.Test.Common
601 , Streamly.Test.Prelude
601 , Streamly.Test.Prelude
602
602
603+test-suite Prelude.ZipSerial
604+ import: test-options, prelude-test-options
605+ type: exitcode-stdio-1.0
606+ main-is: Streamly/Test/Prelude/ZipSerial.hs
607+ ghc-options: -main-is Streamly.Test.Prelude.ZipSerial.main
608+ other-modules: Streamly.Test.Common
609+ , Streamly.Test.Prelude
610+
603test-suite array-test
611test-suite array-test
604 import: test-options
612 import: test-options
605 type: exitcode-stdio-1.0
613 type: exitcode-stdio-1.0
test/Prop.hs−39
@@ -216,23 +216,6 @@ concurrentFoldrApplication n =
216-- Zip operations
216-- Zip operations
217-------------------------------------------------------------------------------
217-------------------------------------------------------------------------------
218
218
219−zipApplicative
220− :: (IsStream t, Applicative (t IO))
221− => ([Int] -> t IO Int)
222− -> ([(Int, Int)] -> [(Int, Int)] -> Bool)
223− -> (t IO (Int, Int) -> SerialT IO (Int, Int))
224− -> ([Int], [Int])
225− -> Property
226−zipApplicative constr eq t (a, b) = withMaxSuccess maxTestCount $
227− monadicIO $ do
228− stream1 <- run ((S.toList . t) ((,) <$> constr a <*> constr b))
229− stream2 <- run ((S.toList . t) (pure (,) <*> constr a <*> constr b))
230− stream3 <- run ((S.toList . t) (S.zipWith (,) (constr a) (constr b)))
231− let list = getZipList $ (,) <$> ZipList a <*> ZipList b
232− listEquals eq stream1 list
233− listEquals eq stream2 list
234− listEquals eq stream3 list
235−
236zipAsyncMonadic
219zipAsyncMonadic
237 :: IsStream t
220 :: IsStream t
238 => ([Int] -> t IO Int)
221 => ([Int] -> t IO Int)
@@ -302,13 +285,6 @@ main = hspec
302 parallelConcurrentAppOps spec =
285 parallelConcurrentAppOps spec =
303 mapOps spec $ makeConcurrentAppOps parallely <> parallelCommonOps
286 mapOps spec $ makeConcurrentAppOps parallely <> parallelCommonOps
304
287
305− let zipSerialOps :: IsStream t
306− => ((ZipSerialM IO a -> t IO a) -> Spec) -> Spec
307− zipSerialOps spec = mapOps spec $ makeOps zipSerially
308−#ifndef COVERAGE_BUILD
309− <> [("rate AvgRate 0.00000001", zipSerially . avgRate 0.00000001)]
310− <> [("maxBuffer (-1)", zipSerially . maxBuffer (-1))]
311−#endif
312 -- Note, the "pure" of applicative Zip streams generates and infinite
288 -- Note, the "pure" of applicative Zip streams generates and infinite
313 -- stream and therefore maxBuffer (-1) must not be used for that case.
289 -- stream and therefore maxBuffer (-1) must not be used for that case.
314 let zipAsyncOps :: IsStream t => ((ZipAsyncM IO a -> t IO a) -> Spec) -> Spec
290 let zipAsyncOps :: IsStream t => ((ZipAsyncM IO a -> t IO a) -> Spec) -> Spec
@@ -338,8 +314,6 @@ main = hspec
338 wAsyncOps $ functorOps folded "wAsyncly folded" sortEq
314 wAsyncOps $ functorOps folded "wAsyncly folded" sortEq
339 parallelOps $ functorOps S.fromFoldable "parallely" sortEq
315 parallelOps $ functorOps S.fromFoldable "parallely" sortEq
340 parallelOps $ functorOps folded "parallely folded" sortEq
316 parallelOps $ functorOps folded "parallely folded" sortEq
341− zipSerialOps $ functorOps S.fromFoldable "zipSerially" (==)
342− zipSerialOps $ functorOps folded "zipSerially folded" (==)
343 zipAsyncOps $ functorOps S.fromFoldable "zipAsyncly" (==)
317 zipAsyncOps $ functorOps S.fromFoldable "zipAsyncly" (==)
344 zipAsyncOps $ functorOps folded "zipAsyncly folded" (==)
318 zipAsyncOps $ functorOps folded "zipAsyncly folded" (==)
345
319
@@ -348,7 +322,6 @@ main = hspec
348 asyncOps $ semigroupOps "asyncly" sortEq
322 asyncOps $ semigroupOps "asyncly" sortEq
349 wAsyncOps $ semigroupOps "wAsyncly" sortEq
323 wAsyncOps $ semigroupOps "wAsyncly" sortEq
350 parallelOps $ semigroupOps "parallely" sortEq
324 parallelOps $ semigroupOps "parallely" sortEq
351− zipSerialOps $ semigroupOps "zipSerially" (==)
352 zipAsyncOps $ semigroupOps "zipAsyncly" (==)
325 zipAsyncOps $ semigroupOps "zipAsyncly" (==)
353
326
354 describe "Applicative operations" $ do
327 describe "Applicative operations" $ do
@@ -362,8 +335,6 @@ main = hspec
362
335
363 -- XXX add tests for indexed/indexedR
336 -- XXX add tests for indexed/indexedR
364 describe "Zip operations" $ do
337 describe "Zip operations" $ do
365− zipSerialOps $ prop "zipSerially applicative" . zipApplicative S.fromFoldable (==)
366− zipSerialOps $ prop "zipSerially applicative folded" . zipApplicative folded (==)
367 zipAsyncOps $ prop "zipAsyncly applicative" . zipApplicative S.fromFoldable (==)
338 zipAsyncOps $ prop "zipAsyncly applicative" . zipApplicative S.fromFoldable (==)
368 zipAsyncOps $ prop "zipAsyncly applicative folded" . zipApplicative folded (==)
339 zipAsyncOps $ prop "zipAsyncly applicative folded" . zipApplicative folded (==)
369
340
@@ -447,22 +418,18 @@ main = hspec
447 asyncOps $ transformCombineOpsCommon S.fromFoldable "asyncly" sortEq
418 asyncOps $ transformCombineOpsCommon S.fromFoldable "asyncly" sortEq
448 wAsyncOps $ transformCombineOpsCommon S.fromFoldable "wAsyncly" sortEq
419 wAsyncOps $ transformCombineOpsCommon S.fromFoldable "wAsyncly" sortEq
449 parallelOps $ transformCombineOpsCommon S.fromFoldable "parallely" sortEq
420 parallelOps $ transformCombineOpsCommon S.fromFoldable "parallely" sortEq
450− zipSerialOps $ transformCombineOpsCommon S.fromFoldable "zipSerially" (==)
451 zipAsyncOps $ transformCombineOpsCommon S.fromFoldable "zipAsyncly" (==)
421 zipAsyncOps $ transformCombineOpsCommon S.fromFoldable "zipAsyncly" (==)
452
422
453 aheadOps $ transformCombineOpsCommon folded "aheadly" (==)
423 aheadOps $ transformCombineOpsCommon folded "aheadly" (==)
454 asyncOps $ transformCombineOpsCommon folded "asyncly" sortEq
424 asyncOps $ transformCombineOpsCommon folded "asyncly" sortEq
455 wAsyncOps $ transformCombineOpsCommon folded "wAsyncly" sortEq
425 wAsyncOps $ transformCombineOpsCommon folded "wAsyncly" sortEq
456 parallelOps $ transformCombineOpsCommon folded "parallely" sortEq
426 parallelOps $ transformCombineOpsCommon folded "parallely" sortEq
457− zipSerialOps $ transformCombineOpsCommon folded "zipSerially" (==)
458 zipAsyncOps $ transformCombineOpsCommon folded "zipAsyncly" (==)
427 zipAsyncOps $ transformCombineOpsCommon folded "zipAsyncly" (==)
459
428
460 aheadOps $ transformCombineOpsOrdered S.fromFoldable "aheadly" (==)
429 aheadOps $ transformCombineOpsOrdered S.fromFoldable "aheadly" (==)
461− zipSerialOps $ transformCombineOpsOrdered S.fromFoldable "zipSerially" (==)
462 zipAsyncOps $ transformCombineOpsOrdered S.fromFoldable "zipAsyncly" (==)
430 zipAsyncOps $ transformCombineOpsOrdered S.fromFoldable "zipAsyncly" (==)
463
431
464 aheadOps $ transformCombineOpsOrdered folded "aheadly" (==)
432 aheadOps $ transformCombineOpsOrdered folded "aheadly" (==)
465− zipSerialOps $ transformCombineOpsOrdered folded "zipSerially" (==)
466 zipAsyncOps $ transformCombineOpsOrdered folded "zipAsyncly" (==)
433 zipAsyncOps $ transformCombineOpsOrdered folded "zipAsyncly" (==)
467
434
468 describe "Stream elimination operations" $ do
435 describe "Stream elimination operations" $ do
@@ -470,37 +437,31 @@ main = hspec
470 asyncOps $ eliminationOps S.fromFoldable "asyncly"
437 asyncOps $ eliminationOps S.fromFoldable "asyncly"
471 wAsyncOps $ eliminationOps S.fromFoldable "wAsyncly"
438 wAsyncOps $ eliminationOps S.fromFoldable "wAsyncly"
472 parallelOps $ eliminationOps S.fromFoldable "parallely"
439 parallelOps $ eliminationOps S.fromFoldable "parallely"
473− zipSerialOps $ eliminationOps S.fromFoldable "zipSerially"
474 zipAsyncOps $ eliminationOps S.fromFoldable "zipAsyncly"
440 zipAsyncOps $ eliminationOps S.fromFoldable "zipAsyncly"
475
441
476 aheadOps $ eliminationOps folded "aheadly folded"
442 aheadOps $ eliminationOps folded "aheadly folded"
477 asyncOps $ eliminationOps folded "asyncly folded"
443 asyncOps $ eliminationOps folded "asyncly folded"
478 wAsyncOps $ eliminationOps folded "wAsyncly folded"
444 wAsyncOps $ eliminationOps folded "wAsyncly folded"
479 parallelOps $ eliminationOps folded "parallely folded"
445 parallelOps $ eliminationOps folded "parallely folded"
480− zipSerialOps $ eliminationOps folded "zipSerially folded"
481 zipAsyncOps $ eliminationOps folded "zipAsyncly folded"
446 zipAsyncOps $ eliminationOps folded "zipAsyncly folded"
482
447
483 aheadOps $ eliminationOpsWord8 S.fromFoldable "aheadly"
448 aheadOps $ eliminationOpsWord8 S.fromFoldable "aheadly"
484 asyncOps $ eliminationOpsWord8 S.fromFoldable "asyncly"
449 asyncOps $ eliminationOpsWord8 S.fromFoldable "asyncly"
485 wAsyncOps $ eliminationOpsWord8 S.fromFoldable "wAsyncly"
450 wAsyncOps $ eliminationOpsWord8 S.fromFoldable "wAsyncly"
486 parallelOps $ eliminationOpsWord8 S.fromFoldable "parallely"
451 parallelOps $ eliminationOpsWord8 S.fromFoldable "parallely"
487− zipSerialOps $ eliminationOpsWord8 S.fromFoldable "zipSerially"
488 zipAsyncOps $ eliminationOpsWord8 S.fromFoldable "zipAsyncly"
452 zipAsyncOps $ eliminationOpsWord8 S.fromFoldable "zipAsyncly"
489
453
490 aheadOps $ eliminationOpsWord8 folded "aheadly folded"
454 aheadOps $ eliminationOpsWord8 folded "aheadly folded"
491 asyncOps $ eliminationOpsWord8 folded "asyncly folded"
455 asyncOps $ eliminationOpsWord8 folded "asyncly folded"
492 wAsyncOps $ eliminationOpsWord8 folded "wAsyncly folded"
456 wAsyncOps $ eliminationOpsWord8 folded "wAsyncly folded"
493 parallelOps $ eliminationOpsWord8 folded "parallely folded"
457 parallelOps $ eliminationOpsWord8 folded "parallely folded"
494− zipSerialOps $ eliminationOpsWord8 folded "zipSerially folded"
495 zipAsyncOps $ eliminationOpsWord8 folded "zipAsyncly folded"
458 zipAsyncOps $ eliminationOpsWord8 folded "zipAsyncly folded"
496
459
497 -- XXX Add a test where we chain all transformation APIs and make sure that
460 -- XXX Add a test where we chain all transformation APIs and make sure that
498 -- the state is being passed through all of them.
461 -- the state is being passed through all of them.
499 describe "Stream serial elimination operations" $ do
462 describe "Stream serial elimination operations" $ do
500 aheadOps $ eliminationOpsOrdered S.fromFoldable "aheadly"
463 aheadOps $ eliminationOpsOrdered S.fromFoldable "aheadly"
501− zipSerialOps $ eliminationOpsOrdered S.fromFoldable "zipSerially"
502 zipAsyncOps $ eliminationOpsOrdered S.fromFoldable "zipAsyncly"
464 zipAsyncOps $ eliminationOpsOrdered S.fromFoldable "zipAsyncly"
503
465
504 aheadOps $ eliminationOpsOrdered folded "aheadly folded"
466 aheadOps $ eliminationOpsOrdered folded "aheadly folded"
505− zipSerialOps $ eliminationOpsOrdered folded "zipSerially folded"
506 zipAsyncOps $ eliminationOpsOrdered folded "zipAsyncly folded"
467 zipAsyncOps $ eliminationOpsOrdered folded "zipAsyncly folded"
test/Streamly/Test/Prelude.hs+18
@@ -39,6 +39,7 @@ module Streamly.Test.Prelude
39 , monadBind
39 , monadBind
40 , monadThen
40 , monadThen
41 -- * ZipOperations
41 -- * ZipOperations
42+ , zipApplicative
42 , zipMonadic
43 , zipMonadic
43 -- * Default values
44 -- * Default values
44 , maxTestCount
45 , maxTestCount
@@ -712,6 +713,23 @@ monadBind constr eq t (a, b) = withMaxSuccess maxTestCount $
712-- Zip operations
713-- Zip operations
713-------------------------------------------------------------------------------
714-------------------------------------------------------------------------------
714
715
716+zipApplicative
717+ :: (IsStream t, Applicative (t IO))
718+ => ([Int] -> t IO Int)
719+ -> ([(Int, Int)] -> [(Int, Int)] -> Bool)
720+ -> (t IO (Int, Int) -> SerialT IO (Int, Int))
721+ -> ([Int], [Int])
722+ -> Property
723+zipApplicative constr eq t (a, b) = withMaxSuccess maxTestCount $
724+ monadicIO $ do
725+ stream1 <- run ((S.toList . t) ((,) <$> constr a <*> constr b))
726+ stream2 <- run ((S.toList . t) (pure (,) <*> constr a <*> constr b))
727+ stream3 <- run ((S.toList . t) (S.zipWith (,) (constr a) (constr b)))
728+ let list = getZipList $ (,) <$> ZipList a <*> ZipList b
729+ listEquals eq stream1 list
730+ listEquals eq stream2 list
731+ listEquals eq stream3 list
732+
715zipMonadic
733zipMonadic
716 :: IsStream t
734 :: IsStream t
717 => ([Int] -> t IO Int)
735 => ([Int] -> t IO Int)
test/Streamly/Test/Prelude/ZipSerial.hsnew file+68
@@ -0,0 +1,68 @@
1+-- |
2+-- Module : Streamly.Test.Prelude.ZipSerial
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.ZipSerial 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 zipSerialOps :: IsStream t
31+ => ((ZipSerialM IO a -> t IO a) -> Spec) -> Spec
32+ zipSerialOps spec = mapOps spec $ makeOps zipSerially
33+#ifndef COVERAGE_BUILD
34+ <> [("rate AvgRate 0.00000001", zipSerially . avgRate 0.00000001)]
35+ <> [("maxBuffer (-1)", zipSerially . maxBuffer (-1))]
36+#endif
37+
38+ describe "Functor operations" $ do
39+ zipSerialOps $ functorOps S.fromFoldable "zipSerially" (==)
40+ zipSerialOps $ functorOps folded "zipSerially folded" (==)
41+
42+ describe "Semigroup operations" $ do
43+ zipSerialOps $ semigroupOps "zipSerially" (==)
44+
45+ -- XXX add tests for indexed/indexedR
46+ describe "Zip operations" $ do
47+ zipSerialOps $
48+ prop "zipSerially applicative" . zipApplicative S.fromFoldable (==)
49+ zipSerialOps $
50+ prop "zipSerially applicative folded" . zipApplicative folded (==)
51+
52+ describe "Stream transform and combine operations" $ do
53+ zipSerialOps $ transformCombineOpsCommon S.fromFoldable "zipSerially" (==)
54+ zipSerialOps $ transformCombineOpsCommon folded "zipSerially" (==)
55+ zipSerialOps $ transformCombineOpsOrdered S.fromFoldable "zipSerially" (==)
56+ zipSerialOps $ transformCombineOpsOrdered folded "zipSerially" (==)
57+
58+ describe "Stream elimination operations" $ do
59+ zipSerialOps $ eliminationOps S.fromFoldable "zipSerially"
60+ zipSerialOps $ eliminationOps folded "zipSerially folded"
61+ zipSerialOps $ eliminationOpsWord8 S.fromFoldable "zipSerially"
62+ zipSerialOps $ eliminationOpsWord8 folded "zipSerially folded"
63+
64+ -- XXX Add a test where we chain all transformation APIs and make sure that
65+ -- the state is being passed through all of them.
66+ describe "Stream serial elimination operations" $ do
67+ zipSerialOps $ eliminationOpsOrdered S.fromFoldable "zipSerially"
68+ zipSerialOps $ eliminationOpsOrdered folded "zipSerially folded"