git.iko.soy/streamly
on master help sign in
Abstract out the splitOnSeq property tests
aaae284adithyaov
test/Streamly/Test/Prelude/Serial.hs+98−52
compare with master
unifiedsplit
@@ -16,6 +16,7 @@ import Data.IORef ( newIORef, readIORef, writeIORef )
16import Data.Int (Int64)
16import Data.Int (Int64)
17import Data.List (intercalate)
17import Data.List (intercalate)
18import Data.Maybe ( isJust, fromJust )
18import Data.Maybe ( isJust, fromJust )
19+import Foreign.Storable (Storable)
19#if __GLASGOW_HASKELL__ < 808
20#if __GLASGOW_HASKELL__ < 808
20import Data.Semigroup ((<>))
21import Data.Semigroup ((<>))
21#endif
22#endif
@@ -23,7 +24,7 @@ import Test.Hspec.QuickCheck
23import Test.QuickCheck
24import Test.QuickCheck
24 ( Gen
25 ( Gen
25 , Property
26 , Property
26− , arbitrary
27+ , Arbitrary(..)
27 , choose
28 , choose
28 , elements
29 , elements
29 , forAll
30 , forAll
@@ -106,55 +107,108 @@ splitOnSuffixSeq = do
106 S.toList
107 S.toList
107 $ IS.splitOnSuffixSeq (A.fromList pat) (FL.toList) (S.fromList xs)
108 $ IS.splitOnSuffixSeq (A.fromList pat) (FL.toList) (S.fromList xs)
108
109
110+seqSplitterProperties ::
111+ forall a. (Arbitrary a, Eq a, Show a, Storable a, Enum a)
112+ => a
113+ -> String
114+ -> Spec
115+seqSplitterProperties sep desc = do
116+ describe (desc <> " splitOnSeq/intercalate")
117+ $ do
118+ -- Empty seperator
119+ intercalateSplitEqId 0
120+ concatSplitIntercalateEqConcat splitOnSeq_ intercalate 0
121+
122+ -- Single element seperator
123+ intercalateSplitEqId 1
124+ concatSplitIntercalateEqConcat splitOnSeq_ intercalate 1
125+
126+ -- Shift Or
127+ intercalateSplitEqId 2
128+ concatSplitIntercalateEqConcat splitOnSeq_ intercalate 2
129+
130+ -- Karp-Rabin
131+ intercalateSplitEqId 4
132+ concatSplitIntercalateEqConcat splitOnSeq_ intercalate 4
133+
134+ -- Exclusive case
135+ splitIntercalateEqId splitOnSeq_ intercalate
136+
137+ where
138+
139+ splitOnSeq_ xs ys =
140+ S.toList $ IS.splitOnSeq (A.fromList ys) FL.toList (S.fromList xs)
141+
142+ nonSepElem :: Gen a
143+ nonSepElem = suchThat arbitrary (/= sep)
144+
145+ listWithSep :: Gen [a]
146+ listWithSep = listOf $ frequency [(3, arbitrary), (1, elements [sep])]
147+
148+ listWithoutSep :: Gen [a]
149+ listWithoutSep = vectorOf 4 nonSepElem
150+
151+ listsWithoutSep :: Gen [[a]]
152+ listsWithoutSep = listOf listWithoutSep
153+
154+ listsWithoutSep1 :: Gen [[a]]
155+ listsWithoutSep1 = listOf1 listWithoutSep
156+
157+ intercalateSplitEqId i =
158+ let name =
159+ "intercalate . splitOnSeq == id ("
160+ <> show i <> " element separator)"
161+ in prop name
162+ $ forAll listWithSep
163+ $ \xs -> do
164+ withMaxSuccess maxTestCount
165+ $ monadicIO
166+ $ do
167+ ys <- splitOnSeq_ xs (replicate i sep)
168+ listEquals
169+ (==)
170+ (intercalate (replicate i sep) ys)
171+ xs
172+
173+ concatSplitIntercalateEqConcat splitter intercalater i =
174+ let name =
175+ "concat . splitter . intercalater == "
176+ <> "concat ("
177+ <> show i <> " element separator/possibly empty list)"
178+ in prop name
179+ $ forAll listsWithoutSep
180+ $ \xss -> do
181+ withMaxSuccess maxTestCount
182+ $ monadicIO
183+ $ do
184+ let xs = intercalater (replicate i sep) xss
185+ ys <- splitter xs (replicate i sep)
186+ listEquals (==) (concat ys) (concat xss)
187+
188+ splitIntercalateEqId splitter intercalater =
189+ let name =
190+ "splitter . intercalater == id"
191+ <> " (exclusive separator/non-empty list)"
192+ in prop name
193+ $ forAll listsWithoutSep1
194+ $ \xss -> do
195+ withMaxSuccess maxTestCount
196+ $ monadicIO
197+ $ do
198+ let xs = intercalater [sep] xss
199+ ys <- splitter xs [sep]
200+ listEquals (==) ys xss
201+
109groupSplitOps :: String -> Spec
202groupSplitOps :: String -> Spec
110groupSplitOps desc = do
203groupSplitOps desc = do
111 -- splitting
204 -- splitting
112 splitOnSeq
205 splitOnSeq
113 splitOnSuffixSeq
206 splitOnSuffixSeq
114− -- XXX add tests with multichar separators too
115
207
116− let split xs ys =
208+ -- seq splitting
117− S.toList $ IS.splitOnSeq (A.fromList ys) FL.toList (S.fromList xs)
209+ seqSplitterProperties (0 :: Int) desc
118− prop (desc <> " intercalate . splitOnSeq == id (nil separator)") $
210+ -- XXX This will fail
119− forAll listWithZeroes $ \xs -> do
211+ -- seqSplitterProperties (0 :: Word8) desc
120− withMaxSuccess maxTestCount $
121− monadicIO $ do
122− ys <- split xs []
123− listEquals (==) (intercalate [] ys) xs
124−
125− prop (desc <> " intercalate . splitOnSeq == id (single element separator)") $
126− forAll listWithZeroes $ \xs -> do
127− withMaxSuccess maxTestCount $
128− monadicIO $ do
129− ys <- split xs [0]
130− listEquals (==) (intercalate [0] ys) xs
131−
132− prop (desc <> " concat . splitOnSeq . intercalate == concat "
133− <> "(nil separator/possibly empty list)") $
134− forAll listsWithoutZeroes $ \xss -> do
135− withMaxSuccess maxTestCount $
136− monadicIO $ do
137− let xs = intercalate [] xss
138− ys <- split xs [0]
139− listEquals (==) (concat ys) (concat xss)
140−
141− prop (desc <> " concat . splitOnSeq . intercalate == "
142− <> "concat (non-nil separator/possibly empty list)") $
143− forAll listsWithoutZeroes $ \xss -> do
144− withMaxSuccess maxTestCount $
145− monadicIO $ do
146− let xs = intercalate [0] xss
147− ys <- split xs [0]
148− listEquals (==) (concat ys) (concat xss)
149−
150− prop (desc <> " splitOnSeq . intercalate == id "
151− <> "(exclusive separator/non-empty list)") $
152− forAll listsWithoutZeroes1 $ \xss -> do
153− withMaxSuccess maxTestCount $
154− monadicIO $ do
155− let xs = intercalate [0] xss
156− ys <- split xs [0]
157− listEquals (==) ys xss
158
212
159 prop (desc <> " intercalate [x] . splitOn (== x) == id") $
213 prop (desc <> " intercalate [x] . splitOn (== x) == id") $
160 forAll listWithZeroes $ \xs -> do
214 forAll listWithZeroes $ \xs -> do
@@ -168,14 +222,6 @@ groupSplitOps desc = do
168 listWithZeroes :: Gen [Int]
222 listWithZeroes :: Gen [Int]
169 listWithZeroes = listOf $ frequency [(3, arbitrary), (1, elements [0])]
223 listWithZeroes = listOf $ frequency [(3, arbitrary), (1, elements [0])]
170
224
171− listWithoutZeroes = vectorOf 4 $ suchThat arbitrary (/= 0)
172−
173− listsWithoutZeroes :: Gen [[Int]]
174− listsWithoutZeroes = listOf listWithoutZeroes
175−
176− listsWithoutZeroes1 :: Gen [[Int]]
177− listsWithoutZeroes1 = listOf1 listWithoutZeroes
178−
179-- |
225-- |
180-- After grouping (and folding) Int stream using @>@ operation,
226-- After grouping (and folding) Int stream using @>@ operation,
181-- the first @Int@ of every @[Int]@ in the @[Int]@ stream should be the minimum.
227-- the first @Int@ of every @[Int]@ in the @[Int]@ stream should be the minimum.