git.iko.soy/streamly
on master help sign in
Create another test group for generation & add multiple gen unfolds
8f0b863adithyaov
test/Streamly/Test/Data/Unfold.hs+106−27
compare with master
unifiedsplit
@@ -13,6 +13,8 @@ import Streamly.Internal.Data.Unfold (Unfold)
13
13
14import qualified Streamly.Internal.Data.Unfold as UF
14import qualified Streamly.Internal.Data.Unfold as UF
15import qualified Streamly.Internal.Data.Stream.IsStream as S
15import qualified Streamly.Internal.Data.Stream.IsStream as S
16+import qualified Streamly.Internal.Data.Stream.StreamD as D
17+import qualified Streamly.Internal.Data.Stream.StreamK as K
16import qualified Prelude
18import qualified Prelude
17import qualified Data.List as List
19import qualified Data.List as List
18
20
@@ -106,6 +108,16 @@ fromStream =
106 $ \n ->
108 $ \n ->
107 testUnfoldD UF.fromStream (S.fromList n :: SerialT Identity Int) n
109 testUnfoldD UF.fromStream (S.fromList n :: SerialT Identity Int) n
108
110
111+fromStreamD :: Property
112+fromStreamD =
113+ property
114+ $ \list -> testUnfoldD UF.fromStreamD (D.fromList list) (list :: [Int])
115+
116+fromStreamK :: Property
117+fromStreamK =
118+ property
119+ $ \list -> testUnfoldD UF.fromStreamK (K.fromList list) (list :: [Int])
120+
109nilM :: Bool
121nilM :: Bool
110nilM =
122nilM =
111 let unf = UF.nilM put
123 let unf = UF.nilM put
@@ -132,6 +144,18 @@ const =
132 let unf = UF.take 10 $ UF.const (modify (+ 1) >> get)
144 let unf = UF.take 10 $ UF.const (modify (+ 1) >> get)
133 in testUnfoldAD unf 0 10 (0 :: Int) [1 .. 10]
145 in testUnfoldAD unf 0 10 (0 :: Int) [1 .. 10]
134
146
147+unfoldrM :: Property
148+unfoldrM =
149+ property
150+ $ \gen ->
151+ let genA = apply gen :: Int -> Maybe (Int, Int)
152+ genM x = modify (+ 1) >> return (genA x)
153+ list = Prelude.take 100 $ List.unfoldr genA 1
154+ unf = UF.take 100 $ UF.unfoldrM genM
155+ ll = length list
156+ fs = if ll < 100 then ll + 1 else 100
157+ in testUnfoldAD unf 0 fs 1 list
158+
135fromListM :: Property
159fromListM :: Property
136fromListM =
160fromListM =
137 property
161 property
@@ -143,7 +167,7 @@ replicateM :: Property
143replicateM =
167replicateM =
144 property
168 property
145 $ \i ->
169 $ \i ->
146− let ns = max 0 i + 1
170+ let ns = max 0 i
147 seed = modify (+ 1) >> get
171 seed = modify (+ 1) >> get
148 in testUnfoldAD (UF.replicateM i) 0 ns seed [1 .. i]
172 in testUnfoldAD (UF.replicateM i) 0 ns seed [1 .. i]
149
173
@@ -151,6 +175,56 @@ repeatM :: Bool
151repeatM =
175repeatM =
152 testUnfoldAD (UF.take 10 UF.repeatM) 0 10 (modify (+ 1) >> get) [1 .. 10]
176 testUnfoldAD (UF.take 10 UF.repeatM) 0 10 (modify (+ 1) >> get) [1 .. 10]
153
177
178+iterateM :: Property
179+iterateM =
180+ property
181+ $ \next ->
182+ let nextA = apply next :: Int -> Int
183+ nextM x = modify (+ 1) >> return (nextA x)
184+ list = Prelude.take 100 $ List.iterate nextA 1
185+ unf = UF.take 100 $ UF.iterateM nextM
186+ in testUnfoldAD unf 0 110 (modify (+ 10) >> return 1) list
187+
188+fromIndicesM :: Property
189+fromIndicesM =
190+ property
191+ $ \indF ->
192+ let indFA = apply indF :: Int -> Int
193+ indFM x = modify (+ 1) >> return (indFA x)
194+ list = Prelude.take 100 $ Prelude.map indFA [1 ..]
195+ unf = UF.take 100 $ UF.fromIndicesM indFM
196+ in testUnfoldAD unf 0 (length list) 1 list
197+
198+enumerateFromStepNum :: Property
199+enumerateFromStepNum =
200+ property
201+ $ \f s ->
202+ let unf = UF.take 10 $ UF.enumerateFromStepNum s
203+ lst = Prelude.take 10 $ List.unfoldr (\x -> Just (x, x + s)) f
204+ in testUnfoldD unf f lst
205+
206+enumerateFromToFractional :: Property
207+enumerateFromToFractional =
208+ property
209+ $ \f t ->
210+ let unf = UF.enumerateFromToFractional (t :: Double)
211+ in testUnfold unf (f :: Double) [f .. t]
212+
213+enumerateFromStepIntegral :: Property
214+enumerateFromStepIntegral =
215+ property
216+ $ \f s ->
217+ let unf = UF.take 10 UF.enumerateFromStepIntegral
218+ lst = Prelude.take 10 $ List.unfoldr (\x -> Just (x, x + s)) f
219+ in testUnfoldD unf (f, s) lst
220+
221+enumerateFromToIntegral :: Property
222+enumerateFromToIntegral =
223+ property
224+ $ \f t ->
225+ let unf = UF.enumerateFromToIntegral t
226+ in testUnfoldD unf f [f .. t]
227+
154take :: Property
228take :: Property
155take =
229take =
156 property
230 property
@@ -207,21 +281,6 @@ dropWhileM =
207 fS = Prelude.length n - Prelude.length fL
281 fS = Prelude.length n - Prelude.length fL
208 in testUnfoldAD unf 0 fS n fL
282 in testUnfoldAD unf 0 fS n fL
209
283
210−enumerateFromStepIntegral :: Property
211−enumerateFromStepIntegral =
212− property
213− $ \f s ->
214− let unf = UF.take 10 UF.enumerateFromStepIntegral
215− lst = Prelude.take 10 $ List.unfoldr (\x -> Just (x, x + s)) f
216− in testUnfoldD unf (f, s) lst
217−
218−enumerateFromToIntegral :: Property
219−enumerateFromToIntegral =
220− property
221− $ \f t ->
222− let unf = UF.enumerateFromToIntegral t
223− in testUnfoldD unf f [f .. t]
224−
225zipWithM :: Property
284zipWithM :: Property
226zipWithM =
285zipWithM =
227 property
286 property
@@ -267,6 +326,36 @@ testInputOps =
267 prop "discardSecond" discardSecond
326 prop "discardSecond" discardSecond
268 prop "swap" swap
327 prop "swap" swap
269
328
329+testGeneration :: Spec
330+testGeneration =
331+ describe "Generation"
332+ $ do
333+ prop "fromStream" fromStream
334+ prop "fromStreamK" fromStreamK
335+ prop "fromStreamD" fromStreamD
336+ prop "nilM" nilM
337+ prop "consM" consM
338+ prop "effect" effect
339+ prop "singletonM" singletonM
340+ -- prop "singleton" singleton
341+ -- prop "identity" identity
342+ prop "const" const
343+ prop "unfoldrM" unfoldrM
344+ -- prop "fromList" fromList
345+ prop "fromListM" fromListM
346+ -- prop "fromSVar" fromSVar
347+ -- prop "fromProducer" fromProducer
348+ prop "replicateM" replicateM
349+ prop "repeatM" repeatM
350+ prop "iterateM" iterateM
351+ prop "fromIndicesM" fromIndicesM
352+ prop "enumerateFromStepIntegral" enumerateFromStepIntegral
353+ prop "enumerateFromToIntegral" enumerateFromToIntegral
354+ -- prop "enumerateFromIntegral" enumerateFromIntegral
355+ prop "enumerateFromStepNum" enumerateFromStepNum
356+ -- prop "numFrom" numFrom
357+ prop "enumerateFromToFractional" enumerateFromToFractional
358+
270-------------------------------------------------------------------------------
359-------------------------------------------------------------------------------
271-- Main
360-- Main
272-------------------------------------------------------------------------------
361-------------------------------------------------------------------------------
@@ -274,23 +363,13 @@ testInputOps =
274main :: IO ()
363main :: IO ()
275main = hspec $ do
364main = hspec $ do
276 testInputOps
365 testInputOps
366+ testGeneration
277 describe "Unfold tests" $ do
367 describe "Unfold tests" $ do
278− prop "fromStream" fromStream
279− prop "nilM" nilM
280− prop "consM" consM
281− prop "effect" effect
282− prop "singletonM" singletonM
283− prop "const" const
284− prop "fromListM" fromListM
285− prop "replicateM" replicateM
286− prop "repeatM" repeatM
287 prop "take" take
368 prop "take" take
288 prop "takeWhileM" takeWhileM
369 prop "takeWhileM" takeWhileM
289 prop "filterM" filterM
370 prop "filterM" filterM
290 prop "drop" drop
371 prop "drop" drop
291 prop "dropWhileM" dropWhileM
372 prop "dropWhileM" dropWhileM
292− prop "enumerateFromStepIntegral" enumerateFromStepIntegral
293− prop "enumerateFromToIntegral" enumerateFromToIntegral
294 prop "zipWithM" zipWithM
373 prop "zipWithM" zipWithM
295 prop "concat" concat
374 prop "concat" concat
296 prop "outerProduct" outerProduct
375 prop "outerProduct" outerProduct