Refactor Async ops into a separate test suite.

streamly.cabal

@@ -624,6 +624,14 @@ test-suite Prelude.Ahead
   other-modules:   Streamly.Test.Common
                  , Streamly.Test.Prelude
 
+test-suite Prelude.Async
+  import: test-options, prelude-test-options
+  type: exitcode-stdio-1.0
+  main-is: Streamly/Test/Prelude/Async.hs
+  ghc-options: -main-is Streamly.Test.Prelude.Async.main
+  other-modules:   Streamly.Test.Common
+                 , Streamly.Test.Prelude
+
 test-suite array-test
   import: test-options
   type: exitcode-stdio-1.0

test/Prop.hs

@@ -229,11 +229,6 @@ main = hspec
 #endif
             ]
 
-    let asyncOps :: IsStream t => ((AsyncT IO a -> t IO a) -> Spec) -> Spec
-        asyncOps spec = mapOps spec $ makeOps asyncly
-#ifndef COVERAGE_BUILD
-            <> [("maxBuffer (-1)", asyncly . maxBuffer (-1))]
-#endif
     let wAsyncOps :: IsStream t => ((WAsyncT IO a -> t IO a) -> Spec) -> Spec
         wAsyncOps spec = mapOps spec $ makeOps wAsyncly
 #ifndef COVERAGE_BUILD
@@ -255,7 +250,6 @@ main = hspec
             mapOps spec $ makeConcurrentAppOps parallely <> parallelCommonOps
 
     describe "Construction" $ do
-        asyncOps    $ prop "asyncly replicateM" . constructWithReplicateM
         wAsyncOps   $ prop "wAsyncly replicateM" . constructWithReplicateM
         parallelOps $ prop "parallely replicateM" .  constructWithReplicateM
 
@@ -269,21 +263,16 @@ main = hspec
         -- XXX add tests for fromIndices
 
     describe "Functor operations" $ do
-        asyncOps     $ functorOps S.fromFoldable "asyncly" sortEq
-        asyncOps     $ functorOps folded "asyncly folded" sortEq
         wAsyncOps    $ functorOps S.fromFoldable "wAsyncly" sortEq
         wAsyncOps    $ functorOps folded "wAsyncly folded" sortEq
         parallelOps  $ functorOps S.fromFoldable "parallely" sortEq
         parallelOps  $ functorOps folded "parallely folded" sortEq
 
     describe "Semigroup operations" $ do
-        asyncOps     $ semigroupOps "asyncly" sortEq
         wAsyncOps    $ semigroupOps "wAsyncly" sortEq
         parallelOps  $ semigroupOps "parallely" sortEq
 
     describe "Applicative operations" $ do
-        asyncOps    $ prop "asyncly applicative" . applicativeOps S.fromFoldable sortEq
-        asyncOps    $ prop "asyncly applicative folded" . applicativeOps folded sortEq
         wAsyncOps   $ prop "wAsyncly applicative" . applicativeOps S.fromFoldable sortEq
         wAsyncOps   $ prop "wAsyncly applicative folded" . applicativeOps folded sortEq
         parallelOps $ prop "parallely applicative folded" . applicativeOps folded sortEq
@@ -293,8 +282,6 @@ main = hspec
         -- We test only the serial zip with serial streams and the parallel
         -- stream, because the rate setting in these streams can slow down
         -- zipAsync.
-        asyncOps    $ prop "zip monadic asyncly" . zipAsyncMonadic S.fromFoldable (==)
-        asyncOps    $ prop "zip monadic asyncly folded" . zipAsyncMonadic folded (==)
         wAsyncOps   $ prop "zip monadic wAsyncly" . zipAsyncMonadic S.fromFoldable (==)
         wAsyncOps   $ prop "zip monadic wAsyncly folded" . zipAsyncMonadic folded (==)
         parallelOps $ prop "zip monadic parallely" . zipMonadic S.fromFoldable (==)
@@ -306,19 +293,15 @@ main = hspec
     -- describe "Merge operations" $ do
 
     describe "Monad operations" $ do
-        asyncOps    $ prop "asyncly monad then" . monadThen S.fromFoldable sortEq
         wAsyncOps   $ prop "wAsyncly monad then" . monadThen S.fromFoldable sortEq
         parallelOps $ prop "parallely monad then" . monadThen S.fromFoldable sortEq
 
-        asyncOps    $ prop "asyncly monad then folded" . monadThen folded sortEq
         wAsyncOps   $ prop "wAsyncly monad then folded" . monadThen folded sortEq
         parallelOps $ prop "parallely monad then folded" . monadThen folded sortEq
 
-        asyncOps    $ prop "asyncly monad bind" . monadBind S.fromFoldable sortEq
         wAsyncOps   $ prop "wAsyncly monad bind" . monadBind S.fromFoldable sortEq
         parallelOps $ prop "parallely monad bind" . monadBind S.fromFoldable sortEq
 
-        asyncOps    $ prop "asyncly monad bind folded"   . monadBind folded sortEq
         wAsyncOps   $ prop "wAsyncly monad bind folded"  . monadBind folded sortEq
         parallelOps $ prop "parallely monad bind folded" . monadBind folded sortEq
 
@@ -349,7 +332,7 @@ main = hspec
 
     describe "Concurrent application" $ do
 --        serialOps $ prop "serial" . concurrentApplication (==)
-        asyncOps $ prop "async" . concurrentApplication sortEq
+--        asyncOps $ prop "async" . concurrentApplication sortEq
 --        aheadOps $ prop "ahead" . concurrentApplication (==)
         parallelConcurrentAppOps $
             prop "parallel" . concurrentApplication sortEq
@@ -360,27 +343,21 @@ main = hspec
             concurrentFoldlApplication
 
     describe "Stream transform and combine operations" $ do
-        asyncOps     $ transformCombineOpsCommon S.fromFoldable "asyncly" sortEq
         wAsyncOps    $ transformCombineOpsCommon S.fromFoldable "wAsyncly" sortEq
         parallelOps  $ transformCombineOpsCommon S.fromFoldable "parallely" sortEq
 
-        asyncOps     $ transformCombineOpsCommon folded "asyncly" sortEq
         wAsyncOps    $ transformCombineOpsCommon folded "wAsyncly" sortEq
         parallelOps  $ transformCombineOpsCommon folded "parallely" sortEq
 
     describe "Stream elimination operations" $ do
-        asyncOps     $ eliminationOps S.fromFoldable "asyncly"
         wAsyncOps    $ eliminationOps S.fromFoldable "wAsyncly"
         parallelOps  $ eliminationOps S.fromFoldable "parallely"
 
-        asyncOps     $ eliminationOps folded "asyncly folded"
         wAsyncOps    $ eliminationOps folded "wAsyncly folded"
         parallelOps  $ eliminationOps folded "parallely folded"
 
-        asyncOps     $ eliminationOpsWord8 S.fromFoldable "asyncly"
         wAsyncOps    $ eliminationOpsWord8 S.fromFoldable "wAsyncly"
         parallelOps  $ eliminationOpsWord8 S.fromFoldable "parallely"
 
-        asyncOps     $ eliminationOpsWord8 folded "asyncly folded"
         wAsyncOps    $ eliminationOpsWord8 folded "wAsyncly folded"
         parallelOps  $ eliminationOpsWord8 folded "parallely folded"

test/Streamly/Test/Prelude/Async.hs

@@ -0,0 +1,77 @@
+-- |
+-- Module      : Streamly.Test.Prelude.Async
+-- Copyright   : (c) 2020 Composewell Technologies
+--
+-- License     : BSD-3-Clause
+-- Maintainer  : streamly@composewell.com
+-- Stability   : experimental
+-- Portability : GHC
+
+module Streamly.Test.Prelude.Async where
+
+#if __GLASGOW_HASKELL__ < 808
+import Data.Semigroup ((<>))
+#endif
+import Test.Hspec.QuickCheck
+import Test.Hspec as H
+
+import Streamly
+import qualified Streamly.Prelude as S
+
+import Streamly.Test.Prelude
+
+main :: IO ()
+main = hspec
+    $ H.parallel
+#ifdef COVERAGE_BUILD
+    $ modifyMaxSuccess (const 10)
+#endif
+    $ do
+    let asyncOps :: IsStream t => ((AsyncT IO a -> t IO a) -> Spec) -> Spec
+        asyncOps spec = mapOps spec $ makeOps asyncly
+#ifndef COVERAGE_BUILD
+            <> [("maxBuffer (-1)", asyncly . maxBuffer (-1))]
+#endif
+
+    describe "Construction" $ do
+        asyncOps    $ prop "asyncly replicateM" . constructWithReplicateM
+
+    describe "Functor operations" $ do
+        asyncOps     $ functorOps S.fromFoldable "asyncly" sortEq
+        asyncOps     $ functorOps folded "asyncly folded" sortEq
+
+    describe "Semigroup operations" $ do
+        asyncOps     $ semigroupOps "asyncly" sortEq
+
+    describe "Applicative operations" $ do
+        asyncOps    $ prop "asyncly applicative" . applicativeOps S.fromFoldable sortEq
+        asyncOps    $ prop "asyncly applicative folded" . applicativeOps folded sortEq
+
+    -- XXX add tests for indexed/indexedR
+    describe "Zip operations" $ do
+        -- We test only the serial zip with serial streams and the parallel
+        -- stream, because the rate setting in these streams can slow down
+        -- zipAsync.
+        asyncOps    $ prop "zip monadic asyncly" . zipAsyncMonadic S.fromFoldable (==)
+        asyncOps    $ prop "zip monadic asyncly folded" . zipAsyncMonadic folded (==)
+
+    -- XXX add merge tests like zip tests
+    -- for mergeBy, we can split a list randomly into two lists and
+    -- then merge them, it should result in original list
+    -- describe "Merge operations" $ do
+
+    describe "Monad operations" $ do
+        asyncOps    $ prop "asyncly monad then" . monadThen S.fromFoldable sortEq
+        asyncOps    $ prop "asyncly monad then folded" . monadThen folded sortEq
+        asyncOps    $ prop "asyncly monad bind" . monadBind S.fromFoldable sortEq
+        asyncOps    $ prop "asyncly monad bind folded"   . monadBind folded sortEq
+
+    describe "Stream transform and combine operations" $ do
+        asyncOps     $ transformCombineOpsCommon S.fromFoldable "asyncly" sortEq
+        asyncOps     $ transformCombineOpsCommon folded "asyncly" sortEq
+
+    describe "Stream elimination operations" $ do
+        asyncOps     $ eliminationOps S.fromFoldable "asyncly"
+        asyncOps     $ eliminationOps folded "asyncly folded"
+        asyncOps     $ eliminationOpsWord8 S.fromFoldable "asyncly"
+        asyncOps     $ eliminationOpsWord8 folded "asyncly folded"