@@ -4,8 +4,6 @@ import qualified Streamly.Internal.Data.Parser.ParserD as D
44import qualified Streamly.Internal.Prelude as S
55import qualified Streamly.Internal.Data.Fold as FL
66
7−import Data.List (partition)
8−
97import Test.Hspec(hspec, describe)
108import Test.Hspec.QuickCheck
119import Test.QuickCheck (forAll, chooseInt, Property, property, listOf, vectorOf, (.&&.))
@@ -238,17 +236,53 @@ teeWith =
238236 Right _ -> False
239237 Left _ -> True)
240238
241−-- deintercalate :: Property
242−-- deintercalate =
243−-- forAll (listOf (chooseInt (0, 1))) $ \ls ->
244−-- case S.parseD (D.deintercalate concatFold prsr_1 concatFold prsr_2) (S.fromList ls) of
245−-- Right parsed_list_tuple -> parsed_list_tuple == partition (== 0) ls
246−-- Left _ -> False
239+shortest :: Property
240+shortest =
241+ forAll (listOf (chooseInt(0, 10000))) $ \ls ->
242+ let
243+ prsr_1 = D.takeWhile (<= 2500) FL.toList
244+ prsr_2 = D.takeWhile (<= 5000) FL.toList
245+ prsr_shortest = D.shortest prsr_1 prsr_2
246+ in
247+ case S.parseD prsr_shortest (S.fromList ls) of
248+ Right short_list -> short_list == Prelude.takeWhile (<= 2500) ls
249+ Left _ -> False
250+ .&&.
251+ property (case S.parseD (D.shortest (D.die "die") (D.yield (1 :: Int))) (S.fromList [1 :: Int]) of
252+ Right r -> r == 1
253+ Left _ -> False)
254+ .&&.
255+ property (case S.parseD (D.shortest (D.yield (1 :: Int)) (D.die "die")) (S.fromList [1 :: Int]) of
256+ Right r -> r == 1
257+ Left _ -> False)
258+ .&&.
259+ property (case S.parseD (D.shortest (D.die "die") (D.die "die")) (S.fromList [1 :: Int]) of
260+ Right _ -> False
261+ Left _ -> True)
247262
248−-- where
249−-- prsr_1 = (D.takeWhile (== 0) FL.toList)
250−-- prsr_2 = (D.takeWhile (== 1) FL.toList)
251−-- concatFold = FL.Fold (\concatList curr_list -> return $ concatList ++ curr_list) (return []) return
263+longest :: Property
264+longest =
265+ forAll (listOf (chooseInt(0, 10000))) $ \ls ->
266+ let
267+ prsr_1 = D.takeWhile (<= 2500) FL.toList
268+ prsr_2 = D.takeWhile (<= 5000) FL.toList
269+ prsr_longest = D.longest prsr_1 prsr_2
270+ in
271+ case S.parseD prsr_longest (S.fromList ls) of
272+ Right long_list -> long_list == Prelude.takeWhile (<= 5000) ls
273+ Left _ -> False
274+ .&&.
275+ property (case S.parseD (D.shortest (D.die "die") (D.yield (1 :: Int))) (S.fromList [1 :: Int]) of
276+ Right r -> r == 1
277+ Left _ -> False)
278+ .&&.
279+ property (case S.parseD (D.shortest (D.yield (1 :: Int)) (D.die "die")) (S.fromList [1 :: Int]) of
280+ Right r -> r == 1
281+ Left _ -> False)
282+ .&&.
283+ property (case S.parseD (D.shortest (D.die "die") (D.die "die")) (S.fromList [1 :: Int]) of
284+ Right _ -> False
285+ Left _ -> True)
252286
253287main :: IO ()
254288main = hspec $ do
@@ -277,4 +311,5 @@ main = hspec $ do
277311 -- prop "test for sliceSepByMax function" sliceSepByMax
278312 prop "test for splitWith function" splitWith
279313 prop "test for teeWith function" teeWith
280− -- prop "test for deintercalate function" deintercalate
314+ prop "test for shortest function" shortest
315+ prop "test for longest function" longest