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
-import qualified Tests.Stream
+import qualified Tests.Bundle
 import qualified Tests.Move
 
 import Test.Framework (defaultMain)
 
-main = defaultMain $ Tests.Stream.tests
+main = defaultMain $ Tests.Bundle.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.Fusion.Stream as S
+import qualified Data.Vector.Fusion.Bundle as S
 
 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_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 [
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.Fusion.Stream as S
+import qualified Data.Vector.Fusion.Bundle as S
 
 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
@@ -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 Arbitrary a => Arbitrary (S.Stream a) where
+instance Arbitrary a => Arbitrary (S.Bundle v a) where
     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
@@ -55,12 +55,12 @@ class (Testable (EqTest a), Conclusion (EqTest a)) => TestData a where
   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
 
-  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