git.iko.soy/streamly
on 8af89dd help sign in
streamly/test/Streamly/Test/Data/Parser.hs
723 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)
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
314sliceSepByP :: Property
315sliceSepByP =
316 forAll (listOf (chooseInt (min_value, max_value ))) $ \ls ->
317 case S.parse (P.sliceSepByP predicate prsr) (S.fromList ls) of
318 Right parsed_list ->
319 checkListEqual parsed_list (tkwhl ls)
320 Left _ -> property False
321 where
322 predicate = (>= 100)
323 prsr = P.many FL.toList (P.satisfy (const True))
324 tkwhl ls = Prelude.takeWhile (not . predicate) ls
327takeWhile :: Property
328takeWhile =
329 forAll (listOf (chooseInt (0, 1))) $ \ ls ->
330 case S.parse (P.takeWhile predicate FL.toList) (S.fromList ls) of
331 Right parsed_list ->
332 checkListEqual parsed_list (Prelude.takeWhile predicate ls)
333 Left _ -> property False
334 where
335 predicate = (== 0)
337takeWhile1 :: Property
338takeWhile1 =
339 forAll (listOf (chooseInt (0, 1))) $ \ ls ->
340 case S.parse (P.takeWhile1 predicate FL.toList) (S.fromList ls) of
341 Right parsed_list -> case ls of
342 [] -> property False
343 (x : _) ->
344 if predicate x
345 then
346 checkListEqual parsed_list
347 $ Prelude.takeWhile predicate ls
348 else
349 property False
350 Left _ -> case ls of
351 [] -> property True
352 (x : _) -> property (not $ predicate x)
353 where
354 predicate = (== 0)
356groupBy :: Property
357groupBy =
358 forAll (listOf (chooseInt (0, 1)))
359 $ \ls ->
360 case S.parse parser (S.fromList ls) of
361 Right parsed -> checkListEqual parsed (groupByLF ls)
362 Left _ -> property False
364 where
366 cmp = (==)
367 parser = P.groupBy cmp FL.toList
368 groupByLF lst
369 | null lst = []
370 | otherwise = head $ List.groupBy cmp lst
373wordBy :: Property
374wordBy =
375 forAll (listOf (elements [' ', 's']))
376 $ \ls ->
377 case S.parse parser (S.fromList ls) of
378 Right parsed -> checkListEqual parsed (words' ls)
379 Left _ -> property False
381 where
383 predicate = (== ' ')
384 parser = P.many FL.toList (P.wordBy predicate FL.toList)
385 words' lst =
386 let wrds = words lst
387 in if wrds == [] then [""] else wrds
389-- splitWithPass :: Property
390-- splitWithPass =
391-- forAll (listOf (chooseInt (0, 1))) $ \ls ->
392-- case S.parse (P.splitWith (,) (P.satisfy (== 0)) (P.satisfy (== 1))) (S.fromList ls) of
393-- Right (result_first, result_second) -> case ls of
394-- 0 : 1 : _ -> (result_first == 0) && (result_second == 1)
395-- _ -> False
396-- Left _ -> case ls of
397-- 0 : 1 : _ -> False
398-- _ -> True
400-- splitWithFailLeft :: Property
401-- splitWithFailLeft =
402-- property (case S.parse (P.splitWith (,) (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of
403-- Right _ -> False
404-- Left _ -> True)
406-- splitWithFailRight :: Property
407-- splitWithFailRight =
408-- property (case S.parse (P.splitWith (,) (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
409-- Right _ -> False
410-- Left _ -> True)
412-- splitWithFailBoth :: Property
413-- splitWithFailBoth =
414-- property (case S.parse (P.splitWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
415-- Right _ -> False
416-- Left _ -> True)
418-- teeWithPass :: Property
419-- teeWithPass =
420-- forAll (chooseInt (0, 10000)) $ \n ->
421-- forAll (listOf (chooseInt (0, 1))) $ \ls ->
422-- let
423-- prsr = P.take n FL.toList
424-- in
425-- case S.parse (P.teeWith (,) prsr prsr) (S.fromList ls) of
426-- Right (ls_1, ls_2) -> checkListEqual (Prelude.take n ls) ls_1 .&&. checkListEqual ls_1 ls_2
427-- Left _ -> property False
429-- teeWithFailLeft :: Property
430-- teeWithFailLeft =
431-- property (case S.parse (P.teeWith (,) (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of
432-- Right _ -> False
433-- Left _ -> True)
435-- teeWithFailRight :: Property
436-- teeWithFailRight =
437-- property (case S.parse (P.teeWith (,) (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
438-- Right _ -> False
439-- Left _ -> True)
441-- teeWithFailBoth :: Property
442-- teeWithFailBoth =
443-- property (case S.parse (P.teeWith (,) (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
444-- Right _ -> False
445-- Left _ -> True)
447-- deintercalate :: Property
448-- deintercalate =
449-- forAll (listOf (chooseInt (0, 1))) $ \ls ->
450-- case S.parse (P.deintercalate concatFold prsr_1 concatFold prsr_2) (S.fromList ls) of
451-- Right parsed_list_tuple -> parsed_list_tuple == (partition (== 0) ls)
452-- Left _ -> False
454-- where
455-- prsr_1 = (P.takeWhile (== 0) FL.toList)
456-- prsr_2 = (P.takeWhile (== 1) FL.toList)
457-- concatFold = FL.Fold (\concatList curr_list -> return $ concatList ++ curr_list) (return []) return
459-- shortestPass :: Property
460-- shortestPass =
461-- forAll (listOf (chooseInt(min_value, max_value))) $ \ls ->
462-- let
463-- prsr_1 = P.takeWhile (<= (mid_value `Prelude.div` 2)) FL.toList
464-- prsr_2 = P.takeWhile (<= mid_value) FL.toList
465-- prsr_shortest = P.shortest prsr_1 prsr_2
466-- in
467-- case S.parse prsr_shortest (S.fromList ls) of
468-- Right short_list -> checkListEqual short_list (Prelude.takeWhile (<= 2500) ls)
469-- Left _ -> property False
471-- shortestFailLeft :: Property
472-- shortestFailLeft =
473-- property (case S.parse (P.shortest (P.die "die") (P.yield (1 :: Int))) (S.fromList [1 :: Int]) of
474-- Right r -> r == 1
475-- Left _ -> False)
477-- shortestFailRight :: Property
478-- shortestFailRight =
479-- property (case S.parse (P.shortest (P.yield (1 :: Int)) (P.die "die")) (S.fromList [1 :: Int]) of
480-- Right r -> r == 1
481-- Left _ -> False)
483-- shortestFailBoth :: Property
484-- shortestFailBoth =
485-- property (case S.parse (P.shortest (P.die "die") (P.die "die")) (S.fromList [1 :: Int]) of
486-- Right _ -> False
487-- Left _ -> True)
489many :: Property
490many =
491 forAll (listOf (chooseInt (0, 1))) $ \ls ->
492 let fldstp conL currL = return $ FL.Partial $ conL ++ currL
493 concatFold = FL.Fold fldstp (return (FL.Partial [])) return
494 prsr =
495 P.many concatFold $ P.fromFold $ FL.sliceSepBy (== 1) FL.toList
496 in
497 case S.parse prsr (S.fromList ls) of
498 Right res_list -> checkListEqual res_list
499 $ Prelude.filter (== 0) ls
500 Left _ -> property False
502-- many_empty :: Property
503-- many_empty =
504-- property (case S.parse (P.many FL.toList (P.die "die")) (S.fromList [1 :: Int]) of
505-- Right res_list -> checkListEqual res_list ([] :: [Int])
506-- Left _ -> property False)
508some :: Property
509some =
510 forAll (listOf (chooseInt (0, 1))) $ \genLs ->
511 let
512 ls = 0 : genLs
513 fldstp conL currL = return $ FL.Partial $ conL ++ currL
514 concatFold = FL.Fold fldstp (return (FL.Partial [])) return
515 prsr =
516 P.some concatFold $ P.fromFold $ FL.sliceSepBy (== 1) FL.toList
517 in
518 case S.parse prsr (S.fromList ls) of
519 Right res_list -> res_list == Prelude.filter (== 0) ls
520 Left _ -> False
522-- someFail :: Property
523-- someFail =
524-- property (case S.parse (P.some FL.toList (P.die "die")) (S.fromList [1 :: Int]) of
525-- Right _ -> False
526-- Left _ -> True)
528-------------------------------------------------------------------------------
529-- Instances
530-------------------------------------------------------------------------------
532applicative :: Property
533applicative =
534 forAll (listOf (chooseAny :: Gen Int)) $ \ list1 ->
535 forAll (listOf (chooseAny :: Gen Int)) $ \ list2 ->
536 let parser =
537 (,)
538 <$> P.fromFold (FL.takeLE (length list1) FL.toList)
539 <*> P.fromFold (FL.takeLE (length list2) FL.toList)
540 in monadicIO $ do
541 (olist1, olist2) <-
542 run $ S.parse parser (S.fromList $ list1 ++ list2)
543 listEquals (==) olist1 list1
544 listEquals (==) olist2 list2
546sequence :: Property
547sequence =
548 forAll (vectorOf 11 (listOf (chooseAny :: Gen Int))) $ \ ins ->
549 let p xs = P.fromFold (FL.takeLE (length xs) FL.toList)
550 in monadicIO $ do
551 outs <- run $
552 S.parse
553 (Prelude.sequence $ fmap p ins)
554 (S.fromList $ concat ins)
555 listEquals (==) outs ins
557monad :: Property
558monad =
559 forAll (listOf (chooseAny :: Gen Int)) $ \ list1 ->
560 forAll (listOf (chooseAny :: Gen Int)) $ \ list2 ->
561 let parser = do
562 olist1 <- P.fromFold (FL.takeLE (length list1) FL.toList)
563 olist2 <- P.fromFold (FL.takeLE (length list2) FL.toList)
564 return (olist1, olist2)
565 in monadicIO $ do
566 (olist1, olist2) <-
567 run $ S.parse parser (S.fromList $ list1 ++ list2)
568 listEquals (==) olist1 list1
569 listEquals (==) olist2 list2
571-------------------------------------------------------------------------------
572-- Stream parsing
573-------------------------------------------------------------------------------
575parseMany :: Property
576parseMany =
577 forAll (chooseInt (1,100)) $ \len ->
578 forAll (listOf (vectorOf len (chooseAny :: Gen Int))) $ \ ins ->
579 monadicIO $ do
580 outs <- do
581 let p = P.fromFold $ FL.takeLE len FL.toList
582 run
583 $ S.toList
584 $ S.parseMany p (S.fromList $ concat ins)
585 listEquals (==) outs ins
587-------------------------------------------------------------------------------
588-- Test for a particular case hit during fs events testing
589-------------------------------------------------------------------------------
591evId :: [Word8]
592evId = [96,238,17,9,0,0,0,0]
594evFlags :: [Word8]
595evFlags = [0,4,1,0,0,0,0,0]
597evPathLen :: [Word8]
598evPathLen = [71,0,0,0,0,0,0,0]
600evPath :: [Word8]
601evPath =
602 [47,85,115,101,114,115,47,118,111,108,47,118,101,109,98,97,47,99,111,109
603 ,112,111,115,101,119,101 ,108,108,45,116,101,99,104,47,69,110,103,47,112
604 ,114,111,106,101,99,116,115,47,115,116,114,101,97,109,108,121,47,115,116
605 ,114,101,97,109,108,121,47,116,109,112,47,122,122
606 ]
608event :: [Word8]
609event = evId ++ evFlags ++ evPathLen ++ evPath
611data Event = Event
612 { eventId :: Word64
613 , eventFlags :: Word32
614 , eventAbsPath :: A.Array Word8
615 } deriving (Show, Ord, Eq)
617readOneEvent :: P.Parser IO Word8 Event
618readOneEvent = do
619 arr <- P.takeEQ 24 (A.writeN 24)
620 let arr1 = A.unsafeCast arr :: A.Array Word64
621 eid = A.unsafeIndex arr1 0
622 eflags = A.unsafeIndex arr1 1
623 pathLen = fromIntegral $ A.unsafeIndex arr1 2
624 -- XXX handle if pathLen is 0
625 path <- P.takeEQ pathLen (A.writeN pathLen)
626 return $ Event
627 { eventId = eid
628 , eventFlags = fromIntegral eflags
629 , eventAbsPath = path
630 }
632parseMany2Events :: Property
633parseMany2Events =
634 monadicIO $ do
635 xs <-
636 ( run
637 $ S.toList
638 $ S.parseMany readOneEvent
639 $ S.fromList (concat (replicate 2 event))
640 )
641 assert (length xs == 2)
642 -- XXX assuming little endian machine
643 let ev = Event
644 { eventId = 152170080
645 , eventFlags = 66560
646 , eventAbsPath = A.fromList evPath
647 }
648 in listEquals (==) xs (replicate 2 ev)
650-------------------------------------------------------------------------------
651-- Main
652-------------------------------------------------------------------------------
654main :: IO ()
655main =
656 hspec $
657 H.parallel $
658 modifyMaxSuccess (const maxTestCount) $ do
659 describe "Instances" $ do
660 prop "applicative" applicative
661 prop "monad" monad
662 prop "sequence" sequence
664 describe "Stream parsing" $ do
665 prop "parseMany" parseMany
666 prop "parseMany2Events" parseMany2Events
668 describe "test for accumulator" $ do
669 prop "P.fromFold FL.sum = FL.sum" fromFold
670 prop "yield value provided" yield
671 prop "yield monadic value provided" yieldM
672 prop "fail err = Left (SomeException (ParseError err))" parserFail
673 prop "always fail" die
674 prop "always fail but monadic" dieM
676 describe "test for element parser" $ do
677 prop "peek = head with list length > 0" peekPass
678 prop "peek fail on []" peekFail
679 prop "eof pass on []" eofPass
680 prop "eof fail on non-empty list" eofFail
681 prop "first element exists and >= mid_value" satisfyPass
682 prop "check first element exists and satisfies predicate" satisfy
684 describe "test for sequence parser" $ do
685 prop "P.takeBetween = Prelude.take when len >= m and len <= n"
686 takeBetweenPass
687 prop ("P.takeBetween = Prelude.take when len >= m and len <= n and fail"
688 ++ "otherwise fail") Main.takeBetween
690 prop "P.takeEQ = Prelude.take when len >= n" takeEQPass
691 prop "P.takeEQ = Prelude.take when len >= n and fail otherwise"
692 Main.takeEQ
693 prop "P.takeGE n ls = ls when len >= n" takeGEPass
694 prop "P.takeGE n ls = ls when len >= n and fail otherwise" Main.takeGE
695 -- prop "lookAhead . take n >> lookAhead . take n = lookAhead . take n" lookAheadPass
696 -- prop "Fail when stream length exceeded" lookAheadFail
697 -- prop "lookAhead . take n >> lookAhead . take n = lookAhead . take n, else fail" lookAhead
698 prop "P.sliceSepByP test" Main.sliceSepByP
699 prop "P.takeWhile = Prelude.takeWhile" Main.takeWhile
700 prop ("P.takeWhile1 = Prelude.takeWhile if taken something,"
701 ++ " else check why failed") takeWhile1
702 prop "P.groupBy = Prelude.head . Prelude.groupBy" groupBy
703 prop "many (P.wordBy ' ') = words'" wordBy
704 -- prop "" splitWithPass
705 -- prop "" splitWithFailLeft
706 -- prop "" splitWithFailRight
707 -- prop "" splitWithFailBoth
708 -- prop "" teeWithPass
709 -- prop "" teeWithFailLeft
710 -- prop "" teeWithFailRight
711 -- prop "" teeWithFailBoth
712 -- prop "" deintercalate
713 -- prop "" shortestPass
714 -- prop "" shortestFailLeft
715 -- prop "" shortestFailRight
716 -- prop "" shortestFailBoth
717 prop ("P.many concatFold $ P.sliceSepBy (== 1) FL.toList ="
718 ++ "Prelude.filter (== 0)") many
719 -- prop "[] due to parser being die" many_empty
720 prop ("P.some concatFold $ P.sliceSepBy (== 1) FL.toList ="
721 ++ "Prelude.filter (== 0)") some
722 -- prop "fail due to parser being die" someFail
723 takeProperties