2ae4887 · streamly · git.iko.soy

10module Streamly.Test.Prelude.Serial where

11

12import Control.Concurrent ( threadDelay )

13−import Control.Monad ( when )

13+import Control.Monad ( when, forM_ )

14import Data.Function ( (&) )

15import Data.IORef ( newIORef, readIORef, writeIORef )

16import Data.Int (Int64)

115seqSplitterProperties sep desc = do

116 describe (desc <> " splitOnSeq")

117 $ do

118− -- Empty seperator

118+

119− intercalateSplitEqId 0

120− intercalateSplitEqIdS 0

121− concatSplitIntercalateEqConcat splitOnSeq_ intercalate 0

122− concatSplitIntercalateEqConcatS splitOnSeq_ IS.intercalate 0

123−

124− -- Single element seperator

125− intercalateSplitEqId 1

119+ forM_ [0, 1, 2, 4] $ intercalateSplitEqId

126− intercalateSplitEqIdS 1

120+ forM_ [0, 1, 2, 4]

127− concatSplitIntercalateEqConcat splitOnSeq_ intercalate 1

128− concatSplitIntercalateEqConcatS splitOnSeq_ IS.intercalate 1

129−

130− -- Shift Or

131− intercalateSplitEqId 2

132− intercalateSplitEqIdS 2

133− concatSplitIntercalateEqConcat splitOnSeq_ intercalate 2

121+ $ concatSplitIntercalateEqConcat

134− concatSplitIntercalateEqConcatS splitOnSeq_ IS.intercalate 2

122+ splitOnSeq_

135−

123+ intercalate

136− -- Karp-Rabin

124+ IS.intercalate

137− intercalateSplitEqId 4

138− intercalateSplitEqIdS 4

139− concatSplitIntercalateEqConcat splitOnSeq_ intercalate 4

140− concatSplitIntercalateEqConcatS splitOnSeq_ IS.intercalate 4

141

125

142 -- Exclusive case

126 -- Exclusive case

143− splitIntercalateEqId splitOnSeq_ intercalate

127+ splitIntercalateEqId splitOnSeq_ intercalate IS.intercalate

144− splitIntercalateEqIdS splitOnSeq_ IS.intercalate

145

128

146 describe (desc <> " splitOnSuffixSeq")

129 describe (desc <> " splitOnSuffixSeq")

147 $ do

130 $ do

148− -- Empty seperator

149− intercalateSplitEqIdNoSepEnd 0

150− intercalateSplitEqIdNoSepEndS 0

151− concatSplitIntercalateEqConcat splitOnSuffixSeq_ intercalateSuffix 0

152− concatSplitIntercalateEqConcatS

153− splitOnSuffixSeq_

154− IS.intercalateSuffix

155− 0

156

131

157− -- Single element seperator

158− intercalateSplitEqIdNoSepEnd 1

132+ forM_ [0, 1, 2, 4] $ intercalateSplitEqIdNoSepEnd

159− intercalateSplitEqIdNoSepEndS 1

133+ forM_ [0, 1, 2, 4]

160− concatSplitIntercalateEqConcat splitOnSuffixSeq_ intercalateSuffix 1

134+ $ concatSplitIntercalateEqConcat

161− concatSplitIntercalateEqConcatS

135+ splitOnSuffixSeq_

162− splitOnSuffixSeq_

136+ intercalateSuffix

163− IS.intercalateSuffix

137+ IS.intercalateSuffix

164− 1

165

138

166− -- Shift Or

139+ -- Exclusive case

167− intercalateSplitEqIdNoSepEnd 2

140+ splitIntercalateEqId

168− intercalateSplitEqIdNoSepEndS 2

169− concatSplitIntercalateEqConcat splitOnSuffixSeq_ intercalateSuffix 2

170− concatSplitIntercalateEqConcatS

171− splitOnSuffixSeq_

172− IS.intercalateSuffix

173− 2

174−

175− -- Karp-Rabin

176− intercalateSplitEqIdNoSepEnd 4

177− intercalateSplitEqIdNoSepEndS 4

178− concatSplitIntercalateEqConcat splitOnSuffixSeq_ intercalateSuffix 4

179− concatSplitIntercalateEqConcatS

180 splitOnSuffixSeq_

141 splitOnSuffixSeq_

142+ intercalateSuffix

181 IS.intercalateSuffix

143 IS.intercalateSuffix

182− 4

183−

184− -- Exclusive case

185− splitIntercalateEqId splitOnSuffixSeq_ intercalateSuffix

186− splitIntercalateEqIdS splitOnSuffixSeq_ IS.intercalateSuffix

187

144

188 where

145 where

189

146

216 <> show i <> " element separator)"

173 <> show i <> " element separator)"

217 in prop name

174 in prop name

218 $ forAll listWithSep

175 $ forAll listWithSep

219− $ \xs -> do

220− withMaxSuccess maxTestCount

176+ $ \xs -> withMaxSuccess maxTestCount $ monadicIO $ testCase xs

221− $ monadicIO

177+

222− $ do

178+ where

223− ys <- splitOnSeq_ xs (replicate i sep)

179+

224− listEquals

180+ testCase xs = do

225− (==)

226− (intercalate (replicate i sep) ys)

227− xs

228−

229− intercalateSplitEqIdS i =

230− let name =

231− "S.intercalate . splitOnSeq == id ("

232− <> show i <> " element separator)"

233− in prop name

234− $ forAll listWithSep

235− $ \xs -> do

236− withMaxSuccess maxTestCount

237− $ monadicIO

238− $ do

239− ys <- splitOnSeq_ xs (replicate i sep)

181+ ys <- splitOnSeq_ xs (replicate i sep)

240− zs <-

182+ szs <-

241− IS.toList

183+ IS.toList

242− $ IS.intercalate

184+ $ IS.intercalate (replicate i sep) UF.fromList

243− (replicate i sep)

244− UF.fromList

245− $ IS.fromList ys

185+ $ IS.fromList ys

186+ let lzs = intercalate (replicate i sep) ys

187+ listEquals (==) szs xs

246− listEquals (==) zs xs

188+ listEquals (==) lzs xs

247

189

248 intercalateSplitEqIdNoSepEnd i =

190 intercalateSplitEqIdNoSepEnd i =

249 let name =

191 let name =

253 $ forAll ((,) <$> listWithSep <*> nonSepElem)

195 $ forAll ((,) <$> listWithSep <*> nonSepElem)

254 $ \(xs_, nonSep) -> do

196 $ \(xs_, nonSep) -> do

255 let xs = xs_ ++ [nonSep]

197 let xs = xs_ ++ [nonSep]

256− withMaxSuccess maxTestCount

198+ withMaxSuccess maxTestCount $ monadicIO $ testCase xs

257− $ monadicIO

199+

258− $ do

200+ where

259− ys <- splitOnSuffixSeq_ xs (replicate i sep)

201+

260− listEquals

202+ testCase xs = do

261− (==)

262− (intercalate (replicate i sep) ys)

263− xs

264−

265− intercalateSplitEqIdNoSepEndS i =

266− let name =

267− "S.intercalate . splitOnSuffixSeq_ . (++ [x \\= sep]) == id ("

268− <> show i <> " element separator)"

269− in prop name

270− $ forAll ((,) <$> listWithSep <*> nonSepElem)

271− $ \(xs_, nonSep) -> do

272− let xs = xs_ ++ [nonSep]

273− withMaxSuccess maxTestCount

274− $ monadicIO

275− $ do

276− ys <- splitOnSuffixSeq_ xs (replicate i sep)

203+ ys <- splitOnSuffixSeq_ xs (replicate i sep)

277− zs <-

204+ szs <-

278− IS.toList

205+ IS.toList

279− $ IS.intercalate

206+ $ IS.intercalate (replicate i sep) UF.fromList

280− (replicate i sep)

281− UF.fromList

282− $ IS.fromList ys

207+ $ IS.fromList ys

208+ let lzs = intercalate (replicate i sep) ys

209+ listEquals (==) szs xs

283− listEquals (==) zs xs

210+ listEquals (==) lzs xs

284−

211+

285− concatSplitIntercalateEqConcat splitter intercalater i =

212+ concatSplitIntercalateEqConcat splitter lintercalater sintercalater i =

286− let name =

287− "concat . splitter . intercalater == "

288− <> "concat ("

289− <> show i <> " element separator/possibly empty list)"

290− in prop name

291− $ forAll listsWithoutSep

292− $ \xss -> do

293− withMaxSuccess maxTestCount

294− $ monadicIO

295− $ do

296− let xs = intercalater (replicate i sep) xss

297− ys <- splitter xs (replicate i sep)

298− listEquals (==) (concat ys) (concat xss)

299−

300− concatSplitIntercalateEqConcatS splitter intercalater i =

301 let name =

213 let name =

302 "concat . splitter . S.intercalater == "

214 "concat . splitter . S.intercalater == "

303 <> "concat ("

215 <> "concat ("

304 <> show i <> " element separator/possibly empty list)"

216 <> show i <> " element separator/possibly empty list)"

305 in prop name

217 in prop name

306 $ forAll listsWithoutSep

218 $ forAll listsWithoutSep

307− $ \xss -> do

308− withMaxSuccess maxTestCount

219+ $ \xss -> withMaxSuccess maxTestCount $ monadicIO $ testCase xss

309− $ monadicIO

220+

310− $ do

221+ where

311− xs <-

222+

223+ testCase xss = do

224+ let lxs = lintercalater (replicate i sep) xss

225+ lys <- splitter lxs (replicate i sep)

226+ sxs <-

312− S.toList

227+ S.toList

313− $ intercalater

314− (replicate i sep)

228+ $ sintercalater (replicate i sep) UF.fromList

315− UF.fromList

316− $ S.fromList xss

229+ $ S.fromList xss

317− ys <- splitter xs (replicate i sep)

230+ sys <- splitter sxs (replicate i sep)

318− listEquals (==) (concat ys) (concat xss)

231+ listEquals (==) (concat lys) (concat xss)

319−

232+ listEquals (==) (concat sys) (concat xss)

233+

320− splitIntercalateEqId splitter intercalater =

234+ splitIntercalateEqId splitter lintercalater sintercalater =

321− let name =

322− "splitter . intercalater == id"

323− <> " (exclusive separator/non-empty list)"

324− in prop name

325− $ forAll listsWithoutSep1

326− $ \xss -> do

327− withMaxSuccess maxTestCount

328− $ monadicIO

329− $ do

330− let xs = intercalater [sep] xss

331− ys <- splitter xs [sep]

332− listEquals (==) ys xss

333−

334− splitIntercalateEqIdS splitter intercalater =

335 let name =

235 let name =

336 "splitter . intercalater == id"

236 "splitter . intercalater == id"

337 <> " (exclusive separator/non-empty list)"

237 <> " (exclusive separator/non-empty list)"

338 in prop name

238 in prop name

339 $ forAll listsWithoutSep1

239 $ forAll listsWithoutSep1

340 $ \xss -> do

240 $ \xss -> do

341− withMaxSuccess maxTestCount

241+ withMaxSuccess maxTestCount $ monadicIO $ testCase xss

342− $ monadicIO

242+

343− $ do

243+ where

344− xs <-

244+

345− S.toList

245+ testCase xss = do

346− $ intercalater [sep] UF.fromList

246+ let lxs = lintercalater [sep] xss

247+ lys <- splitter lxs [sep]

347− $ S.fromList xss

248+ sxs <- S.toList $ sintercalater [sep] UF.fromList $ S.fromList xss

348− ys <- splitter xs [sep]

249+ sys <- splitter sxs [sep]

250+ listEquals (==) lys xss

349− listEquals (==) ys xss

251+ listEquals (==) sys xss

350

252

351

253

352groupSplitOps :: String -> Spec

254groupSplitOps :: String -> Spec