composewell/streamly
1
1
Fork 0
mirror of https://github.com/composewell/streamly.git synced 2024-09-11 11:37:22 +03:00
Code Issues Packages Projects Releases Wiki Activity

Use CPP macro for ParserK tests

Browse Source
This commit is contained in:
Ranjeet Kumar Ranjan 2023-08-19 14:06:23 +05:30
parent a819eb7e5d
commit 61305730f2
3 changed files with 194 additions and 929 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

284
test/Streamly/Test/Data/Parser.hs
View File

@ -1,3 +1,5 @@
{-# LANGUAGE CPP #-}
module Main (main) where
import Control.Applicative ((<|>))
@ -25,6 +27,11 @@ import qualified Streamly.Internal.Data.Producer as Producer
import qualified Streamly.Internal.Data.Unfold as Unfold
import qualified Test.Hspec as H
#ifdef PARSER_K
import qualified Streamly.Internal.Data.StreamK as SK
import qualified Streamly.Data.ParserK as PR
#endif
#if MIN_VERSION_QuickCheck(2,14,0)
import Test.QuickCheck (chooseAny)
@ -59,11 +66,26 @@ max_length = 1000
-- Accumulator Tests
#ifdef PARSER_K
streamOfArray :: [Int] -> SK.StreamK m (A.Array Int)
streamOfArray = SK.fromPure . A.fromList
#define INPUT_FROM_LIST streamOfArray
#define PARSER_RUNNER SK.parseChunks
#define FROM_PARSER_D PR.adaptC
#else
#define INPUT_FROM_LIST S.fromList
#define PARSER_RUNNER S.parse
#define FROM_PARSER_D
#endif
fromFold :: Property
fromFold =
forAll (listOf $ chooseInt (min_value, max_value)) $ \ls ->
monadicIO $ do
s1 <- S.parse (P.fromFold FL.sum) (S.fromList ls)
s1 <- PARSER_RUNNER
(FROM_PARSER_D (P.fromFold FL.sum))
(INPUT_FROM_LIST ls)
o2 <- S.fold FL.sum (S.fromList ls)
return $
case s1 of
@ -73,35 +95,45 @@ fromFold =
fromPure :: Property
fromPure =
forAll (chooseInt (min_value, max_value)) $ \x ->
case runIdentity $ S.parse (P.fromPure x) (S.fromList [1 :: Int]) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.fromPure x))
(INPUT_FROM_LIST [1 :: Int]) of
Right r -> r == x
Left _ -> False
fromEffect :: Property
fromEffect =
forAll (chooseInt (min_value, max_value)) $ \x ->
case runIdentity $ S.parse (P.fromEffect $ return x) (S.fromList [1 :: Int]) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.fromEffect $ return x))
(INPUT_FROM_LIST [1 :: Int]) of
Right r -> r == x
Left _ -> False
die :: Property
die =
property $
case runIdentity $ S.parse (P.die "die test") (S.fromList [0 :: Int]) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.die "die test"))
(INPUT_FROM_LIST [0 :: Int]) of
Right _ -> False
Left _ -> True
dieM :: Property
dieM =
property $
case runIdentity $ S.parse (P.dieM (Identity "die test")) (S.fromList [0 :: Int]) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.dieM (Identity "die test")))
(INPUT_FROM_LIST [0 :: Int]) of
Right _ -> False
Left _ -> True
parserFail :: Property
parserFail =
property $
case runIdentity $ S.parse (Fail.fail err) (S.fromList [0 :: Int]) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (Fail.fail err))
(INPUT_FROM_LIST [0 :: Int]) of
Right _ -> False
Left (ParseError e) -> err == e
where
@ -113,7 +145,9 @@ peekPass :: Property
peekPass =
forAll (chooseInt (1, max_length)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parse P.peek (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D P.peek)
(INPUT_FROM_LIST ls) of
Right head_value -> case ls of
head_ls : _ -> head_value == head_ls
_ -> False
@ -121,13 +155,17 @@ peekPass =
peekFail :: Property
peekFail =
property (case runIdentity $ S.parse P.peek (S.fromList []) of
property (case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D P.peek)
(INPUT_FROM_LIST []) of
Right _ -> False
Left _ -> True)
eofPass :: Property
eofPass =
property (case runIdentity $ S.parse P.eof (S.fromList []) of
property (case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D P.eof)
(INPUT_FROM_LIST []) of
Right _ -> True
Left _ -> False)
@ -135,7 +173,9 @@ eofFail :: Property
eofFail =
forAll (chooseInt (1, max_length)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parse P.eof (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D P.eof)
(INPUT_FROM_LIST ls) of
Right _ -> False
Left _ -> True
@ -147,14 +187,18 @@ satisfyPass =
ls = first_element : ls_tail
predicate = (>= mid_value)
in
case runIdentity $ S.parse (P.satisfy predicate) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.satisfy predicate))
(INPUT_FROM_LIST ls) of
Right r -> r == first_element
Left _ -> False
satisfy :: Property
satisfy =
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parse (P.satisfy predicate) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.satisfy predicate))
(INPUT_FROM_LIST ls) of
Right r -> case ls of
[] -> False
(x : _) -> predicate x && (r == x)
@ -167,14 +211,16 @@ satisfy =
onePass :: Property
onePass =
forAll (chooseInt (1, max_value)) $ \int ->
property (case runIdentity $ S.parse P.one (S.fromList [int]) of
property (case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D P.one) (INPUT_FROM_LIST [int]) of
Right i -> i == int
Left _ -> False)
one :: Property
one =
property $
case runIdentity $ S.parse P.one (S.fromList []) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D P.one) (INPUT_FROM_LIST []) of
Left _ -> True
Right _ -> False
@ -186,8 +232,9 @@ takeBetweenPass =
forAll (chooseInt (m, max_value)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value)))
$ \ls ->
case runIdentity $ S.parse (P.takeBetween m n FL.toList)
(S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.takeBetween m n FL.toList))
(INPUT_FROM_LIST ls) of
Right parsed_list ->
let lpl = Prelude.length parsed_list
in checkListEqual parsed_list
@ -207,7 +254,9 @@ takeBetween =
let inputLen = Prelude.length ls
in do
let p = P.takeBetween m n FL.toList
case runIdentity $ S.parse p (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D p)
(INPUT_FROM_LIST ls) of
Right xs ->
let parsedLen = Prelude.length xs
in if inputLen >= m && parsedLen >= m && parsedLen <= n
@ -220,7 +269,9 @@ take :: Property
take =
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parse (P.fromFold $ FL.take n FL.toList) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.fromFold $ FL.take n FL.toList))
(INPUT_FROM_LIST ls) of
Right parsed_list -> checkListEqual parsed_list (Prelude.take n ls)
Left _ -> property False
@ -230,7 +281,9 @@ takeEQPass =
forAll (chooseInt (n, max_value)) $ \list_length ->
forAll (vectorOf list_length
(chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parse (P.takeEQ n FL.toList) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.takeEQ n FL.toList))
(INPUT_FROM_LIST ls) of
Right parsed_list ->
checkListEqual parsed_list (Prelude.take n ls)
Left _ -> property False
@ -242,7 +295,9 @@ takeEQ =
let
list_length = Prelude.length ls
in
case runIdentity $ S.parse (P.takeEQ n FL.toList) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.takeEQ n FL.toList))
(INPUT_FROM_LIST ls) of
Right parsed_list ->
if n <= list_length
then checkListEqual parsed_list (Prelude.take n ls)
@ -255,7 +310,9 @@ takeGEPass =
forAll (chooseInt (n, max_value)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value)))
$ \ls ->
case runIdentity $ S.parse (P.takeGE n FL.toList) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.takeGE n FL.toList))
(INPUT_FROM_LIST ls) of
Right parsed_list -> checkListEqual parsed_list ls
Left _ -> property False
@ -266,7 +323,9 @@ takeGE =
let
list_length = Prelude.length ls
in
case runIdentity $ S.parse (P.takeGE n FL.toList) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.takeGE n FL.toList))
(INPUT_FROM_LIST ls) of
Right parsed_list ->
if n <= list_length
then checkListEqual parsed_list ls
@ -283,7 +342,8 @@ nLessThanEqual0 ::
nLessThanEqual0 tk ltk =
forAll (elements [0, (-1)]) $ \n ->
forAll (listOf arbitrary) $ \ls ->
case runIdentity $ S.parse (tk n FL.toList) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (tk n FL.toList)) (INPUT_FROM_LIST ls) of
Right parsed_list -> checkListEqual parsed_list (ltk n ls)
Left _ -> property False
@ -309,7 +369,8 @@ lookAheadPass =
in
forAll (chooseInt (n+1, max_value)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parse parseTwice (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D parseTwice) (INPUT_FROM_LIST ls) of
Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
Left _ -> property $ False
@ -325,7 +386,7 @@ lookAheadPass =
-- in
-- forAll (chooseInt (min_value, n - 1)) $ \list_length ->
-- forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
-- case S.parse parseTwice (S.fromList ls) of
-- case PARSER_RUNNER parseTwice (INPUT_FROM_LIST ls) of
-- Right _ -> False
-- Left _ -> True
@ -340,7 +401,8 @@ lookAhead =
return (parsed_list_1, parsed_list_2)
in
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parse parseTwice (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D parseTwice) (INPUT_FROM_LIST ls) of
Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
Left _ -> property ((list_length < n) || (list_length == n && n == 0))
where
@ -349,7 +411,8 @@ lookAhead =
takeEndBy_ :: Property
takeEndBy_ =
forAll (listOf (chooseInt (min_value, max_value ))) $ \ls ->
case runIdentity $ S.parse (P.takeEndBy_ predicate prsr) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.takeEndBy_ predicate prsr)) (INPUT_FROM_LIST ls) of
Right parsed_list ->
checkListEqual parsed_list (tkwhl ls)
Left _ -> property False
@ -362,7 +425,9 @@ takeEndByOrMax_ :: Property
takeEndByOrMax_ =
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (listOf (chooseInt (0, 1))) $ \ls ->
case runIdentity $ S.parse (P.fromFold $ FL.takeEndBy_ predicate (FL.take n FL.toList)) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.fromFold $ FL.takeEndBy_ predicate (FL.take n FL.toList)))
(INPUT_FROM_LIST ls) of
Right parsed_list -> checkListEqual parsed_list (Prelude.take n (Prelude.takeWhile (not . predicate) ls))
Left _ -> property False
where
@ -373,7 +438,8 @@ takeStartBy =
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
let ls1 = 1:ls
in
case runIdentity $ S.parse parser (S.fromList ls1) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D parser) (INPUT_FROM_LIST ls1) of
Right parsed_list ->
if not $ Prelude.null ls1
then
@ -391,7 +457,8 @@ takeStartBy =
takeWhile :: Property
takeWhile =
forAll (listOf (chooseInt (0, 1))) $ \ ls ->
case runIdentity $ S.parse (P.takeWhile predicate FL.toList) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.takeWhile predicate FL.toList)) (INPUT_FROM_LIST ls) of
Right parsed_list ->
checkListEqual parsed_list (Prelude.takeWhile predicate ls)
Left _ -> property False
@ -404,9 +471,10 @@ takeP =
((,) <$> chooseInt (min_value, max_value)
<*> listOf (chooseInt (0, 1)))
$ \(takeNum, ls) ->
case runIdentity $ S.parse
(P.takeP takeNum (P.fromFold FL.toList))
(S.fromList ls) of
case runIdentity $
PARSER_RUNNER
(FROM_PARSER_D (P.takeP takeNum (P.fromFold FL.toList)))
(INPUT_FROM_LIST ls) of
Right parsed_list ->
checkListEqual parsed_list (Prelude.take takeNum ls)
Left _ -> property False
@ -414,7 +482,8 @@ takeP =
takeWhile1 :: Property
takeWhile1 =
forAll (listOf (chooseInt (0, 1))) $ \ ls ->
case runIdentity $ S.parse (P.takeWhile1 predicate FL.toList) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.takeWhile1 predicate FL.toList)) (INPUT_FROM_LIST ls) of
Right parsed_list -> case ls of
[] -> property False
(x : _) ->
@ -444,7 +513,8 @@ takeWhileP =
takeWhileTillLen maxLen prd list =
Prelude.take maxLen $ Prelude.takeWhile prd list
in
case runIdentity $ S.parse prsr (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
Right parsed_list ->
checkListEqual
parsed_list
@ -459,7 +529,7 @@ choice =
<*> chooseInt (min_value, max_value)
<*> listOf (chooseInt (0, 1)))
$ \(i, j, ls) ->
case S.parse (P.choice [parser i, parser j]) (S.fromList ls) of
case PARSER_RUNNER (FROM_PARSER_D (P.choice [parser i, parser j])) (INPUT_FROM_LIST ls) of
Right parsed_list ->
checkListEqual parsed_list $ take (min i j) ls
Left _ -> property False
@ -473,7 +543,8 @@ groupBy :: Property
groupBy =
forAll (listOf (chooseInt (0, 1)))
$ \ls ->
case runIdentity $ S.parse parser (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D parser) (INPUT_FROM_LIST ls) of
Right parsed -> checkListEqual parsed (groupByLF ls)
Left _ -> property False
@ -489,7 +560,8 @@ groupByRolling :: Property
groupByRolling =
forAll (listOf (chooseInt (0, 1)))
$ \ls ->
case runIdentity $ S.parse parser (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D parser) (INPUT_FROM_LIST ls) of
Right parsed -> checkListEqual parsed (groupByLF Nothing ls)
Left _ -> property False
@ -508,12 +580,18 @@ wordBy :: Property
wordBy =
forAll (listOf (elements [' ', 's']))
$ \ls ->
case runIdentity $ S.parse parser (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D parser) (strm ls) of
Right parsed -> checkListEqual parsed (words' ls)
Left _ -> property False
where
#ifdef PARSER_K
strm = SK.fromPure . A.fromList
#else
strm = S.fromList
#endif
predicate = (== ' ')
parser = P.many (P.wordBy predicate FL.toList) FL.toList
words' lst =
@ -573,7 +651,9 @@ parseManyWordQuotedBy =
splitWith :: Property
splitWith =
forAll (listOf (chooseInt (0, 1))) $ \ls ->
case runIdentity $ S.parse (P.splitWith (,) (P.satisfy (== 0)) (P.satisfy (== 1))) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.splitWith (,) (P.satisfy (== 0)) (P.satisfy (== 1))))
(INPUT_FROM_LIST ls) of
Right (result_first, result_second) -> case ls of
0 : 1 : _ -> (result_first == 0) && (result_second == 1)
_ -> False
@ -583,19 +663,25 @@ splitWith =
splitWithFailLeft :: Property
splitWithFailLeft =
property (case runIdentity $ S.parse (P.splitWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
property (case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.splitWith (,) (P.die "die") (P.fromPure (1 :: Int))))
(INPUT_FROM_LIST [1 :: Int]) of
Right _ -> False
Left _ -> True)
splitWithFailRight :: Property
splitWithFailRight =
property (case runIdentity $ S.parse (P.splitWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
property (case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.splitWith (,) (P.fromPure (1 :: Int)) (P.die "die")))
(INPUT_FROM_LIST [1 :: Int]) of
Right _ -> False
Left _ -> True)
splitWithFailBoth :: Property
splitWithFailBoth =
property (case runIdentity $ S.parse (P.splitWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
property (case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.splitWith (,) (P.die "die") (P.die "die")))
(INPUT_FROM_LIST [1 :: Int]) of
Right _ -> False
Left _ -> True)
@ -606,25 +692,25 @@ splitWithFailBoth =
-- let
-- prsr = P.fromFold $ FL.take n FL.toList
-- in
-- case S.parse (P.teeWith (,) prsr prsr) (S.fromList ls) of
-- case PARSER_RUNNER (FROM_PARSER_D (P.teeWith (,) prsr prsr)) (INPUT_FROM_LIST ls) of
-- Right (ls_1, ls_2) -> checkListEqual (Prelude.take n ls) ls_1 .&&. checkListEqual ls_1 ls_2
-- Left _ -> property False
-- teeWithFailLeft :: Property
-- teeWithFailLeft =
-- property (case S.parse (P.teeWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
-- property (case PARSER_RUNNER (FROM_PARSER_D (P.teeWith (,) (P.die "die") (P.fromPure (1 :: Int)))) (INPUT_FROM_LIST [1 :: Int]) of
-- Right _ -> False
-- Left _ -> True)
-- teeWithFailRight :: Property
-- teeWithFailRight =
-- property (case S.parse (P.teeWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
-- property (case PARSER_RUNNER (FROM_PARSER_D (P.teeWith (,) (P.fromPure (1 :: Int)) (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
-- Right _ -> False
-- Left _ -> True)
-- teeWithFailBoth :: Property
-- teeWithFailBoth =
-- property (case S.parse (P.teeWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
-- property (case PARSER_RUNNER (FROM_PARSER_D (P.teeWith (,) (P.die "die") (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
-- Right _ -> False
-- Left _ -> True)
@ -632,7 +718,7 @@ splitWithFailBoth =
deintercalate :: Property
deintercalate =
forAll (listOf (chooseAny :: Gen Int)) $ \ls ->
case runIdentity $ S.parse p (S.fromList ls) of
case runIdentity $ PARSER_RUNNER p (INPUT_FROM_LIST ls) of
Right evenOdd -> evenOdd == List.partition even ls
Left _ -> False
@ -654,28 +740,28 @@ deintercalate =
-- prsr_2 = P.takeWhile (<= mid_value) FL.toList
-- prsr_shortest = P.shortest prsr_1 prsr_2
-- in
-- case S.parse prsr_shortest (S.fromList ls) of
-- case PARSER_RUNNER prsr_shortest (INPUT_FROM_LIST ls) of
-- Right short_list -> checkListEqual short_list (Prelude.takeWhile (<= half_mid_value) ls)
-- Left _ -> property False
-- shortestPassLeft :: Property
-- shortestPassLeft =
-- property (case S.parse (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
-- property (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.die "die") (P.fromPure (1 :: Int)))) (INPUT_FROM_LIST [1 :: Int]) of
-- Right r -> r == 1
-- Left _ -> False)
--
-- shortestPassRight :: Property
-- shortestPassRight =
-- property (case S.parse (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
-- property (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.fromPure (1 :: Int)) (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
-- Right r -> r == 1
-- Left _ -> False)
-- shortestFailBoth :: Property
-- shortestFailBoth =
-- property
-- (case S.parse
-- (case PARSER_RUNNER
-- (P.shortest (P.die "die") (P.die "die"))
-- (S.fromList [1 :: Int]) of
-- (INPUT_FROM_LIST [1 :: Int]) of
-- Right _ -> False
-- Left _ -> True)
--
@ -688,26 +774,26 @@ deintercalate =
-- prsr_2 = P.takeWhile (<= mid_value) FL.toList
-- prsr_longest = P.longest prsr_1 prsr_2
-- in
-- case S.parse prsr_longest (S.fromList ls) of
-- case PARSER_RUNNER prsr_longest (INPUT_FROM_LIST ls) of
-- Right long_list -> long_list == Prelude.takeWhile (<= mid_value) ls
-- Left _ -> False
--
-- longestPassLeft :: Property
-- longestPassLeft =
-- property (case S.parse (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
-- property (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.die "die") (P.fromPure (1 :: Int)))) (INPUT_FROM_LIST [1 :: Int]) of
-- Right r -> r == 1
-- Left _ -> False)
--
-- longestPassRight :: Property
-- longestPassRight =
-- property (case S.parse (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
-- property (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.fromPure (1 :: Int)) (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
-- Right r -> r == 1
-- Left _ -> False)
--
-- longestFailBoth :: Property
-- longestFailBoth =
-- property
-- (case S.parse (P.shortest (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
-- (case PARSER_RUNNER (FROM_PARSER_D (P.shortest (P.die "die") (P.die "die"))) (INPUT_FROM_LIST [1 :: Int]) of
-- Right _ -> False
-- Left _ -> True)
@ -719,14 +805,17 @@ many =
prsr =
flip P.many concatFold
$ P.fromFold $ FL.takeEndBy_ (== 1) FL.toList
in case runIdentity $ S.parse prsr (S.fromList ls) of
in case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
Right res_list ->
checkListEqual res_list (Prelude.filter (== 0) ls)
Left _ -> property False
many_empty :: Property
many_empty =
property (case runIdentity $ S.parse (flip P.many FL.toList (P.die "die")) (S.fromList [1 :: Int]) of
property (case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (flip P.many FL.toList (P.die "die")))
(INPUT_FROM_LIST [1 :: Int]) of
Right res_list -> checkListEqual res_list ([] :: [Int])
Left _ -> property False)
@ -740,13 +829,16 @@ some =
prsr =
flip P.some concatFold
$ P.fromFold $ FL.takeEndBy_ (== 1) FL.toList
in case runIdentity $ S.parse prsr (S.fromList ls) of
in case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
Right res_list -> res_list == Prelude.filter (== 0) ls
Left _ -> False
someFail :: Property
someFail =
property (case runIdentity $ S.parse (P.some (P.die "die") FL.toList) (S.fromList [1 :: Int]) of
property (case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D (P.some (P.die "die") FL.toList))
(INPUT_FROM_LIST [1 :: Int]) of
Right _ -> False
Left _ -> True)
@ -763,7 +855,9 @@ applicative =
<$> P.fromFold (FL.take (length list1) FL.toList)
<*> P.fromFold (FL.take (length list2) FL.toList)
in
case runIdentity $ S.parse parser (S.fromList $ list1 ++ list2) of
case runIdentity $ PARSER_RUNNER
(FROM_PARSER_D parser)
(INPUT_FROM_LIST $ list1 ++ list2) of
Right (olist1, olist2) -> olist1 == list1 && olist2 == list2
Left _ -> False
@ -773,9 +867,9 @@ sequence =
let p xs = P.fromFold (FL.take (length xs) FL.toList)
in monadicIO $ do
outs <- run $
S.parse
(Prelude.sequence $ fmap p ins)
(S.fromList $ concat ins)
PARSER_RUNNER
(FROM_PARSER_D (Prelude.sequence $ fmap p ins))
(INPUT_FROM_LIST $ concat ins)
return $
case outs of
Right ls -> ls == ins
@ -784,9 +878,9 @@ sequence =
altEOF1 :: Property
altEOF1 =
monadicIO $ do
s1 <- S.parse
(P.satisfy (> 0) <|> return 66)
(S.fromList ([]::[Int]))
s1 <- PARSER_RUNNER
(FROM_PARSER_D (P.satisfy (> 0) <|> return 66))
(INPUT_FROM_LIST ([]::[Int]))
return $
case s1 of
Right x -> x == 66
@ -795,9 +889,9 @@ altEOF1 =
altEOF2 :: Property
altEOF2 =
monadicIO $ do
s1 <- S.parse
((P.takeEQ 2 FL.toList) <|> (P.takeEQ 1 FL.toList))
(S.fromList ([51]::[Int]))
s1 <- PARSER_RUNNER
(FROM_PARSER_D ((P.takeEQ 2 FL.toList) <|> (P.takeEQ 1 FL.toList)))
(INPUT_FROM_LIST ([51]::[Int]))
return $
case s1 of
Right x -> x == [51]
@ -812,7 +906,9 @@ monad =
olist2 <- P.fromFold (FL.take (length list2) FL.toList)
return (olist1, olist2)
in monadicIO $ do
s <- S.parse parser (S.fromList $ list1 ++ list2)
s <- PARSER_RUNNER
(FROM_PARSER_D parser)
(INPUT_FROM_LIST $ list1 ++ list2)
return $
case s of
Right (olist1, olist2) -> olist1 == list1 && olist2 == list2
@ -868,15 +964,19 @@ parserSequence :: Property
parserSequence =
forAll (vectorOf 11 (listOf (chooseAny :: Gen Int))) $ \ins ->
monadicIO $ do
let parsers = S.fromList
$ fmap (\xs -> P.fromFold $ FL.take (length xs) FL.sum) ins
let sequencedParser = P.sequence parsers FL.sum
outs <-
S.parse sequencedParser $ S.concatMap S.fromList (S.fromList ins)
return $
case outs of
Right x -> x == sum (map sum ins)
Left _ -> False
let parsers = S.fromList
$ fmap (\xs -> P.fromFold $ FL.take (length xs) FL.sum) ins
let sequencedParser = FROM_PARSER_D (P.sequence parsers FL.sum)
#ifdef PARSER_K
strm = SK.map A.fromList (SK.fromList ins)
#else
strm = S.concatMap S.fromList (S.fromList ins)
#endif
outs <- PARSER_RUNNER sequencedParser strm
return $
case outs of
Right x -> x == sum (map sum ins)
Left _ -> False
-------------------------------------------------------------------------------
-- Test for a particular case hit during fs events testing
@ -947,9 +1047,9 @@ manyEqParseMany =
forAll (listOf (chooseInt (0, 100))) $ \lst ->
forAll (chooseInt (1, 100)) $ \i ->
monadicIO $ do
let strm = S.fromList lst
r1 <- run $ S.parse (P.many (split i) FL.toList) strm
r2 <- run $ S.fold FL.toList $ S.catRights $ S.parseMany (split i) strm
let strm = INPUT_FROM_LIST lst
r1 <- run $ PARSER_RUNNER (FROM_PARSER_D (P.many (split i) FL.toList)) strm
r2 <- run $ S.fold FL.toList $ S.catRights $ S.parseMany (split i) (S.fromList lst)
return $
case r1 of
Right o1 -> o1 == r2
@ -963,7 +1063,7 @@ manyEqParseMany =
takeEndBy1 :: Property
takeEndBy1 =
forAll (listOf (chooseInt (0, 1))) $ \ls ->
case runIdentity $ S.parse (P.takeEndBy predicate prsr) (S.fromList ls) of
case runIdentity $ PARSER_RUNNER (FROM_PARSER_D (P.takeEndBy predicate prsr)) (INPUT_FROM_LIST ls) of
Right parsed_list ->
checkListEqual
parsed_list
@ -1053,7 +1153,7 @@ takeEndByEsc =
Just _ ->
x : escapeSep Nothing xs
in
case runIdentity $ S.parse prsr (S.fromList ls) of
case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
Right parsed_list -> checkListEqual parsed_list $ escapeSep Nothing ls
Left err -> property (displayException err == msg)
@ -1129,7 +1229,7 @@ takeFramedByEsc_ =
in
helper l Nothing (0 :: Int)
in
case runIdentity $ S.parse prsr (S.fromList ls) of
case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
Right parsed_list ->
if checkPassBeg ls
then checkListEqual parsed_list $
@ -1186,7 +1286,7 @@ takeFramedByEsc_Pass =
in
helper l Nothing (0 :: Int)
in
case runIdentity $ S.parse prsr (S.fromList ls) of
case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
Right parsed_list -> checkListEqual parsed_list $ escapeFrame isBegin isEnd isEsc ls
_ -> property False
@ -1205,7 +1305,7 @@ takeFramedByEsc_Fail1 =
ls = [0 :: Int]
in
case runIdentity $ S.parse prsr (S.fromList ls) of
case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
Right _ -> property False
Left err -> property (displayException err == msg)
@ -1224,7 +1324,7 @@ takeFramedByEsc_Fail2 =
ls = [1 :: Int]
in
case runIdentity $ S.parse prsr (S.fromList ls) of
case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
Right _ -> property False
Left err -> property (displayException err == msg)
@ -1243,7 +1343,7 @@ takeFramedByEsc_Fail3 =
ls = [2 :: Int]
in
case runIdentity $ S.parse prsr (S.fromList ls) of
case runIdentity $ PARSER_RUNNER (FROM_PARSER_D prsr) (INPUT_FROM_LIST ls) of
Right _ -> property False
Left err -> property $ (displayException err == msg)
@ -1253,7 +1353,7 @@ takeStartBy_ =
let ls1 = 1:ls
msg = "takeFramedByGeneric: empty token"
in
case runIdentity $ S.parse parser (S.fromList ls1) of
case runIdentity $ PARSER_RUNNER (FROM_PARSER_D parser) (INPUT_FROM_LIST ls1) of
Right parsed_list ->
if not $ Prelude.null ls1
then

836
test/Streamly/Test/Data/ParserK.hs
View File

@ -1,836 +0,0 @@
module Main (main) where
import Control.Applicative ((<|>))
import Control.Exception (SomeException(..), try)
import Data.Word (Word8, Word32, Word64)
import Streamly.Test.Common (listEquals, checkListEqual, chooseInt)
import Test.Hspec (Spec, hspec, describe)
import Test.Hspec.QuickCheck
import Test.QuickCheck
(arbitrary, forAll, elements, Property,
property, listOf, vectorOf, (.&&.), Gen)
import Test.QuickCheck.Monadic (monadicIO, assert, run)
import qualified Data.List as List
import qualified Prelude
import qualified Streamly.Data.Stream as S
import qualified Streamly.Internal.Data.Array as A
import qualified Streamly.Internal.Data.Fold as FL
import qualified Streamly.Internal.Data.Parser as P
import qualified Streamly.Internal.Data.Producer as Producer
import qualified Streamly.Internal.Data.Stream as S
import qualified Streamly.Internal.Data.Stream as D
import qualified Streamly.Internal.Data.Unfold as Unfold
import qualified Test.Hspec as H
import Prelude hiding (sequence)
#if MIN_VERSION_QuickCheck(2,14,0)
import Test.QuickCheck (chooseAny)
import Control.Monad.Identity (runIdentity, Identity (Identity))
#else
import System.Random (Random(random))
import Test.QuickCheck.Gen (Gen(MkGen))
-- | Generates a random element over the natural range of `a`.
chooseAny :: Random a => Gen a
chooseAny = MkGen (\r _ -> let (x,_) = random r in x)
#endif
maxTestCount :: Int
maxTestCount = 100
min_value :: Int
min_value = 0
mid_value :: Int
mid_value = 5000
max_value :: Int
max_value = 10000
max_length :: Int
max_length = 1000
toList :: Monad m => S.Stream m a -> m [a]
toList = S.fold FL.toList
-- Accumulator Tests
fromFold :: Property
fromFold =
forAll (listOf $ chooseInt (min_value, max_value))
$ \ls ->
case (==) <$> runIdentity (S.parseD (P.fromFold FL.sum) (S.fromList ls))
<*> (S.fold FL.sum (S.fromList ls)) of
Right is_equal -> is_equal
Left _ -> False
fromPure :: Property
fromPure =
forAll (chooseInt (min_value, max_value)) $ \x ->
case runIdentity $ S.parseD (P.fromPure x) (S.fromList [1 :: Int]) of
Right r -> r == x
Left _ -> False
fromEffect :: Property
fromEffect =
forAll (chooseInt (min_value, max_value)) $ \x ->
case runIdentity $ S.parseD (P.fromEffect $ return x) (S.fromList [1 :: Int]) of
Right r -> r == x
Left _ -> False
die :: Property
die =
property $
case runIdentity (S.parseD (P.die "die test") (S.fromList [0 :: Int])) of
Right _ -> False
Left _ -> True
dieM :: Property
dieM =
property $
case runIdentity (S.parseD (P.dieM (Identity "die test")) (S.fromList [0 :: Int])) of
Right _ -> False
Left _ -> True
-- Element Parser Tests
peekPass :: Property
peekPass =
forAll (chooseInt (1, max_length)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parseD P.peek (S.fromList ls) of
Right head_value -> case ls of
head_ls : _ -> head_value == head_ls
_ -> False
Left _ -> False
peekFail :: Property
peekFail =
property (case runIdentity $ S.parseD P.peek (S.fromList []) of
Right _ -> False
Left _ -> True)
eofPass :: Property
eofPass =
property (case S.parseD P.eof (S.fromList []) of
Right _ -> True
Left _ -> False)
eofFail :: Property
eofFail =
forAll (chooseInt (1, max_length)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parseD P.eof (S.fromList ls) of
Right _ -> False
Left _ -> True
satisfyPass :: Property
satisfyPass =
forAll (chooseInt (mid_value, max_value)) $ \first_element ->
forAll (listOf (chooseInt (min_value, max_value))) $ \ls_tail ->
let
ls = first_element : ls_tail
predicate = (>= mid_value)
in
case runIdentity $ S.parseD (P.satisfy predicate) (S.fromList ls) of
Right r -> r == first_element
Left _ -> False
satisfy :: Property
satisfy =
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parseD (P.satisfy predicate) (S.fromList ls) of
Right r -> case ls of
[] -> False
(x : _) -> predicate x && (r == x)
Left _ -> case ls of
[] -> True
(x : _) -> not $ predicate x
where
predicate = (>= mid_value)
-- Sequence Parsers Tests
takeBetweenPass :: Property
takeBetweenPass =
forAll (chooseInt (min_value, max_value)) $ \m ->
forAll (chooseInt (m, max_value)) $ \n ->
forAll (chooseInt (m, max_value)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parseD (P.takeBetween m n FL.toList) (S.fromList ls) of
Right parsed_list ->
let lpl = Prelude.length parsed_list
in checkListEqual parsed_list (Prelude.take lpl ls)
Left _ -> property False
takeBetween :: Property
takeBetween =
forAll (chooseInt (min_value, max_value)) $ \m ->
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
let
list_length = Prelude.length ls
in monadicIO $ do
let p = P.takeBetween m n FL.toList
r <- run $ try $ S.parseD p (S.fromList ls)
return $ case r of
Right x -> case x of
Right parsed_list ->
if m <= list_length && n >= m
then
let len = Prelude.length parsed_list
in checkListEqual
parsed_list (Prelude.take len ls)
else property False
Left _ ->
property (m > n || list_length < m)
Left (_ :: SomeException) ->
property (m > n || list_length < m)
take :: Property
take =
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parseD (P.fromFold $ FL.take n FL.toList) (S.fromList ls) of
Right parsed_list -> checkListEqual parsed_list (Prelude.take n ls)
Left _ -> property False
takeEQPass :: Property
takeEQPass =
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (chooseInt (n, max_value)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parseD (P.takeEQ n FL.toList) (S.fromList ls) of
Right parsed_list -> checkListEqual parsed_list (Prelude.take n ls)
Left _ -> property False
takeEQ :: Property
takeEQ =
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
let
list_length = Prelude.length ls
in
case runIdentity $ S.parseD (P.takeEQ n FL.toList) (S.fromList ls) of
Right parsed_list ->
if (n <= list_length) then
checkListEqual parsed_list (Prelude.take n ls)
else
property False
Left _ -> property (n > list_length)
takeGEPass :: Property
takeGEPass =
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (chooseInt (n, max_value)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parseD (P.takeGE n FL.toList) (S.fromList ls) of
Right parsed_list -> checkListEqual parsed_list ls
Left _ -> property False
takeGE :: Property
takeGE =
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
let
list_length = Prelude.length ls
in
case runIdentity $ S.parseD (P.takeGE n FL.toList) (S.fromList ls) of
Right parsed_list ->
if (n <= list_length) then
checkListEqual parsed_list ls
else
property False
Left _ -> property (n > list_length)
nLessThanEqual0 ::
( Int
-> FL.Fold Identity Int [Int]
-> P.Parser Int Identity [Int]
)
-> (Int -> [Int] -> [Int])
-> Property
nLessThanEqual0 tk ltk =
forAll (elements [0, (-1)]) $ \n ->
forAll (listOf arbitrary) $ \ls ->
case runIdentity $ S.parseD (tk n FL.toList) (S.fromList ls) of
Right parsed_list -> checkListEqual parsed_list (ltk n ls)
Left _ -> property False
takeProperties :: Spec
takeProperties =
describe "take combinators when n <= 0/" $ do
prop "takeEQ n FL.toList = []" $
nLessThanEqual0 P.takeEQ (\_ -> const [])
prop "takeGE n FL.toList xs = xs" $
nLessThanEqual0 P.takeGE (\_ -> id)
-- XXX lookAhead can't deal with EOF which in this case means when
-- n==list_length, this test will fail. So excluding that case for now.
lookAheadPass :: Property
lookAheadPass =
forAll (chooseInt (min_value, max_value)) $ \n ->
let
takeWithoutConsume = P.lookAhead $ P.fromFold $ FL.take n FL.toList
parseTwice = do
parsed_list_1 <- takeWithoutConsume
parsed_list_2 <- takeWithoutConsume
return (parsed_list_1, parsed_list_2)
in
forAll (chooseInt (n+1, max_value)) $ \list_length ->
forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parseD parseTwice (S.fromList ls) of
Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
Left _ -> property $ False
lookAhead :: Property
lookAhead =
forAll (chooseInt (min_value, max_value)) $ \n ->
let
takeWithoutConsume = P.lookAhead $ P.fromFold $ FL.take n FL.toList
parseTwice = do
parsed_list_1 <- takeWithoutConsume
parsed_list_2 <- takeWithoutConsume
return (parsed_list_1, parsed_list_2)
in
forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
case runIdentity $ S.parseD parseTwice (S.fromList ls) of
Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
Left _ -> property ((list_length < n) || (list_length == n && n == 0))
where
list_length = Prelude.length ls
takeWhile :: Property
takeWhile =
forAll (listOf (chooseInt (0, 1))) $ \ ls ->
case runIdentity $ S.parseD (P.takeWhile predicate FL.toList) (S.fromList ls) of
Right parsed_list -> checkListEqual parsed_list (Prelude.takeWhile predicate ls)
Left _ -> property False
where
predicate = (== 0)
takeWhile1 :: Property
takeWhile1 =
forAll (listOf (chooseInt (0, 1))) $ \ ls ->
case runIdentity $ S.parseD (P.takeWhile1 predicate FL.toList) (S.fromList ls) of
Right parsed_list -> case ls of
[] -> property False
(x : _) ->
if predicate x then
checkListEqual parsed_list (Prelude.takeWhile predicate ls)
else
property False
Left _ -> case ls of
[] -> property True
(x : _) -> property (not $ predicate x)
where
predicate = (== 0)
groupBy :: Property
groupBy =
forAll (listOf (chooseInt (0, 1)))
$ \ls ->
case runIdentity $ S.parseD parser (S.fromList ls) of
Right parsed -> checkListEqual parsed (groupByLF ls)
Left _ -> property False
where
cmp = (==)
parser = P.groupBy cmp FL.toList
groupByLF lst
| null lst = []
| otherwise = head $ List.groupBy cmp lst
groupByRolling :: Property
groupByRolling =
forAll (listOf (chooseInt (0, 1)))
$ \ls ->
case runIdentity $ S.parseD parser (S.fromList ls) of
Right parsed -> checkListEqual parsed (groupByLF Nothing ls)
Left _ -> property False
where
cmp = (==)
parser = P.groupBy cmp FL.toList
groupByLF _ [] = []
groupByLF Nothing (x:xs) = x : groupByLF (Just x) xs
groupByLF (Just y) (x:xs) =
if cmp y x
then x : groupByLF (Just x) xs
else []
takeEndByOrMax :: Property
takeEndByOrMax =
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (listOf (chooseInt (0, 1))) $ \ls ->
case runIdentity $ S.parseD (P.fromFold $ FL.takeEndBy_ predicate (FL.take n FL.toList)) (S.fromList ls) of
Right parsed_list -> checkListEqual parsed_list (Prelude.take n (Prelude.takeWhile (not . predicate) ls))
Left _ -> property False
where
predicate = (== 1)
wordBy :: Property
wordBy =
forAll (listOf (elements [' ', 's']))
$ \ls ->
case runIdentity $ S.parseD parser (S.fromList ls) of
Right parsed -> checkListEqual parsed (words' ls)
Left _ -> property False
where
predicate = (== ' ')
parser = P.many (P.wordBy predicate FL.toList) FL.toList
words' lst =
let wrds = words lst
in if wrds == [] && length lst > 0 then [""] else wrds
splitWith :: Property
splitWith =
forAll (listOf (chooseInt (0, 1))) $ \ls ->
case runIdentity $ S.parseD (P.splitWith (,) (P.satisfy (== 0)) (P.satisfy (== 1))) (S.fromList ls) of
Right (result_first, result_second) -> case ls of
0 : 1 : _ -> (result_first == 0) && (result_second == 1)
_ -> False
Left _ -> case ls of
0 : 1 : _ -> False
_ -> True
splitWithFailLeft :: Property
splitWithFailLeft =
property (case runIdentity $ S.parseD (P.splitWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
Right _ -> False
Left _ -> True)
splitWithFailRight :: Property
splitWithFailRight =
property (case runIdentity $ S.parseD (P.splitWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
Right _ -> False
Left _ -> True)
splitWithFailBoth :: Property
splitWithFailBoth =
property (case runIdentity $ S.parseD (P.splitWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
Right _ -> False
Left _ -> True)
{-
teeWithPass :: Property
teeWithPass =
forAll (chooseInt (min_value, max_value)) $ \n ->
forAll (listOf (chooseInt (0, 1))) $ \ls ->
let
prsr = P.fromFold $ FL.take n FL.toList
in
case S.parseD (P.teeWith (,) prsr prsr) (S.fromList ls) of
Right (ls_1, ls_2) -> checkListEqual (Prelude.take n ls) ls_1 .&&. checkListEqual ls_1 ls_2
Left _ -> property False
teeWithFailLeft :: Property
teeWithFailLeft =
property (case S.parseD (P.teeWith (,) (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
Right _ -> False
Left _ -> True)
teeWithFailRight :: Property
teeWithFailRight =
property (case S.parseD (P.teeWith (,) (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
Right _ -> False
Left _ -> True)
teeWithFailBoth :: Property
teeWithFailBoth =
property (case S.parseD (P.teeWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
Right _ -> False
Left _ -> True)
shortestPass :: Property
shortestPass =
forAll (listOf (chooseInt(min_value, max_value))) $ \ls ->
let
half_mid_value = mid_value `Prelude.div` 2
prsr_1 = P.takeWhile (<= half_mid_value) FL.toList
prsr_2 = P.takeWhile (<= mid_value) FL.toList
prsr_shortest = P.shortest prsr_1 prsr_2
in
case S.parseD prsr_shortest (S.fromList ls) of
Right short_list -> checkListEqual short_list (Prelude.takeWhile (<= half_mid_value) ls)
Left _ -> property False
shortestPassLeft :: Property
shortestPassLeft =
property (case S.parseD (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
Right r -> r == 1
Left _ -> False)
shortestPassRight :: Property
shortestPassRight =
property (case S.parseD (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
Right r -> r == 1
Left _ -> False)
shortestFailBoth :: Property
shortestFailBoth =
property
(case S.parseD
(P.shortest (P.die "die") (P.die "die"))
(S.fromList [1 :: Int]) of
Right _ -> False
Left _ -> True)
longestPass :: Property
longestPass =
forAll (listOf (chooseInt(min_value, max_value))) $ \ls ->
let
half_mid_value = mid_value `Prelude.div` 2
prsr_1 = P.takeWhile (<= half_mid_value) FL.toList
prsr_2 = P.takeWhile (<= mid_value) FL.toList
prsr_longest = P.longest prsr_1 prsr_2
in
case S.parseD prsr_longest (S.fromList ls) of
Right long_list -> long_list == Prelude.takeWhile (<= mid_value) ls
Left _ -> False
longestPassLeft :: Property
longestPassLeft =
property (case S.parseD (P.shortest (P.die "die") (P.fromPure (1 :: Int))) (S.fromList [1 :: Int]) of
Right r -> r == 1
Left _ -> False)
longestPassRight :: Property
longestPassRight =
property (case S.parseD (P.shortest (P.fromPure (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
Right r -> r == 1
Left _ -> False)
longestFailBoth :: Property
longestFailBoth =
property
(case S.parseD (P.shortest (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
Right _ -> False
Left _ -> True)
-}
many :: Property
many =
forAll (listOf (chooseInt (0, 1)))
$ \ls ->
let fldstp conL currL = return $ FL.Partial (conL ++ currL)
concatFold =
FL.Fold fldstp (return (FL.Partial [])) return
prsr =
flip P.many concatFold
$ P.fromFold $ FL.takeEndBy_ (== 1) FL.toList
in case runIdentity $ S.parseD prsr (S.fromList ls) of
Right res_list ->
checkListEqual res_list (Prelude.filter (== 0) ls)
Left _ -> property False
many_empty :: Property
many_empty =
property (case runIdentity $ S.parseD (flip P.many FL.toList (P.die "die")) (S.fromList [1 :: Int]) of
Right res_list -> checkListEqual res_list ([] :: [Int])
Left _ -> property False)
some :: Property
some =
forAll (listOf (chooseInt (0, 1)))
$ \ls ->
let fldstp conL currL = return $ FL.Partial $ conL ++ currL
concatFold = FL.Fold fldstp (return (FL.Partial [])) return
prsr =
flip P.some concatFold
$ P.fromFold $ FL.takeEndBy_ (== 1) FL.toList
in case runIdentity $ S.parseD prsr (S.fromList ls) of
Right res_list -> res_list == Prelude.filter (== 0) ls
Left _ -> False
someFail :: Property
someFail =
property (case runIdentity $ S.parseD (P.some (P.die "die") FL.toList) (S.fromList [1 :: Int]) of
Right _ -> False
Left _ -> True)
-------------------------------------------------------------------------------
-- Instances
-------------------------------------------------------------------------------
applicative :: Property
applicative =
forAll (listOf (chooseAny :: Gen Int)) $ \ list1 ->
forAll (listOf (chooseAny :: Gen Int)) $ \ list2 ->
monadicIO $ do
let parser =
(,)
<$> P.fromFold (FL.take (length list1) FL.toList)
<*> P.fromFold (FL.take (length list2) FL.toList)
return $
case runIdentity $ S.parseD parser (S.fromList $ list1 ++ list2) of
Right (olist1, olist2) -> olist1 == list1 && olist2 == list2
Left _ -> False
sequence :: Property
sequence =
forAll (vectorOf 11 (listOf (chooseAny :: Gen Int))) $ \ ins ->
monadicIO $ do
let parsers = fmap (\xs -> P.fromFold $ FL.take (length xs) FL.toList) ins
outs <- S.parseD
(Prelude.sequence parsers)
(S.fromList $ concat ins)
return $
case outs of
Right x -> x == ins
Left _ -> False
altEOF1 :: Property
altEOF1 =
monadicIO $ do
s1 <- S.parseD
(P.satisfy (> 0) <|> return 66)
(S.fromList ([]::[Int]))
return $
case s1 of
Right x -> x == 66
Left _ -> False
altEOF2 :: Property
altEOF2 =
monadicIO $ do
s1 <- S.parseD
((P.takeEQ 2 FL.toList) <|> (P.takeEQ 1 FL.toList))
(S.fromList ([51]::[Int]))
return $
case s1 of
Right x -> x == [51]
Left _ -> False
monad :: Property
monad =
forAll (listOf (chooseAny :: Gen Int)) $ \ list1 ->
forAll (listOf (chooseAny :: Gen Int)) $ \ list2 ->
monadicIO $ do
let parser = do
olist1 <- P.fromFold (FL.take (length list1) FL.toList)
olist2 <- P.fromFold (FL.take (length list2) FL.toList)
return (olist1, olist2)
s1 <- S.parseD parser (S.fromList $ list1 ++ list2)
return $
case s1 of
Right (olist1, olist2) -> olist1 == list1 && olist2 == list2
Left _ -> False
-------------------------------------------------------------------------------
-- Stream parsing
-------------------------------------------------------------------------------
parseMany :: Property
parseMany =
forAll (chooseInt (1,100)) $ \len ->
forAll (listOf (vectorOf len (chooseAny :: Gen Int))) $ \ ins ->
monadicIO $ do
outs <-
(toList $ S.catRights $ S.parseManyD
(P.fromFold $ FL.take len FL.toList) (S.fromList $ concat ins)
)
return $ outs == ins
-- basic sanity test for parsing from arrays
parseUnfold :: Property
parseUnfold = do
let len = 200
-- ls = input list (stream)
-- clen = chunk size
-- tlen = parser take size
forAll
((,,)
<$> vectorOf len (chooseAny :: Gen Int)
<*> chooseInt (1, len)
<*> chooseInt (1, len)) $ \(ls, clen, tlen) ->
monadicIO $ do
arrays <- toList $ S.chunksOf clen (S.fromList ls)
let src = Producer.source (Just (Producer.OuterLoop arrays))
let parser = P.fromFold (FL.take tlen FL.toList)
let readSrc =
Producer.producer
$ Producer.concat Producer.fromList A.producer
let streamParser =
Producer.simplify (Producer.parseManyD parser readSrc)
xs <- run
$ toList
$ S.unfoldMany Unfold.fromList
$ S.catRights
$ S.unfold streamParser src
listEquals (==) xs ls
parserSequence :: Property
parserSequence =
forAll (vectorOf 11 (listOf (chooseAny :: Gen Int))) $ \ins ->
monadicIO $ do
let parsers = D.fromList
$ fmap (\xs -> P.fromFold $ FL.take (length xs) FL.sum) ins
let sequencedParser = P.sequence parsers FL.sum
outs <-
S.parseD sequencedParser $ S.concatMap S.fromList (S.fromList ins)
return $
case outs of
Right x -> x == sum (map sum ins)
Left _ -> False
-------------------------------------------------------------------------------
-- Test for a particular case hit during fs events testing
-------------------------------------------------------------------------------
evId :: [Word8]
evId = [96,238,17,9,0,0,0,0]
evFlags :: [Word8]
evFlags = [0,4,1,0,0,0,0,0]
evPathLen :: [Word8]
evPathLen = [71,0,0,0,0,0,0,0]
evPath :: [Word8]
evPath =
[47,85,115,101,114,115,47,118,111,108,47,118,101,109,98,97,47,99,111,109
,112,111,115,101,119,101 ,108,108,45,116,101,99,104,47,69,110,103,47,112
,114,111,106,101,99,116,115,47,115,116,114,101,97,109,108,121,47,115,116
,114,101,97,109,108,121,47,116,109,112,47,122,122
]
event :: [Word8]
event = evId ++ evFlags ++ evPathLen ++ evPath
data Event = Event
{ eventId :: Word64
, eventFlags :: Word32
, eventAbsPath :: A.Array Word8
} deriving (Show, Ord, Eq)
readOneEvent :: P.Parser Word8 IO Event
readOneEvent = do
arr <- P.takeEQ 24 (A.writeN 24)
let arr1 = A.castUnsafe arr :: A.Array Word64
eid = A.getIndexUnsafe 0 arr1
eflags = A.getIndexUnsafe 1 arr1
pathLen = fromIntegral $ A.getIndexUnsafe 2 arr1
path <- P.takeEQ pathLen (A.writeN pathLen)
return $ Event
{ eventId = eid
, eventFlags = fromIntegral eflags
, eventAbsPath = path
}
parseMany2Events :: Property
parseMany2Events =
monadicIO $ do
xs <-
( run
$ toList
$ S.catRights
$ S.parseManyD readOneEvent
$ S.fromList (concat (replicate 2 event))
)
assert (length xs == 2)
-- XXX assuming little endian machine
let ev = Event
{ eventId = 152170080
, eventFlags = 66560
, eventAbsPath = A.fromList evPath
}
in listEquals (==) xs (replicate 2 ev)
-------------------------------------------------------------------------------
-- Main
-------------------------------------------------------------------------------
moduleName :: String
moduleName = "Data.ParserK"
main :: IO ()
main =
hspec $
H.parallel $
modifyMaxSuccess (const maxTestCount) $ do
describe moduleName $ do
describe "Instances" $ do
prop "applicative" applicative
prop "Alternative: end of input 1" altEOF1
prop "Alternative: end of input 2" altEOF2
prop "monad" monad
prop "sequence" sequence
describe "Stream parsing" $ do
prop "parseMany" parseMany
prop "parseMany2Events" parseMany2Events
prop "parseUnfold" parseUnfold
prop "parserSequence" parserSequence
describe "test for accumulator" $ do
prop "P.fromFold FL.sum = FL.sum" fromFold
prop "fromPure value provided" fromPure
prop "fromPure monadic value provided" fromEffect
prop "always fail" die
prop "always fail but monadic" dieM
describe "test for element parser" $ do
prop "peek = head with list length > 0" peekPass
prop "peek fail on []" peekFail
prop "eof pass on []" eofPass
prop "eof fail on non-empty list" eofFail
prop "first element exists and >= mid_value" satisfyPass
prop "check first element exists and satisfies predicate" satisfy
describe "test for sequence parser" $ do
prop "P.takeBetween m n = Prelude.take when len >= m and len <= n"
takeBetweenPass
prop ("P.takeBetween m n = Prelude.take when len >= m and len <= n and"
++ " fail otherwise") takeBetween
prop "P.take = Prelude.take" Main.take
prop "P.takeEQ = Prelude.take when len >= n" takeEQPass
prop "P.takeEQ = Prelude.take when len >= n and fail otherwise" Main.takeEQ
prop "P.takeGE n ls = ls when len >= n" takeGEPass
prop "P.takeGE n ls = ls when len >= n and fail otherwise" Main.takeGE
prop "lookAhead . take n >> lookAhead . take n = lookAhead . take n" lookAheadPass
prop "lookAhead . take n >> lookAhead . take n = lookAhead . take n, else fail" lookAhead
prop "P.takeWhile = Prelude.takeWhile" Main.takeWhile
prop "P.takeWhile1 = Prelude.takeWhile if taken something, else check why failed" takeWhile1
prop "P.groupBy = Prelude.head . Prelude.groupBy" groupBy
prop "groupByRolling" groupByRolling
prop "P.takeEndByOrMax = Prelude.take n (Prelude.takeWhile (not . predicate)" takeEndByOrMax
prop "many (P.wordBy ' ') = words'" wordBy
prop "parse 0, then 1, else fail" splitWith
prop "fail due to die as left parser" splitWithFailLeft
prop "fail due to die as right parser" splitWithFailRight
prop "fail due to die as both parsers" splitWithFailBoth
{-
prop "parsed two lists should be equal" teeWithPass
prop "fail due to die as left parser" teeWithFailLeft
prop "fail due to die as right parser" teeWithFailRight
prop "fail due to die as both parsers" teeWithFailBoth
prop "P.takeWhile (<= half_mid_value) = Prelude.takeWhile half_mid_value" shortestPass
prop "pass even if die is left parser" shortestPassLeft
prop "pass even if die is right parser" shortestPassRight
prop "fail due to die as both parsers" shortestFailBoth
prop "P.takeWhile (<= mid_value) = Prelude.takeWhile (<= mid_value)" longestPass
prop "pass even if die is left parser" longestPassLeft
prop "pass even if die is right parser" longestPassRight
prop "fail due to die as both parsers" longestFailBoth
-}
prop "P.many concatFold $ P.takeEndBy_ (== 1) FL.toList = Prelude.filter (== 0)" many
prop "[] due to parser being die" many_empty
prop "P.some concatFold $ P.takeEndBy_ (== 1) FL.toList = Prelude.filter (== 0)" some
prop "fail due to parser being die" someFail
takeProperties

3
test/streamly-tests.cabal
View File

@ -326,7 +326,8 @@ test-suite Data.Parser
test-suite Data.ParserK
import: test-options
type: exitcode-stdio-1.0
main-is: Streamly/Test/Data/ParserK.hs
main-is: Streamly/Test/Data/Parser.hs
cpp-options: -DPARSER_K
if flag(limit-build-mem)
ghc-options: +RTS -M1500M -RTS