QuickCheck 2.8.1 → 2.8.2

raw patch · 9 files changed

+105/−33 lines, 9 filesdep ~QuickCheckdep ~template-haskellPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: QuickCheck, template-haskell

API changes (from Hackage documentation)

Files

• QuickCheck.cabal +5/−3
• Test/QuickCheck/All.hs +19/−7
• Test/QuickCheck/Arbitrary.hs +46/−8
• Test/QuickCheck/Function.hs +1/−1
• Test/QuickCheck/Gen.hs +4/−6
• Test/QuickCheck/Modifiers.hs +1/−1
• Test/QuickCheck/Test.hs +14/−5
• Test/QuickCheck/Text.hs +5/−2
• changelog +10/−0

@@ -1,5 +1,5 @@ Name: QuickCheck-Version: 2.8.1+Version: 2.8.2 Cabal-Version: >= 1.8 Build-type: Simple License: BSD3@@ -37,7 +37,7 @@ source-repository this   type:     git   location: https://github.com/nick8325/quickcheck-  tag:      2.8.1+  tag:      2.8.2  flag base3   Description: Choose the new smaller, split-up base package.@@ -50,6 +50,7 @@  flag templateHaskell   Description: Build Test.QuickCheck.All, which uses Template Haskell.+  Default: True  library   -- Choose which library versions to use.@@ -92,6 +93,7 @@     cpp-options: -DNO_TRANSFORMERS   if impl(ghc >= 6.12) && flag(templateHaskell)     Build-depends: template-haskell >= 2.4+    Other-Extensions: TemplateHaskell     Exposed-Modules: Test.QuickCheck.All   else     cpp-options: -DNO_TEMPLATE_HASKELL@@ -158,7 +160,7 @@     build-depends:       base,       containers,-      QuickCheck == 2.8.1,+      QuickCheck == 2.8.2,       template-haskell >= 2.4,       test-framework >= 0.4 && < 0.9     if flag(templateHaskell)

@@ -2,6 +2,7 @@ #ifndef NO_SAFE_HASKELL {-# LANGUAGE Trustworthy #-} #endif+ -- | Test all properties in the current module, using Template Haskell. -- You need to have a @{-\# LANGUAGE TemplateHaskell \#-}@ pragma in -- your module for any of these to work.@@ -66,28 +67,39 @@   let err msg = error $ msg ++ ": " ++ pprint ty0   (polys, ctx, ty) <- deconstructType err ty0   case polys of-    [] -> return (VarE t)+    [] -> return (expName t)     _ -> do       integer <- [t| Integer |]       ty' <- monomorphiseType err integer ty-      return (SigE (VarE t) ty')+      return (SigE (expName t) ty') +expName :: Name -> Exp+expName n = if isVar n then VarE n else ConE n++-- See section 2.4 of the Haskell 2010 Language Report, plus support for "[]"+isVar :: Name -> Bool+isVar = let isVar' (c:_) = not (isUpper c || c `elem` ":[")+            isVar' _     = True+        in isVar' . nameBase+ infoType :: Info -> Type+#if __GLASGOW_HASKELL__ >= 711+infoType (ClassOpI _ ty _) = ty+infoType (DataConI _ ty _) = ty+infoType (VarI _ ty _) = ty+#else infoType (ClassOpI _ ty _ _) = ty infoType (DataConI _ ty _ _) = ty infoType (VarI _ ty _ _) = ty+#endif  deconstructType :: Error -> Type -> Q ([Name], Cxt, Type) deconstructType err ty0@(ForallT xs ctx ty) = do   let plain (PlainTV  _)       = True-#ifndef MIN_VERSION_template_haskell-      plain (KindedTV _ StarT) = True-#else-#if MIN_VERSION_template_haskell(2,8,0)+#if __GLASGOW_HASKELL__ >= 706       plain (KindedTV _ StarT) = True #else       plain (KindedTV _ StarK) = True-#endif #endif       plain _                  = False   unless (all plain xs) $ err "Higher-kinded type variables in type"

@@ -3,8 +3,11 @@ #ifndef NO_GENERICS {-# LANGUAGE DefaultSignatures, FlexibleContexts, TypeOperators #-} {-# LANGUAGE FlexibleInstances, KindSignatures, ScopedTypeVariables #-}-{-# LANGUAGE MultiParamTypeClasses, OverlappingInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-}+#if __GLASGOW_HASKELL__ < 710+{-# LANGUAGE OverlappingInstances  #-} #endif+#endif #ifndef NO_SAFE_HASKELL {-# LANGUAGE Safe #-} #endif@@ -52,6 +55,7 @@ -- imports  import Control.Applicative+import Data.Foldable(toList) import System.Random(Random) import Test.QuickCheck.Gen import Test.QuickCheck.Gen.Unsafe@@ -115,6 +119,12 @@ import GHC.Generics #endif +import qualified Data.Set as Set+import qualified Data.Map as Map+import qualified Data.IntSet as IntSet+import qualified Data.IntMap as IntMap+import qualified Data.Sequence as Sequence+ -------------------------------------------------------------------------- -- ** class Arbitrary @@ -122,7 +132,6 @@ class Arbitrary a where   -- | A generator for values of the given type.   arbitrary :: Gen a-  arbitrary = error "no default generator"    -- | Produces a (possibly) empty list of all the possible   -- immediate shrinks of the given value. The default implementation@@ -195,7 +204,7 @@ #ifndef NO_GENERICS -- | Shrink a term to any of its immediate subterms, -- and also recursively shrink all subterms.-genericShrink :: (Generic a, Arbitrary a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) => a -> [a]+genericShrink :: (Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) => a -> [a] genericShrink x = subterms x ++ recursivelyShrink x  -- | Recursively shrink all immediate subterms.@@ -229,7 +238,7 @@   -- | All immediate subterms of a term.-subterms :: (Generic a, Arbitrary a, GSubterms (Rep a) a) => a -> [a]+subterms :: (Generic a, GSubterms (Rep a) a) => a -> [a] subterms = gSubterms . from  @@ -292,10 +301,10 @@   gSubtermsIncl (M1 x) = gSubtermsIncl x  -- This is the important case: We've found a term of the same type.-instance Arbitrary a => GSubtermsIncl (K1 i a) a where+instance {-# OVERLAPPING #-} GSubtermsIncl (K1 i a) a where   gSubtermsIncl (K1 x) = [x] -instance GSubtermsIncl (K1 i a) b where+instance {-# OVERLAPPING #-} GSubtermsIncl (K1 i a) b where   gSubtermsIncl (K1 _) = []  #endif@@ -365,7 +374,7 @@                ++ [ x':xs | x'  <- shrink x ] -} -instance (Integral a, Arbitrary a) => Arbitrary (Ratio a) where+instance Integral a => Arbitrary (Ratio a) where   arbitrary = arbitrarySizedFractional   shrink    = shrinkRealFracToInteger @@ -494,6 +503,23 @@   arbitrary = arbitrarySizedFractional   shrink    = shrinkRealFrac +-- Arbitrary instances for container types+instance (Ord a, Arbitrary a) => Arbitrary (Set.Set a) where+  arbitrary = fmap Set.fromList arbitrary+  shrink = map Set.fromList . shrink . Set.toList+instance (Ord k, Arbitrary k, Arbitrary v) => Arbitrary (Map.Map k v) where+  arbitrary = fmap Map.fromList arbitrary+  shrink = map Map.fromList . shrink . Map.toList+instance Arbitrary IntSet.IntSet where+  arbitrary = fmap IntSet.fromList arbitrary+  shrink = map IntSet.fromList . shrink . IntSet.toList+instance Arbitrary a => Arbitrary (IntMap.IntMap a) where+  arbitrary = fmap IntMap.fromList arbitrary+  shrink = map IntMap.fromList . shrink . IntMap.toList+instance Arbitrary a => Arbitrary (Sequence.Seq a) where+  arbitrary = fmap Sequence.fromList arbitrary+  shrink = map Sequence.fromList . shrink . toList+ -- ** Helper functions for implementing arbitrary  -- | Generates an integral number. The number can be positive or negative@@ -799,6 +825,18 @@ instance CoArbitrary Double where   coarbitrary = coarbitraryReal +-- Coarbitrary instances for container types+instance CoArbitrary a => CoArbitrary (Set.Set a) where+  coarbitrary = coarbitrary. Set.toList+instance (CoArbitrary k, CoArbitrary v) => CoArbitrary (Map.Map k v) where+  coarbitrary = coarbitrary . Map.toList+instance CoArbitrary IntSet.IntSet where+  coarbitrary = coarbitrary . IntSet.toList+instance CoArbitrary a => CoArbitrary (IntMap.IntMap a) where+  coarbitrary = coarbitrary . IntMap.toList+instance CoArbitrary a => CoArbitrary (Sequence.Seq a) where+  coarbitrary = coarbitrary . toList+ -- ** Helpers for implementing coarbitrary  -- | A 'coarbitrary' implementation for integral numbers.@@ -826,7 +864,7 @@ vector :: Arbitrary a => Int -> Gen [a] vector k = vectorOf k arbitrary --- | Generates an ordered list of a given length.+-- | Generates an ordered list. orderedList :: (Ord a, Arbitrary a) => Gen [a] orderedList = sort `fmap` arbitrary 

@@ -279,7 +279,7 @@ -- -- > prop :: Fun String Integer -> Bool -- > prop (Fn f) = f "banana" == f "monkey"---              || f "banana" == f "elephant"+-- >            || f "banana" == f "elephant" pattern Fn f <- Fun _ f #endif 

@@ -33,6 +33,8 @@   )  import Test.QuickCheck.Random+import Data.List+import Data.Ord  -------------------------------------------------------------------------- -- ** Generator type@@ -155,13 +157,9 @@  -- | Generates a random permutation of the given list. shuffle :: [a] -> Gen [a]-shuffle [] = return [] shuffle xs = do-  (y, ys) <- elements (selectOne xs)-  (y:) <$> shuffle ys-  where-    selectOne [] = []-    selectOne (y:ys) = (y,ys) : map (second (y:)) (selectOne ys)+  ns <- vectorOf (length xs) (choose (minBound :: Int, maxBound))+  return (map snd (sortBy (comparing fst) (zip ns xs)))  -- | Takes a list of elements of increasing size, and chooses -- among an initial segment of the list. The size of this initial

@@ -175,7 +175,7 @@ instance Functor NonZero where   fmap f (NonZero x) = NonZero (f x) -instance (Num a, Ord a, Arbitrary a) => Arbitrary (NonZero a) where+instance (Num a, Eq a, Arbitrary a) => Arbitrary (NonZero a) where   arbitrary = fmap NonZero $ arbitrary `suchThat` (/= 0)    shrink (NonZero x) = [ NonZero x' | x' <- shrink x, x' /= 0 ]

@@ -38,11 +38,20 @@ -- | Args specifies arguments to the QuickCheck driver data Args   = Args-  { replay          :: Maybe (QCGen,Int) -- ^ Should we replay a previous test?-  , maxSuccess      :: Int               -- ^ Maximum number of successful tests before succeeding-  , maxDiscardRatio :: Int               -- ^ Maximum number of discarded tests per successful test before giving up-  , maxSize         :: Int               -- ^ Size to use for the biggest test cases-  , chatty          :: Bool              -- ^ Whether to print anything+  { replay          :: Maybe (QCGen,Int)+    -- ^ Should we replay a previous test?+    -- Note: saving a seed from one version of QuickCheck and+    -- replaying it in another is not supported.+    -- If you want to store a test case permanently you should save+    -- the test case itself.+  , maxSuccess      :: Int+    -- ^ Maximum number of successful tests before succeeding+  , maxDiscardRatio :: Int+    -- ^ Maximum number of discarded tests per successful test before giving up+  , maxSize         :: Int+    -- ^ Size to use for the biggest test cases+  , chatty          :: Bool+    -- ^ Whether to print anything   }  deriving ( Show, Read ) 

@@ -35,6 +35,7 @@   , BufferMode (..)   , hGetBuffering   , hSetBuffering+  , hIsTerminalDevice   )  import Data.IORef@@ -102,8 +103,10 @@   action `finally` hSetBuffering stderr mode  withStdioTerminal :: (Terminal -> IO a) -> IO a-withStdioTerminal action =-  withBuffering (newTerminal (handle stdout) (handle stderr) >>= action)+withStdioTerminal action = do+  isatty <- hIsTerminalDevice stderr+  let err = if isatty then handle stderr else const (return ())+  withBuffering (newTerminal (handle stdout) err >>= action)  withNullTerminal :: (Terminal -> IO a) -> IO a withNullTerminal action =

@@ -1,3 +1,13 @@+QuickCheck 2.8.2 (released 2016-01-15)+	* GHC 8 support+	* Add Arbitrary and CoArbitrary instances for types in+	  containers package+	* Improve speed of shuffle combinator+	* Only print to stderr if it's a terminal.+	* Small changes: slightly improve documentation,+	  remove redundant constraints from some functions' types,+	  small improvements to Test.QuickCheck.All.+ QuickCheck 2.8.1 (released 2015-04-03) 	* Fix bug where exceptions thrown printing counterexamples weren't 	  being caught when terminal output was disabled