656bfc6 · streamly · git.iko.soy

git.iko.soy/streamly

Add tests and benchmarks for takeBetween

commit656bfc6bc875ba22d4d7562170761b2784021529 authorAnurag Hooda <anuraghooda@composewell.com> dateFri 18 Dec 2020, 02:06 (6 years ago) parent4ee157f

5 files changed+97−4

compare with master

unifiedsplit

benchmark/Streamly/Benchmark/Data/Parser.hs+6−1 benchmark/streamly-benchmarks.cabal+2−1 src/Streamly/Internal/Data/Parser.hs+2−2 test/Streamly/Test/Data/Parser.hs+53 test/Streamly/Test/Data/Parser/ParserD.hs+34

benchmark/Streamly/Benchmark/Data/Parser.hs+6−1

@@ -60,6 +60,10 @@ benchIOSink value name f =

6060-- Parsers

6161-------------------------------------------------------------------------------

6262

63+{-# INLINE takeBetween #-}

64+takeBetween :: MonadCatch m => Int -> SerialT m a -> m ()

65+takeBetween value = IP.parse (PR.takeBetween 0 value FL.drain)

66+

6367{-# INLINE takeEQ #-}

6468takeEQ :: MonadCatch m => Int -> SerialT m a -> m ()

6569takeEQ value = IP.parse (PR.takeEQ value FL.drain)

@@ -267,7 +271,8 @@ moduleName = "Data.Parser"

267271

268272o_1_space_serial :: Int -> [Benchmark]

269273o_1_space_serial value =

270− [ benchIOSink value "takeEQ" $ takeEQ value

274+ [ benchIOSink value "takeBetween" $ takeBetween value

275+ , benchIOSink value "takeEQ" $ takeEQ value

271276 , benchIOSink value "takeWhile" $ takeWhile value

272277 , benchIOSink value "drainWhile" $ drainWhile value

273278 , benchIOSink value "groupBy" $ groupBy

benchmark/streamly-benchmarks.cabal+2−1

@@ -173,7 +173,7 @@ benchmark Prelude.Serial

173173 , Serial.Nested

174174 , Serial.Exceptions

175175 , Serial.Split

176− ghc-options: +RTS -M750M -RTS

176+ ghc-options: +RTS -M1000M -RTS

177177 if impl(ghcjs)

178178 buildable: False

179179 else

@@ -314,6 +314,7 @@ benchmark Data.Parser

314314 import: bench-options

315315 type: exitcode-stdio-1.0

316316 hs-source-dirs: Streamly/Benchmark/Data

317+ ghc-options: +RTS -M750M -RTS

317318 main-is: Parser.hs

318319 if impl(ghcjs)

319320 buildable: False

src/Streamly/Internal/Data/Parser.hs+2−2

@@ -337,8 +337,8 @@ either = K.toParserK . D.either

337337-- | @takeBetween m n@ takes a minimum of @m@ and a maximum of @n@ input

338338-- elements and folds them using the supplied fold.

339339--

340−-- Stops after @m@ elements.

341−-- Fails if the stream ends before @n@ elements could be taken.

340+-- Stops after @n@ elements.

341+-- Fails if the stream ends before @m@ elements could be taken.

342342--

343343-- Examples: -

344344--

test/Streamly/Test/Data/Parser.hs+53

@@ -155,6 +155,54 @@ satisfy =

155155 predicate = (>= mid_value)

156156

157157-- Sequence Parsers Tests

158+takeBetweenPass :: Property

159+takeBetweenPass =

160+ forAll (chooseInt (min_value, max_value)) $ \m ->

161+ forAll (chooseInt (m, max_value)) $ \n ->

162+ forAll (chooseInt (m, max_value)) $ \list_length ->

163+ forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->

164+ case S.parse (P.takeBetween m n FL.toList) (S.fromList ls) of

165+ Right parsed_list ->

166+ let lpl = Prelude.length parsed_list

167+ in checkListEqual parsed_list (Prelude.take lpl ls)

168+ Left _ -> property False

169+

170+takeBetween :: Property

171+takeBetween =

172+ forAll (chooseInt (min_value, max_value)) $ \m ->

173+ forAll (chooseInt (min_value, max_value)) $ \n ->

174+ forAll (listOf(chooseInt (min_value, max_value))) $ \ls ->

175+ let

176+ list_length = Prelude.length ls

177+ in

178+ case S.parse (P.takeBetween m n FL.toList) (S.fromList ls) of

179+ Right parsed_list ->

180+ if m <= list_length && n >= list_length

181+ then

182+ let lpl = Prelude.length parsed_list

183+ in checkListEqual parsed_list (Prelude.take

184+ lpl ls)

185+ else property False

186+ Left _ -> property (m > n || list_length < m)

187+

188+

189+-- takeBetween :: Property

190+-- takeBetween =

191+-- forAll (chooseInt (min_value, max_value)) $ \m ->

192+-- forAll (chooseInt (min_value, max_value)) $ \n ->

193+-- forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->

194+-- let

195+-- list_length = Prelude.length ls

196+-- in

197+-- case S.parseD (P.takeBetween m n FL.toList) (S.fromList ls) of

198+-- Right parsed_list ->

199+-- if m <= list_length && n >= list_length

200+-- then

201+-- let lpl = Prelude.length parsed_list

202+-- in checkListEqual parsed_list (Prelude.take

203+-- lpl ls)

204+-- else property False

205+-- Left _ -> property (m > n || list_length < m)

158206

159207takeEQPass :: Property

160208takeEQPass =

@@ -634,6 +682,11 @@ main =

634682 prop "check first element exists and satisfies predicate" satisfy

635683

636684 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

689+

637690 prop "P.takeEQ = Prelude.take when len >= n" takeEQPass

638691 prop "P.takeEQ = Prelude.take when len >= n and fail otherwise" Main.takeEQ

639692 prop "P.takeGE n ls = ls when len >= n" takeGEPass

test/Streamly/Test/Data/Parser/ParserD.hs+34

@@ -147,6 +147,36 @@ satisfy =

147147 predicate = (>= mid_value)

148148

149149-- Sequence Parsers Tests

150+takeBetweenPass :: Property

151+takeBetweenPass =

152+ forAll (chooseInt (min_value, max_value)) $ \m ->

153+ forAll (chooseInt (m, max_value)) $ \n ->

154+ forAll (chooseInt (m, max_value)) $ \list_length ->

155+ forAll (vectorOf list_length (chooseInt (min_value, max_value))) $ \ls ->

156+ case S.parseD (P.takeBetween m n FL.toList) (S.fromList ls) of

157+ Right parsed_list ->

158+ let lpl = Prelude.length parsed_list

159+ in checkListEqual parsed_list (Prelude.take lpl ls)

160+ Left _ -> property False

161+

162+

163+takeBetween :: Property

164+takeBetween =

165+ forAll (chooseInt (min_value, max_value)) $ \m ->

166+ forAll (chooseInt (min_value, max_value)) $ \n ->

167+ forAll (listOf (chooseInt (min_value, max_value))) $ \ls ->

168+ let

169+ list_length = Prelude.length ls

170+ in

171+ case S.parseD (P.takeBetween m n FL.toList) (S.fromList ls) of

172+ Right parsed_list ->

173+ if m <= list_length && n >= list_length

174+ then

175+ let lpl = Prelude.length parsed_list

176+ in checkListEqual parsed_list (Prelude.take

177+ lpl ls)

178+ else property False

179+ Left _ -> property (m > n || list_length < m)

150180

151181take :: Property

152182take =

@@ -662,6 +692,10 @@ main =

662692 prop "check first element exists and satisfies predicate" satisfy

663693

664694 describe "test for sequence parser" $ do

695+ prop "P.takeBetween m n = Prelude.take when len >= m and len <= n"

696+ takeBetweenPass

697+ prop "P.takeBetween m n = Prelude.take when len >= m and len <= n and\

698+ \fail otherwise" takeBetween

665699 prop "P.take = Prelude.take" Main.take

666700 prop "P.takeEQ = Prelude.take when len >= n" takeEQPass

667701 prop "P.takeEQ = Prelude.take when len >= n and fail otherwise" Main.takeEQ