git.iko.soy/streamly
on 3e53339 help sign in
streamly/test/Streamly/Test/Data/Parser.hs
720 lines 27 kB history raw
1module Main (main) where
3import Control.Exception (SomeException(..), displayException)
4import Data.Word (Word8, Word32, Word64)
5import Streamly.Test.Common (listEquals, checkListEqual, chooseInt)
6import Test.Hspec (Spec, hspec, describe)
7import Test.Hspec.QuickCheck
8import Test.QuickCheck
9 (arbitrary, forAll, elements, Property, property, listOf,
10 vectorOf, Gen, suchThat)
11import Test.QuickCheck.Monadic (monadicIO, assert, run)
13import Prelude hiding (sequence)
15import qualified Data.List as List
16import qualified Prelude
17import qualified Streamly.Internal.Data.Array.Storable.Foreign as A
18import qualified Streamly.Internal.Data.Fold as FL
19import qualified Streamly.Internal.Data.Parser as P
20import qualified Streamly.Internal.Data.Stream.IsStream as S
21import qualified Test.Hspec as H
23#if MIN_VERSION_QuickCheck(2,14,0)
25import Test.QuickCheck (chooseAny)
27#else
29import System.Random (Random(random))
30import Test.QuickCheck.Gen (Gen(MkGen))
32-- | Generates a random element over the natural range of `a`.
33chooseAny :: Random a => Gen a
34chooseAny = MkGen (\r _ -> let (x,_) = random r in x)
36#endif
39maxTestCount :: Int
40maxTestCount = 100
42min_value :: Int
43min_value = 0
45mid_value :: Int
46mid_value = 5000
48max_value :: Int
49max_value = 10000
51max_length :: Int
52max_length = 1000
54-- Accumulator Tests
56fromFold :: Property
57fromFold =
58 forAll (listOf $ chooseInt (min_value, max_value)) $ \ls ->
59 case (==) <$> S.parse (P.fromFold FL.sum) (S.fromList ls)
60 <*> S.fold FL.sum (S.fromList ls) of
61 Right is_equal -> is_equal
62 Left _ -> False
64yield :: Property
65yield =
66 forAll (chooseInt (min_value, max_value)) $ \x ->
67 case S.parse (P.yield x) (S.fromList [1 :: Int]) of
68 Right r -> r == x
69 Left _ -> False
71yieldM :: Property
72yieldM =
73 forAll (chooseInt (min_value, max_value)) $ \x ->
74 case S.parse (P.yieldM $ return x) (S.fromList [1 :: Int]) of
75 Right r -> r == x
76 Left _ -> False
78die :: Property
79die =
80 property $
81 case S.parse (P.die "die test") (S.fromList [0 :: Int]) of
82 Right _ -> False
83 Left _ -> True
85dieM :: Property
86dieM =
87 property $
88 case S.parse (P.dieM (Right "die test")) (S.fromList [0 :: Int]) of
89 Right _ -> False
90 Left _ -> True
92parserFail :: Property
93parserFail =
94 property $
95 case S.parse (fail err) (S.fromList [0 :: Int]) of
96 Right _ -> False
97 Left (SomeException e) -> err == displayException e
98 where
99 err = "Testing MonadFail.fail."
101-- Element Parser Tests
103peekPass :: Property
104peekPass =
105 forAll (chooseInt (1, max_length)) $ \list_length ->
106 forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
107 case S.parse P.peek (S.fromList ls) of
108 Right head_value -> case ls of
109 head_ls : _ -> head_value == head_ls
110 _ -> False
111 Left _ -> False
113peekFail :: Property
114peekFail =
115 property (case S.parse P.peek (S.fromList []) of
116 Right _ -> False
117 Left _ -> True)
119eofPass :: Property
120eofPass =
121 property (case S.parse P.eof (S.fromList []) of
122 Right _ -> True
123 Left _ -> False)
125eofFail :: Property
126eofFail =
127 forAll (chooseInt (1, max_length)) $ \list_length ->
128 forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
129 case S.parse P.eof (S.fromList ls) of
130 Right _ -> False
131 Left _ -> True
133satisfyPass :: Property
134satisfyPass =
135 forAll (chooseInt (mid_value, max_value)) $ \first_element ->
136 forAll (listOf (chooseInt (min_value, max_value))) $ \ls_tail ->
137 let
138 ls = first_element : ls_tail
139 predicate = (>= mid_value)
140 in
141 case S.parse (P.satisfy predicate) (S.fromList ls) of
142 Right r -> r == first_element
143 Left _ -> False
145satisfy :: Property
146satisfy =
147 forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
148 case S.parse (P.satisfy predicate) (S.fromList ls) of
149 Right r -> case ls of
150 [] -> False
151 (x : _) -> predicate x && (r == x)
152 Left _ -> case ls of
153 [] -> True
154 (x : _) -> not $ predicate x
155 where
156 predicate = (>= mid_value)
158-- Sequence Parsers Tests
159takeBetweenPass :: Property
160takeBetweenPass =
161 forAll (chooseInt (min_value, max_value)) $ \m ->
162 forAll (chooseInt (m, max_value)) $ \n ->
163 forAll (chooseInt (m, max_value)) $ \list_length ->
164 forAll (vectorOf list_length (chooseInt (min_value, max_value)))
165 $ \ls ->
166 case S.parse (P.takeBetween m n FL.toList)
167 (S.fromList ls) of
168 Right parsed_list ->
169 let lpl = Prelude.length parsed_list
170 in checkListEqual parsed_list
171 $ Prelude.take lpl ls
172 Left _ -> property False
174takeBetween :: Property
175takeBetween =
176 forAll (chooseInt (min_value, max_value)) $ \m ->
177 forAll (chooseInt (min_value, max_value)) $ \n ->
178 forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
179 let
180 list_length = Prelude.length ls
181 in
182 case S.parse (P.takeBetween m n FL.toList)
183 (S.fromList ls) of
184 Right parsed_list ->
185 if m <= list_length && n >= list_length
186 then
187 let lpl = Prelude.length parsed_list
188 in checkListEqual parsed_list
189 $ Prelude.take lpl ls
190 else property False
191 Left _ -> property (m > n || list_length < m)
194takeEQPass :: Property
195takeEQPass =
196 forAll (chooseInt (min_value, max_value)) $ \n ->
197 forAll (chooseInt (n, max_value)) $ \list_length ->
198 forAll (vectorOf list_length
199 (chooseInt (min_value, max_value))) $ \ls ->
200 case S.parse (P.takeEQ n FL.toList) (S.fromList ls) of
201 Right parsed_list ->
202 checkListEqual parsed_list (Prelude.take n ls)
203 Left _ -> property False
205takeEQ :: Property
206takeEQ =
207 forAll (chooseInt (min_value, max_value)) $ \n ->
208 forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
209 let
210 list_length = Prelude.length ls
211 in
212 case S.parse (P.takeEQ n FL.toList) (S.fromList ls) of
213 Right parsed_list ->
214 if n <= list_length
215 then checkListEqual parsed_list (Prelude.take n ls)
216 else property False
217 Left _ -> property (n > list_length)
219takeGEPass :: Property
220takeGEPass =
221 forAll (chooseInt (min_value, max_value)) $ \n ->
222 forAll (chooseInt (n, max_value)) $ \list_length ->
223 forAll (vectorOf list_length (chooseInt (min_value, max_value)))
224 $ \ls ->
225 case S.parse (P.takeGE n FL.toList) (S.fromList ls) of
226 Right parsed_list -> checkListEqual parsed_list ls
227 Left _ -> property False
229takeGE :: Property
230takeGE =
231 forAll (chooseInt (min_value, max_value)) $ \n ->
232 forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
233 let
234 list_length = Prelude.length ls
235 in
236 case S.parse (P.takeGE n FL.toList) (S.fromList ls) of
237 Right parsed_list ->
238 if n <= list_length
239 then checkListEqual parsed_list ls
240 else property False
241 Left _ -> property (n > list_length)
243nLessThanEqual0 ::
244 ( Int
245 -> FL.Fold (Either SomeException) Int [Int]
246 -> P.Parser (Either SomeException) Int [Int]
247 )
248 -> (Int -> [Int] -> [Int])
249 -> Property
250nLessThanEqual0 tk ltk =
251 forAll (elements [0, (-1)]) $ \n ->
252 forAll (listOf arbitrary) $ \ls ->
253 case S.parse (tk n FL.toList) (S.fromList ls) of
254 Right parsed_list -> checkListEqual parsed_list (ltk n ls)
255 Left _ -> property False
257takeProperties :: Spec
258takeProperties =
259 describe "take combinators when n <= 0/" $ do
260 prop "takeEQ n FL.toList = []" $
261 nLessThanEqual0 P.takeEQ (\_ -> const [])
262 prop "takeGE n FL.toList xs = xs" $
263 nLessThanEqual0 P.takeGE (\_ -> id)
265-- lookAheadPass :: Property
266-- lookAheadPass =
267-- forAll (chooseInt (min_value + 1, max_value)) $ \n ->
268-- let
269-- takeWithoutConsume = P.lookAhead $ P.take n FL.toList
270-- parseTwice = do
271-- parsed_list_1 <- takeWithoutConsume
272-- parsed_list_2 <- takeWithoutConsume
273-- return (parsed_list_1, parsed_list_2)
274-- in
275-- forAll (chooseInt (n, max_value)) $ \list_length ->
276-- forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
277-- case S.parse parseTwice (S.fromList ls) of
278-- Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
279-- Left _ -> property $ False
281-- lookAheadFail :: Property
282-- lookAheadFail =
283-- forAll (chooseInt (min_value + 1, max_value)) $ \n ->
284-- let
285-- takeWithoutConsume = P.lookAhead $ P.take n FL.toList
286-- parseTwice = do
287-- parsed_list_1 <- takeWithoutConsume
288-- parsed_list_2 <- takeWithoutConsume
289-- return (parsed_list_1, parsed_list_2)
290-- in
291-- forAll (chooseInt (min_value, n - 1)) $ \list_length ->
292-- forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->
293-- case S.parse parseTwice (S.fromList ls) of
294-- Right _ -> False
295-- Left _ -> True
297-- lookAhead :: Property
298-- lookAhead =
299-- forAll (chooseInt (min_value, max_value)) $ \n ->
300-- let
301-- takeWithoutConsume = P.lookAhead $ P.take n FL.toList
302-- parseTwice = do
303-- parsed_list_1 <- takeWithoutConsume
304-- parsed_list_2 <- takeWithoutConsume
305-- return (parsed_list_1, parsed_list_2)
306-- in
307-- forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->
308-- case S.parse parseTwice (S.fromList ls) of
309-- Right (ls_1, ls_2) -> checkListEqual ls_1 ls_2 .&&. checkListEqual ls_1 (Prelude.take n ls)
310-- Left _ -> property ((list_length < n) || (list_length == n && n == 0))
311-- where
312-- list_length = Prelude.length ls
314takeWhile :: Property
315takeWhile =
316 forAll (listOf (chooseInt (0, 1))) $ \ ls ->
317 case S.parse (P.takeWhile predicate FL.toList) (S.fromList ls) of
318 Right parsed_list ->
319 checkListEqual parsed_list (Prelude.takeWhile predicate ls)
320 Left _ -> property False
321 where
322 predicate = (== 0)
324takeWhile1 :: Property
325takeWhile1 =
326 forAll (listOf (chooseInt (0, 1))) $ \ ls ->
327 case S.parse (P.takeWhile1 predicate FL.toList) (S.fromList ls) of
328 Right parsed_list -> case ls of
329 [] -> property False
330 (x : _) ->
331 if predicate x
332 then
333 checkListEqual parsed_list
334 $ Prelude.takeWhile predicate ls
335 else
336 property False
337 Left _ -> case ls of
338 [] -> property True
339 (x : _) -> property (not $ predicate x)
340 where
341 predicate = (== 0)
343groupBy :: Property
344groupBy =
345 forAll (listOf (chooseInt (0, 1)))
346 $ \ls ->
347 case S.parse parser (S.fromList ls) of
348 Right parsed -> checkListEqual parsed (groupByLF ls)
349 Left _ -> property False
351 where
353 cmp = (==)
354 parser = P.groupBy cmp FL.toList
355 groupByLF lst
356 | null lst = []
357 | otherwise = head $ List.groupBy cmp lst
360wordBy :: Property
361wordBy =
362 forAll (listOf (elements [' ', 's']))
363 $ \ls ->
364 case S.parse parser (S.fromList ls) of
365 Right parsed -> checkListEqual parsed (words' ls)
366 Left _ -> property False
368 where
370 predicate = (== ' ')
371 parser = P.many FL.toList (P.wordBy predicate FL.toList)
372 words' lst =
373 let wrds = words lst
374 in if wrds == [] then [""] else wrds
376-- splitWithPass :: Property
377-- splitWithPass =
378-- forAll (listOf (chooseInt (0, 1))) $ \ls ->
379-- case S.parse (P.splitWith (,) (P.satisfy (== 0)) (P.satisfy (== 1))) (S.fromList ls) of
380-- Right (result_first, result_second) -> case ls of
381-- 0 : 1 : _ -> (result_first == 0) && (result_second == 1)
382-- _ -> False
383-- Left _ -> case ls of
384-- 0 : 1 : _ -> False
385-- _ -> True
387-- splitWithFailLeft :: Property
388-- splitWithFailLeft =
389-- property (case S.parse (P.splitWith (,) (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of
390-- Right _ -> False
391-- Left _ -> True)
393-- splitWithFailRight :: Property
394-- splitWithFailRight =
395-- property (case S.parse (P.splitWith (,) (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
396-- Right _ -> False
397-- Left _ -> True)
399-- splitWithFailBoth :: Property
400-- splitWithFailBoth =
401-- property (case S.parse (P.splitWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
402-- Right _ -> False
403-- Left _ -> True)
405-- teeWithPass :: Property
406-- teeWithPass =
407-- forAll (chooseInt (0, 10000)) $ \n ->
408-- forAll (listOf (chooseInt (0, 1))) $ \ls ->
409-- let
410-- prsr = P.take n FL.toList
411-- in
412-- case S.parse (P.teeWith (,) prsr prsr) (S.fromList ls) of
413-- Right (ls_1, ls_2) -> checkListEqual (Prelude.take n ls) ls_1 .&&. checkListEqual ls_1 ls_2
414-- Left _ -> property False
416-- teeWithFailLeft :: Property
417-- teeWithFailLeft =
418-- property (case S.parse (P.teeWith (,) (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of
419-- Right _ -> False
420-- Left _ -> True)
422-- teeWithFailRight :: Property
423-- teeWithFailRight =
424-- property (case S.parse (P.teeWith (,) (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
425-- Right _ -> False
426-- Left _ -> True)
428-- teeWithFailBoth :: Property
429-- teeWithFailBoth =
430-- property (case S.parse (P.teeWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
431-- Right _ -> False
432-- Left _ -> True)
434-- deintercalate :: Property
435-- deintercalate =
436-- forAll (listOf (chooseInt (0, 1))) $ \ls ->
437-- case S.parse (P.deintercalate concatFold prsr_1 concatFold prsr_2) (S.fromList ls) of
438-- Right parsed_list_tuple -> parsed_list_tuple == (partition (== 0) ls)
439-- Left _ -> False
441-- where
442-- prsr_1 = (P.takeWhile (== 0) FL.toList)
443-- prsr_2 = (P.takeWhile (== 1) FL.toList)
444-- concatFold = FL.Fold (\concatList curr_list -> return $ concatList ++ curr_list) (return []) return
446-- shortestPass :: Property
447-- shortestPass =
448-- forAll (listOf (chooseInt(min_value, max_value))) $ \ls ->
449-- let
450-- prsr_1 = P.takeWhile (<= (mid_value `Prelude.div` 2)) FL.toList
451-- prsr_2 = P.takeWhile (<= mid_value) FL.toList
452-- prsr_shortest = P.shortest prsr_1 prsr_2
453-- in
454-- case S.parse prsr_shortest (S.fromList ls) of
455-- Right short_list -> checkListEqual short_list (Prelude.takeWhile (<= 2500) ls)
456-- Left _ -> property False
458-- shortestFailLeft :: Property
459-- shortestFailLeft =
460-- property (case S.parse (P.shortest (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of
461-- Right r -> r == 1
462-- Left _ -> False)
464-- shortestFailRight :: Property
465-- shortestFailRight =
466-- property (case S.parse (P.shortest (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
467-- Right r -> r == 1
468-- Left _ -> False)
470-- shortestFailBoth :: Property
471-- shortestFailBoth =
472-- property (case S.parse (P.shortest (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
473-- Right _ -> False
474-- Left _ -> True)
476many :: Property
477many =
478 forAll (listOf (chooseInt (0, 1))) $ \ls ->
479 let fldstp conL currL = return $ FL.Partial $ conL ++ currL
480 concatFold = FL.Fold fldstp (return []) return
481 prsr = P.many concatFold
482 $ P.fromFold $ FL.sliceSepBy (== 1) FL.toList
483 in
484 case S.parse prsr (S.fromList ls) of
485 Right res_list -> checkListEqual res_list
486 $ Prelude.filter (== 0) ls
487 Left _ -> property False
489-- many_empty :: Property
490-- many_empty =
491-- property (case S.parse (P.many FL.toList (P.die "die")) (S.fromList [1 :: Int]) of
492-- Right res_list -> checkListEqual res_list ([] :: [Int])
493-- Left _ -> property False)
495some :: Property
496some =
497 forAll (listOf (chooseInt (0, 1))) $ \genLs ->
498 let
499 ls = 0 : genLs
500 concatFold = FL.Fold
501 (\concatList curr_list ->
502 return $ FL.Partial $ concatList ++ curr_list)
503 (return [])
504 return
505 prsr = P.some concatFold
506 $ P.fromFold $ FL.sliceSepBy (== 1) FL.toList
507 in
508 case S.parse prsr (S.fromList ls) of
509 Right res_list -> res_list == Prelude.filter (== 0) ls
510 Left _ -> False
512-- someFail :: Property
513-- someFail =
514-- property (case S.parse (P.some FL.toList (P.die "die")) (S.fromList [1 :: Int]) of
515-- Right _ -> False
516-- Left _ -> True)
518-------------------------------------------------------------------------------
519-- Instances
520-------------------------------------------------------------------------------
522-- XXX Remove "`suchThat` (\x -> length x > 0)) $ \ list1 ->" once FL.ltake is
523-- fixed.
524applicative :: Property
525applicative =
526 forAll (listOf (chooseAny :: Gen Int) `suchThat` (\x -> length x > 0)) $ \ list1 ->
527 forAll (listOf (chooseAny :: Gen Int)) $ \ list2 ->
528 let parser =
529 (,)
530 <$> P.fromFold (FL.ltake (length list1) FL.toList)
531 <*> P.fromFold (FL.ltake (length list2) FL.toList)
532 in monadicIO $ do
533 (olist1, olist2) <-
534 run $ S.parse parser (S.fromList $ list1 ++ list2)
535 listEquals (==) olist1 list1
536 listEquals (==) olist2 list2
538-- XXX Remove "`suchThat` (\x -> length x > 0)) $ \ list1 ->" once FL.ltake is
539-- fixed.
540sequence :: Property
541sequence =
542 forAll (vectorOf 11 (listOf (chooseAny :: Gen Int) `suchThat`
543 (\x -> length x > 0))) $ \ ins ->
544 let p xs = P.fromFold (FL.ltake (length xs) FL.toList)
545 in monadicIO $ do
546 outs <- run $
547 S.parse
548 (Prelude.sequence $ fmap p ins)
549 (S.fromList $ concat ins)
550 listEquals (==) outs ins
552-- XXX Remove "`suchThat` (\x -> length x > 0)) $ \ list1 ->" once FL.ltake is
553-- fixed.
554monad :: Property
555monad =
556 forAll (listOf (chooseAny :: Gen Int) `suchThat`
557 (\x -> length x > 0)) $ \ list1 ->
558 forAll (listOf (chooseAny :: Gen Int)) $ \ list2 ->
559 let parser = do
560 olist1 <- P.fromFold (FL.ltake (length list1) FL.toList)
561 olist2 <- P.fromFold (FL.ltake (length list2) FL.toList)
562 return (olist1, olist2)
563 in monadicIO $ do
564 (olist1, olist2) <-
565 run $ S.parse parser (S.fromList $ list1 ++ list2)
566 listEquals (==) olist1 list1
567 listEquals (==) olist2 list2
569-------------------------------------------------------------------------------
570-- Stream parsing
571-------------------------------------------------------------------------------
573parseMany :: Property
574parseMany =
575 forAll (chooseInt (1,100)) $ \len ->
576 forAll (listOf (vectorOf len (chooseAny :: Gen Int))) $ \ ins ->
577 monadicIO $ do
578 outs <- do
579 let p = P.fromFold $ FL.ltake len FL.toList
580 run
581 $ S.toList
582 $ S.parseMany p (S.fromList $ concat ins)
583 listEquals (==) outs ins
585-------------------------------------------------------------------------------
586-- Test for a particular case hit during fs events testing
587-------------------------------------------------------------------------------
589evId :: [Word8]
590evId = [96,238,17,9,0,0,0,0]
592evFlags :: [Word8]
593evFlags = [0,4,1,0,0,0,0,0]
595evPathLen :: [Word8]
596evPathLen = [71,0,0,0,0,0,0,0]
598evPath :: [Word8]
599evPath =
600 [47,85,115,101,114,115,47,118,111,108,47,118,101,109,98,97,47,99,111,109
601 ,112,111,115,101,119,101 ,108,108,45,116,101,99,104,47,69,110,103,47,112
602 ,114,111,106,101,99,116,115,47,115,116,114,101,97,109,108,121,47,115,116
603 ,114,101,97,109,108,121,47,116,109,112,47,122,122
604 ]
606event :: [Word8]
607event = evId ++ evFlags ++ evPathLen ++ evPath
609data Event = Event
610 { eventId :: Word64
611 , eventFlags :: Word32
612 , eventAbsPath :: A.Array Word8
613 } deriving (Show, Ord, Eq)
615readOneEvent :: P.Parser IO Word8 Event
616readOneEvent = do
617 arr <- P.takeEQ 24 (A.writeN 24)
618 let arr1 = A.unsafeCast arr :: A.Array Word64
619 eid = A.unsafeIndex arr1 0
620 eflags = A.unsafeIndex arr1 1
621 pathLen = fromIntegral $ A.unsafeIndex arr1 2
622 -- XXX handle if pathLen is 0
623 path <- P.takeEQ pathLen (A.writeN pathLen)
624 return $ Event
625 { eventId = eid
626 , eventFlags = fromIntegral eflags
627 , eventAbsPath = path
628 }
630parseMany2Events :: Property
631parseMany2Events =
632 monadicIO $ do
633 xs <-
634 ( run
635 $ S.toList
636 $ S.parseMany readOneEvent
637 $ S.fromList (concat (replicate 2 event))
638 )
639 assert (length xs == 2)
640 -- XXX assuming little endian machine
641 let ev = Event
642 { eventId = 152170080
643 , eventFlags = 66560
644 , eventAbsPath = A.fromList evPath
645 }
646 in listEquals (==) xs (replicate 2 ev)
648-------------------------------------------------------------------------------
649-- Main
650-------------------------------------------------------------------------------
652main :: IO ()
653main =
654 hspec $
655 H.parallel $
656 modifyMaxSuccess (const maxTestCount) $ do
657 describe "Instances" $ do
658 prop "applicative" applicative
659 prop "monad" monad
660 prop "sequence" sequence
662 describe "Stream parsing" $ do
663 prop "parseMany" parseMany
664 prop "parseMany2Events" parseMany2Events
666 describe "test for accumulator" $ do
667 prop "P.fromFold FL.sum = FL.sum" fromFold
668 prop "yield value provided" yield
669 prop "yield monadic value provided" yieldM
670 prop "fail err = Left (SomeException (ParseError err))" parserFail
671 prop "always fail" die
672 prop "always fail but monadic" dieM
674 describe "test for element parser" $ do
675 prop "peek = head with list length > 0" peekPass
676 prop "peek fail on []" peekFail
677 prop "eof pass on []" eofPass
678 prop "eof fail on non-empty list" eofFail
679 prop "first element exists and >= mid_value" satisfyPass
680 prop "check first element exists and satisfies predicate" satisfy
682 describe "test for sequence parser" $ do
683 prop "P.takeBetween = Prelude.take when len >= m and len <= n"
684 takeBetweenPass
685 prop ("P.takeBetween = Prelude.take when len >= m and len <= n and fail"
686 ++ "otherwise fail") Main.takeBetween
688 prop "P.takeEQ = Prelude.take when len >= n" takeEQPass
689 prop "P.takeEQ = Prelude.take when len >= n and fail otherwise"
690 Main.takeEQ
691 prop "P.takeGE n ls = ls when len >= n" takeGEPass
692 prop "P.takeGE n ls = ls when len >= n and fail otherwise" Main.takeGE
693 -- prop "lookAhead . take n >> lookAhead . take n = lookAhead . take n" lookAheadPass
694 -- prop "Fail when stream length exceeded" lookAheadFail
695 -- prop "lookAhead . take n >> lookAhead . take n = lookAhead . take n, else fail" lookAhead
696 prop "P.takeWhile = Prelude.takeWhile" Main.takeWhile
697 prop ("P.takeWhile1 = Prelude.takeWhile if taken something,"
698 ++ " else check why failed") takeWhile1
699 prop "P.groupBy = Prelude.head . Prelude.groupBy" groupBy
700 prop "many (P.wordBy ' ') = words'" wordBy
701 -- prop "" splitWithPass
702 -- prop "" splitWithFailLeft
703 -- prop "" splitWithFailRight
704 -- prop "" splitWithFailBoth
705 -- prop "" teeWithPass
706 -- prop "" teeWithFailLeft
707 -- prop "" teeWithFailRight
708 -- prop "" teeWithFailBoth
709 -- prop "" deintercalate
710 -- prop "" shortestPass
711 -- prop "" shortestFailLeft
712 -- prop "" shortestFailRight
713 -- prop "" shortestFailBoth
714 prop ("P.many concatFold $ P.sliceSepBy (== 1) FL.toList ="
715 ++ "Prelude.filter (== 0)") many
716 -- prop "[] due to parser being die" many_empty
717 prop ("P.some concatFold $ P.sliceSepBy (== 1) FL.toList ="
718 ++ "Prelude.filter (== 0)") some
719 -- prop "fail due to parser being die" someFail
720 takeProperties