Adapt tests to new names and modules
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Fri, 5 Oct 2012 19:44:35 +0000 (19:44 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Fri, 5 Oct 2012 19:44:35 +0000 (19:44 +0000)
tests/Main.hs
tests/Tests/Bundle.hs [new file with mode: 0644]
tests/Tests/Stream.hs [deleted file]
tests/Tests/Vector.hs
tests/Utilities.hs

index 21980dd..52172ef 100644 (file)
@@ -1,12 +1,12 @@
 module Main (main) where
 
 import qualified Tests.Vector
 module Main (main) where
 
 import qualified Tests.Vector
-import qualified Tests.Stream
+import qualified Tests.Bundle
 import qualified Tests.Move
 
 import Test.Framework (defaultMain)
 
 import qualified Tests.Move
 
 import Test.Framework (defaultMain)
 
-main = defaultMain $ Tests.Stream.tests
+main = defaultMain $ Tests.Bundle.tests
                   ++ Tests.Vector.tests
                   ++ Tests.Move.tests
 
                   ++ Tests.Vector.tests
                   ++ Tests.Move.tests
 
diff --git a/tests/Tests/Bundle.hs b/tests/Tests/Bundle.hs
new file mode 100644 (file)
index 0000000..09368a1
--- /dev/null
@@ -0,0 +1,163 @@
+module Tests.Bundle ( tests ) where
+
+import Boilerplater
+import Utilities
+
+import qualified Data.Vector.Fusion.Bundle as S
+
+import Test.QuickCheck
+
+import Test.Framework
+import Test.Framework.Providers.QuickCheck2
+
+import Text.Show.Functions ()
+import Data.List           (foldl', foldl1', unfoldr, find, findIndex)
+import System.Random       (Random)
+
+#define COMMON_CONTEXT(a) \
+ VANILLA_CONTEXT(a)
+
+#define VANILLA_CONTEXT(a) \
+  Eq a,     Show a,     Arbitrary a,     CoArbitrary a,     TestData a,     Model a ~ a,        EqTest a ~ Property
+
+testSanity :: forall v a. (COMMON_CONTEXT(a)) => S.Bundle v a -> [Test]
+testSanity _ = [
+        testProperty "fromList.toList == id" prop_fromList_toList,
+        testProperty "toList.fromList == id" prop_toList_fromList
+    ]
+  where
+    prop_fromList_toList :: P (S.Bundle v a -> S.Bundle v a)
+        = (S.fromList . S.toList) `eq` id
+    prop_toList_fromList :: P ([a] -> [a])
+        = (S.toList . (S.fromList :: [a] -> S.Bundle v a)) `eq` id
+
+testPolymorphicFunctions :: forall v a. (COMMON_CONTEXT(a)) => S.Bundle v a -> [Test]
+testPolymorphicFunctions _ = $(testProperties [
+        'prop_eq,
+
+        'prop_length, 'prop_null,
+
+        'prop_empty, 'prop_singleton, 'prop_replicate,
+        'prop_cons, 'prop_snoc, 'prop_append,
+
+        'prop_head, 'prop_last, 'prop_index,
+
+        'prop_extract, 'prop_init, 'prop_tail, 'prop_take, 'prop_drop,
+
+        'prop_map, 'prop_zipWith, 'prop_zipWith3,
+        'prop_filter, 'prop_takeWhile, 'prop_dropWhile,
+
+        'prop_elem, 'prop_notElem,
+        'prop_find, 'prop_findIndex,
+
+        'prop_foldl, 'prop_foldl1, 'prop_foldl', 'prop_foldl1',
+        'prop_foldr, 'prop_foldr1,
+
+        'prop_prescanl, 'prop_prescanl',
+        'prop_postscanl, 'prop_postscanl',
+        'prop_scanl, 'prop_scanl', 'prop_scanl1, 'prop_scanl1',
+
+        'prop_concatMap,
+        'prop_unfoldr
+    ])
+  where
+    -- Prelude
+    prop_eq :: P (S.Bundle v a -> S.Bundle v a -> Bool) = (==) `eq` (==)
+
+    prop_length :: P (S.Bundle v a -> Int)     = S.length `eq` length
+    prop_null   :: P (S.Bundle v a -> Bool)    = S.null `eq` null
+    prop_empty  :: P (S.Bundle v a)            = S.empty `eq` []
+    prop_singleton :: P (a -> S.Bundle v a)    = S.singleton `eq` singleton
+    prop_replicate :: P (Int -> a -> S.Bundle v a)
+              = (\n _ -> n < 1000) ===> S.replicate `eq` replicate
+    prop_cons      :: P (a -> S.Bundle v a -> S.Bundle v a) = S.cons `eq` (:)
+    prop_snoc      :: P (S.Bundle v a -> a -> S.Bundle v a) = S.snoc `eq` snoc
+    prop_append    :: P (S.Bundle v a -> S.Bundle v a -> S.Bundle v a) = (S.++) `eq` (++)
+
+    prop_head      :: P (S.Bundle v a -> a) = not . S.null ===> S.head `eq` head
+    prop_last      :: P (S.Bundle v a -> a) = not . S.null ===> S.last `eq` last
+    prop_index        = \xs ->
+                        not (S.null xs) ==>
+                        forAll (choose (0, S.length xs-1)) $ \i ->
+                        unP prop xs i
+      where
+        prop :: P (S.Bundle v a -> Int -> a) = (S.!!) `eq` (!!)
+
+    prop_extract      = \xs ->
+                        forAll (choose (0, S.length xs))     $ \i ->
+                        forAll (choose (0, S.length xs - i)) $ \n ->
+                        unP prop i n xs
+      where
+        prop :: P (Int -> Int -> S.Bundle v a -> S.Bundle v a) = S.slice `eq` slice
+
+    prop_tail :: P (S.Bundle v a -> S.Bundle v a) = not . S.null ===> S.tail `eq` tail
+    prop_init :: P (S.Bundle v a -> S.Bundle v a) = not . S.null ===> S.init `eq` init
+    prop_take :: P (Int -> S.Bundle v a -> S.Bundle v a) = S.take `eq` take
+    prop_drop :: P (Int -> S.Bundle v a -> S.Bundle v a) = S.drop `eq` drop
+
+    prop_map :: P ((a -> a) -> S.Bundle v a -> S.Bundle v a) = S.map `eq` map
+    prop_zipWith :: P ((a -> a -> a) -> S.Bundle v a -> S.Bundle v a -> S.Bundle v a) = S.zipWith `eq` zipWith
+    prop_zipWith3 :: P ((a -> a -> a -> a) -> S.Bundle v a -> S.Bundle v a -> S.Bundle v a -> S.Bundle v a)
+             = S.zipWith3 `eq` zipWith3
+
+    prop_filter :: P ((a -> Bool) -> S.Bundle v a -> S.Bundle v a) = S.filter `eq` filter
+    prop_takeWhile :: P ((a -> Bool) -> S.Bundle v a -> S.Bundle v a) = S.takeWhile `eq` takeWhile
+    prop_dropWhile :: P ((a -> Bool) -> S.Bundle v a -> S.Bundle v a) = S.dropWhile `eq` dropWhile
+
+    prop_elem    :: P (a -> S.Bundle v a -> Bool) = S.elem `eq` elem
+    prop_notElem :: P (a -> S.Bundle v a -> Bool) = S.notElem `eq` notElem
+    prop_find    :: P ((a -> Bool) -> S.Bundle v a -> Maybe a) = S.find `eq` find
+    prop_findIndex :: P ((a -> Bool) -> S.Bundle v a -> Maybe Int)
+      = S.findIndex `eq` findIndex
+
+    prop_foldl :: P ((a -> a -> a) -> a -> S.Bundle v a -> a) = S.foldl `eq` foldl
+    prop_foldl1 :: P ((a -> a -> a) -> S.Bundle v a -> a)     = notNullS2 ===>
+                        S.foldl1 `eq` foldl1
+    prop_foldl' :: P ((a -> a -> a) -> a -> S.Bundle v a -> a) = S.foldl' `eq` foldl'
+    prop_foldl1' :: P ((a -> a -> a) -> S.Bundle v a -> a)     = notNullS2 ===>
+                        S.foldl1' `eq` foldl1'
+    prop_foldr :: P ((a -> a -> a) -> a -> S.Bundle v a -> a) = S.foldr `eq` foldr
+    prop_foldr1 :: P ((a -> a -> a) -> S.Bundle v a -> a)     = notNullS2 ===>
+                        S.foldr1 `eq` foldr1
+
+    prop_prescanl :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a)
+                = S.prescanl `eq` prescanl
+    prop_prescanl' :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a)
+                = S.prescanl' `eq` prescanl
+    prop_postscanl :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a)
+                = S.postscanl `eq` postscanl
+    prop_postscanl' :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a)
+                = S.postscanl' `eq` postscanl
+    prop_scanl :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a)
+                = S.scanl `eq` scanl
+    prop_scanl' :: P ((a -> a -> a) -> a -> S.Bundle v a -> S.Bundle v a)
+               = S.scanl' `eq` scanl
+    prop_scanl1 :: P ((a -> a -> a) -> S.Bundle v a -> S.Bundle v a) = notNullS2 ===>
+                 S.scanl1 `eq` scanl1
+    prop_scanl1' :: P ((a -> a -> a) -> S.Bundle v a -> S.Bundle v a) = notNullS2 ===>
+                 S.scanl1' `eq` scanl1
+    prop_concatMap    = forAll arbitrary $ \xs ->
+                        forAll (sized (\n -> resize (n `div` S.length xs) arbitrary)) $ \f -> unP prop f xs
+      where
+        prop :: P ((a -> S.Bundle v a) -> S.Bundle v a -> S.Bundle v a) = S.concatMap `eq` concatMap
+
+    limitUnfolds f (theirs, ours) | ours >= 0
+                                  , Just (out, theirs') <- f theirs = Just (out, (theirs', ours - 1))
+                                  | otherwise                       = Nothing
+    prop_unfoldr :: P (Int -> (Int -> Maybe (a,Int)) -> Int -> S.Bundle v a)
+         = (\n f a -> S.unfoldr (limitUnfolds f) (a, n))
+           `eq` (\n f a -> unfoldr (limitUnfolds f) (a, n))
+
+testBoolFunctions :: forall v. S.Bundle v Bool -> [Test]
+testBoolFunctions _ = $(testProperties ['prop_and, 'prop_or ])
+  where
+    prop_and :: P (S.Bundle v Bool -> Bool) = S.and `eq` and
+    prop_or  :: P (S.Bundle v Bool -> Bool) = S.or `eq` or
+
+testBundleFunctions = testSanity (undefined :: S.Bundle v Int)
+                      ++ testPolymorphicFunctions (undefined :: S.Bundle v Int)
+                      ++ testBoolFunctions (undefined :: S.Bundle v Bool)
+
+tests = [ testGroup "Data.Vector.Fusion.Bundle" testBundleFunctions ]
+
diff --git a/tests/Tests/Stream.hs b/tests/Tests/Stream.hs
deleted file mode 100644 (file)
index 34cf1c7..0000000
+++ /dev/null
@@ -1,163 +0,0 @@
-module Tests.Stream ( tests ) where
-
-import Boilerplater
-import Utilities
-
-import qualified Data.Vector.Fusion.Stream as S
-
-import Test.QuickCheck
-
-import Test.Framework
-import Test.Framework.Providers.QuickCheck2
-
-import Text.Show.Functions ()
-import Data.List           (foldl', foldl1', unfoldr, find, findIndex)
-import System.Random       (Random)
-
-#define COMMON_CONTEXT(a) \
- VANILLA_CONTEXT(a)
-
-#define VANILLA_CONTEXT(a) \
-  Eq a,     Show a,     Arbitrary a,     CoArbitrary a,     TestData a,     Model a ~ a,        EqTest a ~ Property
-
-testSanity :: forall a. (COMMON_CONTEXT(a)) => S.Stream a -> [Test]
-testSanity _ = [
-        testProperty "fromList.toList == id" prop_fromList_toList,
-        testProperty "toList.fromList == id" prop_toList_fromList
-    ]
-  where
-    prop_fromList_toList :: P (S.Stream a -> S.Stream a)
-        = (S.fromList . S.toList) `eq` id
-    prop_toList_fromList :: P ([a] -> [a])
-        = (S.toList . (S.fromList :: [a] -> S.Stream a)) `eq` id
-
-testPolymorphicFunctions :: forall a. (COMMON_CONTEXT(a)) => S.Stream a -> [Test]
-testPolymorphicFunctions _ = $(testProperties [
-        'prop_eq,
-
-        'prop_length, 'prop_null,
-
-        'prop_empty, 'prop_singleton, 'prop_replicate,
-        'prop_cons, 'prop_snoc, 'prop_append,
-
-        'prop_head, 'prop_last, 'prop_index,
-
-        'prop_extract, 'prop_init, 'prop_tail, 'prop_take, 'prop_drop,
-
-        'prop_map, 'prop_zipWith, 'prop_zipWith3,
-        'prop_filter, 'prop_takeWhile, 'prop_dropWhile,
-
-        'prop_elem, 'prop_notElem,
-        'prop_find, 'prop_findIndex,
-
-        'prop_foldl, 'prop_foldl1, 'prop_foldl', 'prop_foldl1',
-        'prop_foldr, 'prop_foldr1,
-
-        'prop_prescanl, 'prop_prescanl',
-        'prop_postscanl, 'prop_postscanl',
-        'prop_scanl, 'prop_scanl', 'prop_scanl1, 'prop_scanl1',
-
-        'prop_concatMap,
-        'prop_unfoldr
-    ])
-  where
-    -- Prelude
-    prop_eq :: P (S.Stream a -> S.Stream a -> Bool) = (==) `eq` (==)
-
-    prop_length :: P (S.Stream a -> Int)     = S.length `eq` length
-    prop_null   :: P (S.Stream a -> Bool)    = S.null `eq` null
-    prop_empty  :: P (S.Stream a)            = S.empty `eq` []
-    prop_singleton :: P (a -> S.Stream a)    = S.singleton `eq` singleton
-    prop_replicate :: P (Int -> a -> S.Stream a)
-              = (\n _ -> n < 1000) ===> S.replicate `eq` replicate
-    prop_cons      :: P (a -> S.Stream a -> S.Stream a) = S.cons `eq` (:)
-    prop_snoc      :: P (S.Stream a -> a -> S.Stream a) = S.snoc `eq` snoc
-    prop_append    :: P (S.Stream a -> S.Stream a -> S.Stream a) = (S.++) `eq` (++)
-
-    prop_head      :: P (S.Stream a -> a) = not . S.null ===> S.head `eq` head
-    prop_last      :: P (S.Stream a -> a) = not . S.null ===> S.last `eq` last
-    prop_index        = \xs ->
-                        not (S.null xs) ==>
-                        forAll (choose (0, S.length xs-1)) $ \i ->
-                        unP prop xs i
-      where
-        prop :: P (S.Stream a -> Int -> a) = (S.!!) `eq` (!!)
-
-    prop_extract      = \xs ->
-                        forAll (choose (0, S.length xs))     $ \i ->
-                        forAll (choose (0, S.length xs - i)) $ \n ->
-                        unP prop i n xs
-      where
-        prop :: P (Int -> Int -> S.Stream a -> S.Stream a) = S.slice `eq` slice
-
-    prop_tail :: P (S.Stream a -> S.Stream a) = not . S.null ===> S.tail `eq` tail
-    prop_init :: P (S.Stream a -> S.Stream a) = not . S.null ===> S.init `eq` init
-    prop_take :: P (Int -> S.Stream a -> S.Stream a) = S.take `eq` take
-    prop_drop :: P (Int -> S.Stream a -> S.Stream a) = S.drop `eq` drop
-
-    prop_map :: P ((a -> a) -> S.Stream a -> S.Stream a) = S.map `eq` map
-    prop_zipWith :: P ((a -> a -> a) -> S.Stream a -> S.Stream a -> S.Stream a) = S.zipWith `eq` zipWith
-    prop_zipWith3 :: P ((a -> a -> a -> a) -> S.Stream a -> S.Stream a -> S.Stream a -> S.Stream a)
-             = S.zipWith3 `eq` zipWith3
-
-    prop_filter :: P ((a -> Bool) -> S.Stream a -> S.Stream a) = S.filter `eq` filter
-    prop_takeWhile :: P ((a -> Bool) -> S.Stream a -> S.Stream a) = S.takeWhile `eq` takeWhile
-    prop_dropWhile :: P ((a -> Bool) -> S.Stream a -> S.Stream a) = S.dropWhile `eq` dropWhile
-
-    prop_elem    :: P (a -> S.Stream a -> Bool) = S.elem `eq` elem
-    prop_notElem :: P (a -> S.Stream a -> Bool) = S.notElem `eq` notElem
-    prop_find    :: P ((a -> Bool) -> S.Stream a -> Maybe a) = S.find `eq` find
-    prop_findIndex :: P ((a -> Bool) -> S.Stream a -> Maybe Int)
-      = S.findIndex `eq` findIndex
-
-    prop_foldl :: P ((a -> a -> a) -> a -> S.Stream a -> a) = S.foldl `eq` foldl
-    prop_foldl1 :: P ((a -> a -> a) -> S.Stream a -> a)     = notNullS2 ===>
-                        S.foldl1 `eq` foldl1
-    prop_foldl' :: P ((a -> a -> a) -> a -> S.Stream a -> a) = S.foldl' `eq` foldl'
-    prop_foldl1' :: P ((a -> a -> a) -> S.Stream a -> a)     = notNullS2 ===>
-                        S.foldl1' `eq` foldl1'
-    prop_foldr :: P ((a -> a -> a) -> a -> S.Stream a -> a) = S.foldr `eq` foldr
-    prop_foldr1 :: P ((a -> a -> a) -> S.Stream a -> a)     = notNullS2 ===>
-                        S.foldr1 `eq` foldr1
-
-    prop_prescanl :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a)
-                = S.prescanl `eq` prescanl
-    prop_prescanl' :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a)
-                = S.prescanl' `eq` prescanl
-    prop_postscanl :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a)
-                = S.postscanl `eq` postscanl
-    prop_postscanl' :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a)
-                = S.postscanl' `eq` postscanl
-    prop_scanl :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a)
-                = S.scanl `eq` scanl
-    prop_scanl' :: P ((a -> a -> a) -> a -> S.Stream a -> S.Stream a)
-               = S.scanl' `eq` scanl
-    prop_scanl1 :: P ((a -> a -> a) -> S.Stream a -> S.Stream a) = notNullS2 ===>
-                 S.scanl1 `eq` scanl1
-    prop_scanl1' :: P ((a -> a -> a) -> S.Stream a -> S.Stream a) = notNullS2 ===>
-                 S.scanl1' `eq` scanl1
-    prop_concatMap    = forAll arbitrary $ \xs ->
-                        forAll (sized (\n -> resize (n `div` S.length xs) arbitrary)) $ \f -> unP prop f xs
-      where
-        prop :: P ((a -> S.Stream a) -> S.Stream a -> S.Stream a) = S.concatMap `eq` concatMap
-
-    limitUnfolds f (theirs, ours) | ours >= 0
-                                  , Just (out, theirs') <- f theirs = Just (out, (theirs', ours - 1))
-                                  | otherwise                       = Nothing
-    prop_unfoldr :: P (Int -> (Int -> Maybe (a,Int)) -> Int -> S.Stream a)
-         = (\n f a -> S.unfoldr (limitUnfolds f) (a, n))
-           `eq` (\n f a -> unfoldr (limitUnfolds f) (a, n))
-
-testBoolFunctions :: [Test]
-testBoolFunctions = $(testProperties ['prop_and, 'prop_or])
-  where
-    prop_and :: P (S.Stream Bool -> Bool) = S.and `eq` and
-    prop_or  :: P (S.Stream Bool -> Bool) = S.or `eq` or
-
-testStreamFunctions = testSanity (undefined :: S.Stream Int)
-                      ++ testPolymorphicFunctions (undefined :: S.Stream Int)
-                      ++ testBoolFunctions
-
-tests = [ testGroup "Data.Vector.Fusion.Stream" testStreamFunctions ]
-
index 7d8b850..af1e398 100644 (file)
@@ -8,7 +8,7 @@ import qualified Data.Vector
 import qualified Data.Vector.Primitive
 import qualified Data.Vector.Storable
 import qualified Data.Vector.Unboxed
 import qualified Data.Vector.Primitive
 import qualified Data.Vector.Storable
 import qualified Data.Vector.Unboxed
-import qualified Data.Vector.Fusion.Stream as S
+import qualified Data.Vector.Fusion.Bundle as S
 
 import Test.QuickCheck
 
 
 import Test.QuickCheck
 
@@ -74,7 +74,7 @@ testSanity _ = [
     prop_fromList_toList (v :: v a)        = (V.fromList . V.toList)                        v == v
     prop_toList_fromList (l :: [a])        = ((V.toList :: v a -> [a]) . V.fromList)        l == l
     prop_unstream_stream (v :: v a)        = (V.unstream . V.stream)                        v == v
     prop_fromList_toList (v :: v a)        = (V.fromList . V.toList)                        v == v
     prop_toList_fromList (l :: [a])        = ((V.toList :: v a -> [a]) . V.fromList)        l == l
     prop_unstream_stream (v :: v a)        = (V.unstream . V.stream)                        v == v
-    prop_stream_unstream (s :: S.Stream a) = ((V.stream :: v a -> S.Stream a) . V.unstream) s == s
+    prop_stream_unstream (s :: S.Bundle v a) = ((V.stream :: v a -> S.Bundle v a) . V.unstream) s == s
 
 testPolymorphicFunctions :: forall a v. (COMMON_CONTEXT(a, v), VECTOR_CONTEXT(Int, v)) => v a -> [Test]
 testPolymorphicFunctions _ = $(testProperties [
 
 testPolymorphicFunctions :: forall a v. (COMMON_CONTEXT(a, v), VECTOR_CONTEXT(Int, v)) => v a -> [Test]
 testPolymorphicFunctions _ = $(testProperties [
index 927e9bd..e0129f2 100644 (file)
@@ -8,13 +8,13 @@ import qualified Data.Vector.Generic as DVG
 import qualified Data.Vector.Primitive as DVP
 import qualified Data.Vector.Storable as DVS
 import qualified Data.Vector.Unboxed as DVU
 import qualified Data.Vector.Primitive as DVP
 import qualified Data.Vector.Storable as DVS
 import qualified Data.Vector.Unboxed as DVU
-import qualified Data.Vector.Fusion.Stream as S
+import qualified Data.Vector.Fusion.Bundle as S
 
 import Data.List ( sortBy )
 
 
 
 import Data.List ( sortBy )
 
 
-instance Show a => Show (S.Stream a) where
-    show s = "Data.Vector.Fusion.Stream.fromList " ++ show (S.toList s)
+instance Show a => Show (S.Bundle v a) where
+    show s = "Data.Vector.Fusion.Bundle.fromList " ++ show (S.toList s)
 
 
 instance Arbitrary a => Arbitrary (DV.Vector a) where
 
 
 instance Arbitrary a => Arbitrary (DV.Vector a) where
@@ -41,10 +41,10 @@ instance (Arbitrary a, DVU.Unbox a) => Arbitrary (DVU.Vector a) where
 instance (CoArbitrary a, DVU.Unbox a) => CoArbitrary (DVU.Vector a) where
     coarbitrary = coarbitrary . DVU.toList
 
 instance (CoArbitrary a, DVU.Unbox a) => CoArbitrary (DVU.Vector a) where
     coarbitrary = coarbitrary . DVU.toList
 
-instance Arbitrary a => Arbitrary (S.Stream a) where
+instance Arbitrary a => Arbitrary (S.Bundle v a) where
     arbitrary = fmap S.fromList arbitrary
 
     arbitrary = fmap S.fromList arbitrary
 
-instance CoArbitrary a => CoArbitrary (S.Stream a) where
+instance CoArbitrary a => CoArbitrary (S.Bundle v a) where
     coarbitrary = coarbitrary . S.toList
 
 class (Testable (EqTest a), Conclusion (EqTest a)) => TestData a where
     coarbitrary = coarbitrary . S.toList
 
 class (Testable (EqTest a), Conclusion (EqTest a)) => TestData a where
@@ -55,12 +55,12 @@ class (Testable (EqTest a), Conclusion (EqTest a)) => TestData a where
   type EqTest a
   equal :: a -> a -> EqTest a
 
   type EqTest a
   equal :: a -> a -> EqTest a
 
-instance Eq a => TestData (S.Stream a) where
-  type Model (S.Stream a) = [a]
+instance Eq a => TestData (S.Bundle v a) where
+  type Model (S.Bundle v a) = [a]
   model = S.toList
   unmodel = S.fromList
 
   model = S.toList
   unmodel = S.fromList
 
-  type EqTest (S.Stream a) = Property
+  type EqTest (S.Bundle v a) = Property
   equal x y = property (x == y)
 
 instance Eq a => TestData (DV.Vector a) where
   equal x y = property (x == y)
 
 instance Eq a => TestData (DV.Vector a) where