New patches: [fmt cabal gwern0@gmail.com**20080407045028] < > { hunk ./QuickCheck.cabal 1 -Name: QuickCheck -Version: 2.0 -Cabal-Version: >= 1.2 -Build-type: Simple -License: BSD4 +Name: QuickCheck +Version: 2.0 +License: BSD4 License-file: LICENSE hunk ./QuickCheck.cabal 5 -Copyright: Koen Claessen -Author: Koen Claessen -Maintainer: Koen Claessen +Copyright: Koen Claessen +Author: Koen Claessen +Maintainer: Koen Claessen + +Synopsis: QuickCheck is a library for random testing of program properties. Homepage: http://www.haskell.org/QuickCheck/ hunk ./QuickCheck.cabal 11 -Description: - QuickCheck is a library for random testing of program properties. + +Cabal-Version: >= 1.2 +Build-type: Simple +Tested-With: GHC==6.8.2 flag splitBase Description: Choose the new smaller, split-up base package. } [.cabal: +category gwern0@gmail.com**20080407045049] < > { hunk ./QuickCheck.cabal 9 Author: Koen Claessen Maintainer: Koen Claessen +Category: Testing Synopsis: QuickCheck is a library for random testing of program properties. Homepage: http://www.haskell.org/QuickCheck/ } [.cabal: change homepage and links gwern0@gmail.com**20080407045300 The original listed website, , seems to be quite dead. I've replaced it with a link to the haskell wiki and to the old chalmers site. ] < > { hunk ./QuickCheck.cabal 11 Category: Testing Synopsis: QuickCheck is a library for random testing of program properties. -Homepage: http://www.haskell.org/QuickCheck/ + . + For more information, see the homepage or the Haskell wiki: + . +Homepage: http://www.cs.chalmers.se/~rjmh/QuickCheck/ Cabal-Version: >= 1.2 Build-type: Simple } [improve README gwern0@gmail.com**20080407045749] < > { hunk ./README 5 === Installation === -Installation is done with Cabal: +Installation is done with Cabal as usual, either automatically +through cabal-install: hunk ./README 8 -$ runghc Setup.lhs configure -$ runghc Setup.lhs build -$ runghc Setup.lhs install +$ cabal install QuickCheck + +or manually in an uncompressed tarball: + +$ runhaskell Setup configure +$ runhaskell Setup build +$ runhaskell Setup install === Documentation === hunk ./README 19 -$ runghc Setup.lhs haddock +$ runhaskell Setup haddock generates API documentation in dist/doc/html/index.html } [.cabal: add a real description gwern0@gmail.com**20080407045904] < > { hunk ./QuickCheck.cabal 9 Author: Koen Claessen Maintainer: Koen Claessen -Category: Testing -Synopsis: QuickCheck is a library for random testing of program properties. - . - For more information, see the homepage or the Haskell wiki: - . +Category: Testing +Synopsis: QuickCheck is a library for random testing of program properties; +Description: QuickCheck can test Haskell programs automatically. The programmer + provides specifications of the program, in the form of logical + properties which functions should satisfy, and QuickCheck then tests + that the properties hold in a large number of randomly generated cases. + Specifications are expressed in Haskell, using combinators defined + in the QuickCheck library. QuickCheck provides combinators to define + properties, observe the distribution of test data, and define + test data generators. + . + Note that this is version 2 of QuickCheck, which may differ from + QuickCheck 1.x in a number of ways. + . + For more information, see the homepage or the Haskell wiki: + . Homepage: http://www.cs.chalmers.se/~rjmh/QuickCheck/ Cabal-Version: >= 1.2 } [.cabal: BSD4 -> BSD3 license change gwern0@gmail.com**20080407050018 The 4-clause BSD includes the advertising clause, and is 4 clauses long. The provided LICENSE file doesn't seem to have an advertising clause for anyone, and seems to have only 3 clauses. Which is good, as people don't like the advertising BSD license - why it's deprecated. ] < > { hunk ./QuickCheck.cabal 3 Name: QuickCheck Version: 2.0 -License: BSD4 +License: BSD3 License-file: LICENSE Copyright: Koen Claessen Author: Koen Claessen } [.cabal: +Bringert to copyright gwern0@gmail.com**20080407050146 Per the license file, which mentions two copyright holders. ] < > { hunk ./QuickCheck.cabal 5 Version: 2.0 License: BSD3 License-file: LICENSE -Copyright: Koen Claessen +Copyright: Koen Claessen, Bjorn Bringert Author: Koen Claessen Maintainer: Koen Claessen } [-Wall Monadic.hs gwern0@gmail.com**20080407050534] < > { hunk ./Test/QuickCheck/Monadic.hs 9 -------------------------------------------------------------------------- -- imports +import Control.Monad (liftM) +import System.IO.Unsafe (unsafePerformIO) import Test.QuickCheck.Gen import Test.QuickCheck.Property hunk ./Test/QuickCheck/Monadic.hs 13 -import Test.QuickCheck.Arbitrary - -import Control.Monad - ( liftM - ) - -import Control.Monad.ST - -import System.IO.Unsafe - ( unsafePerformIO - ) -- instance of monad transformer? hunk ./Test/QuickCheck/Monadic.hs 28 instance Monad m => Monad (PropertyM m) where return x = MkPropertyM (\k -> k x) MkPropertyM m >>= f = MkPropertyM (\k -> m (\a -> unPropertyM (f a) k)) - fail s = MkPropertyM (\k -> return (return (property result))) + fail s = MkPropertyM (\_ -> return $ return $ property failedResult) where hunk ./Test/QuickCheck/Monadic.hs 30 - result = failed{ reason = s } + failedResult = failed{ reason = s } -- should think about strictness/exceptions here --assert :: Testable prop => prop -> PropertyM m () hunk ./Test/QuickCheck/Monadic.hs 46 case ok r of Just True -> do m <- k () return (do p' <- m - return (r &&& p')) + return (r &&& p')) _ -> return (return (property r)) -} hunk ./Test/QuickCheck/Monadic.hs 80 -- run functions monadic :: Monad m => (m Property -> Property) -> PropertyM m a -> Property -monadic run (MkPropertyM m) = - do mp <- m (const (return (return (property True)))) - run mp +monadic runf (MkPropertyM m) = + do mp <- m $ const $ return $ return $ property True + runf mp {- monadicIO :: Monad m => (m Property -> IO Property) -> PropertyM m a -> IO Property hunk ./Test/QuickCheck/Monadic.hs 119 {- monadicS :: MonadS m => ((forall s . m s Property) -> Property) -> (forall s . PropertyM (m s) a) -> Property monadicS run mp = MkGen $ \r n -> - let MkGen g' = run (let MkPropertyM f = mp' + let MkGen g' = run (let MkPropertyM f = mp' MkGen g = f (const (return (return (property True)))) in unIdM (g r n)) in g' undefined undefined } [some misc partial -Wall gwern0@gmail.com**20080407154644] < > { hunk ./Test/QuickCheck/Arbitrary.hs 3 {-# OPTIONS -fglasgow-exts #-} module Test.QuickCheck.Arbitrary - ( + ( -- * Arbitrary and CoArbitrary classes. Arbitrary(..) , CoArbitrary(..) hunk ./Test/QuickCheck/Arbitrary.hs 7 - + -- ** Helper functions for implementing arbitrary , arbitrarySizedIntegral -- :: Num a => Gen a , arbitrarySizedFractional -- :: Fractional a => Gen a hunk ./Test/QuickCheck/Arbitrary.hs 21 , (><) , coarbitraryIntegral -- :: Integral a => a -> Gen b -> Gen b , coarbitraryReal -- :: Real a => a -> Gen b -> Gen b - + -- ** Generators which use arbitrary , vector -- :: Arbitrary a => Int -> Gen [a] , orderedList -- :: (Ord a, Arbitrary a) => Gen [a] hunk ./Test/QuickCheck/Arbitrary.hs 91 -- | 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. shrink :: a -> [a] hunk ./Test/QuickCheck/Arbitrary.hs 110 instance Arbitrary a => Arbitrary (Maybe a) where arbitrary = frequency [(1, return Nothing), (3, liftM Just arbitrary)] - + shrink (Just x) = Nothing : [ Just x' | x' <- shrink x ] shrink _ = [] hunk ./Test/QuickCheck/Arbitrary.hs 116 instance (Arbitrary a, Arbitrary b) => Arbitrary (Either a b) where arbitrary = oneof [liftM Left arbitrary, liftM Right arbitrary] - + shrink (Left x) = [ Left x' | x' <- shrink x ] shrink (Right y) = [ Right y' | y' <- shrink y ] hunk ./Test/QuickCheck/Arbitrary.hs 119 - + instance Arbitrary a => Arbitrary [a] where arbitrary = sized $ \n -> do k <- choose (0,n) hunk ./Test/QuickCheck/Arbitrary.hs 142 xs1 = take n1 xs n2 = n - n1 xs2 = drop n1 xs - + [] `ilv` ys = ys xs `ilv` [] = xs (x:xs) `ilv` (y:ys) = x : y : (xs `ilv` ys) hunk ./Test/QuickCheck/Arbitrary.hs 146 - + shrinkOne [] = [] shrinkOne (x:xs) = [ x':xs | x' <- shrink x ] hunk ./Test/QuickCheck/Arbitrary.hs 149 - ++ [ x:xs' | xs' <- shrinkOne xs ] + ++ [ x:xs' | xs' <- shrinkOne xs ] {- -- "standard" definition for lists: hunk ./Test/QuickCheck/Arbitrary.hs 167 => Arbitrary (a,b) where arbitrary = liftM2 (,) arbitrary arbitrary - + shrink (x,y) = [ (x',y) | x' <- shrink x ] ++ [ (x,y') | y' <- shrink y ] hunk ./Test/QuickCheck/Arbitrary.hs 170 - + instance (Arbitrary a, Arbitrary b, Arbitrary c) => Arbitrary (a,b,c) where hunk ./Test/QuickCheck/Arbitrary.hs 175 arbitrary = liftM3 (,,) arbitrary arbitrary arbitrary - + shrink (x,y,z) = [ (x',y,z) | x' <- shrink x ] ++ [ (x,y',z) | y' <- shrink y ] ++ [ (x,y,z') | z' <- shrink z ] hunk ./Test/QuickCheck/Arbitrary.hs 179 - + instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => Arbitrary (a,b,c,d) where hunk ./Test/QuickCheck/Arbitrary.hs 184 arbitrary = liftM4 (,,,) arbitrary arbitrary arbitrary arbitrary - + shrink (w,x,y,z) = [ (w',x,y,z) | w' <- shrink w ] ++ [ (w,x',y,z) | x' <- shrink x ] ++ [ (w,x,y',z) | y' <- shrink y ] hunk ./Test/QuickCheck/Arbitrary.hs 189 ++ [ (w,x,y,z') | z' <- shrink z ] - + instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e) => Arbitrary (a,b,c,d,e) where hunk ./Test/QuickCheck/Arbitrary.hs 194 arbitrary = liftM5 (,,,,) arbitrary arbitrary arbitrary arbitrary arbitrary - + shrink (v,w,x,y,z) = [ (v',w,x,y,z) | v' <- shrink v ] ++ [ (v,w',x,y,z) | w' <- shrink w ] ++ [ (v,w,x',y,z) | x' <- shrink x ] hunk ./Test/QuickCheck/Arbitrary.hs 200 ++ [ (v,w,x,y',z) | y' <- shrink y ] ++ [ (v,w,x,y,z') | z' <- shrink z ] - + -- typical instance for primitive (numerical) types instance Arbitrary Integer where hunk ./Test/QuickCheck/Arbitrary.hs 261 -- ** Helper functions for implementing shrink --- | Returns no shrinking alternatives. +-- | Returns no shrinking alternatives. shrinkNothing :: a -> [a] shrinkNothing _ = [] hunk ./Test/QuickCheck/Arbitrary.hs 267 -- | Shrink an integral number. shrinkIntegral :: Integral a => a -> [a] -shrinkIntegral x = +shrinkIntegral x = nub $ [ -x | x < 0 hunk ./Test/QuickCheck/Arbitrary.hs 290 , x' << x ] where - x << y = abs x < abs y + a << b = abs a < abs b -------------------------------------------------------------------------- -- ** CoArbitrary hunk ./Test/QuickCheck/Arbitrary.hs 299 class CoArbitrary a where -- | Used to generate a function of type @a -> c@. The implementation -- should use the first argument to perturb the random generator - -- given as the second argument. the returned generator + -- given as the second argument. the returned generator -- is then used to generate the function result. hunk ./Test/QuickCheck/Arbitrary.hs 301 - -- You can often use 'variant' and '(><)' to implement + -- You can often use 'variant' and '(><)' to implement -- 'coarbitrary'. coarbitrary :: a -> Gen c -> Gen c hunk ./Test/QuickCheck/Arbitrary.hs 313 coarbitrary{| a :+: b |} (Inr y) = variant (-1) . coarbitrary y -} --- | Combine two generator perturbing functions, for example the +-- | Combine two generator perturbing functions, for example the -- results of calls to 'variant' or 'coarbitrary'. hunk ./Test/QuickCheck/Arbitrary.hs 315 -(><) :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> (Gen a -> Gen a) +(><) :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> (Gen a -> Gen a) (><) f g gen = do n <- arbitrary hunk ./Test/QuickCheck/Arbitrary.hs 318 - (g . variant (n :: Int) . f) gen + (g . variant (n :: Int) . f) gen -- for the sake of non-GHC compilers, I have added definitions -- for coarbitrary here. hunk ./Test/QuickCheck/Arbitrary.hs 327 coarbitrary f gen = do xs <- arbitrary coarbitrary (map f xs) gen - + instance CoArbitrary () where coarbitrary _ = id hunk ./Test/QuickCheck/Arbitrary.hs 332 instance CoArbitrary Bool where - coarbitrary False = variant 0 - coarbitrary True = variant (-1) + coarbitrary False = variant (0::Int) + coarbitrary True = variant (-1::Int) instance CoArbitrary a => CoArbitrary (Maybe a) where hunk ./Test/QuickCheck/Arbitrary.hs 336 - coarbitrary Nothing = variant 0 - coarbitrary (Just x) = variant (-1) . coarbitrary x + coarbitrary Nothing = variant (0::Int) + coarbitrary (Just x) = variant (-1::Int) . coarbitrary x instance (CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b) where hunk ./Test/QuickCheck/Arbitrary.hs 340 - coarbitrary (Left x) = variant 0 . coarbitrary x - coarbitrary (Right y) = variant (-1) . coarbitrary y - + coarbitrary (Left x) = variant (0::Int) . coarbitrary x + coarbitrary (Right y) = variant (-1::Int) . coarbitrary y + instance CoArbitrary a => CoArbitrary [a] where hunk ./Test/QuickCheck/Arbitrary.hs 344 - coarbitrary [] = variant 0 - coarbitrary (x:xs) = variant (-1) . coarbitrary (x,xs) + coarbitrary [] = variant (0::Int) + coarbitrary (x:xs) = variant (-1::Int) . coarbitrary (x,xs) instance (Integral a, CoArbitrary a) => CoArbitrary (Ratio a) where coarbitrary r = coarbitrary (numerator r,denominator r) hunk ./Test/QuickCheck/Arbitrary.hs 355 where coarbitrary (x,y) = coarbitrary x >< coarbitrary y - + instance (CoArbitrary a, CoArbitrary b, CoArbitrary c) => CoArbitrary (a,b,c) where hunk ./Test/QuickCheck/Arbitrary.hs 362 coarbitrary (x,y,z) = coarbitrary x >< coarbitrary y >< coarbitrary z - + instance (CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d) => CoArbitrary (a,b,c,d) where hunk ./Test/QuickCheck/Arbitrary.hs 370 >< coarbitrary y >< coarbitrary z >< coarbitrary v - + instance (CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d, CoArbitrary e) => CoArbitrary (a,b,c,d,e) where hunk ./Test/QuickCheck/Arbitrary.hs 379 >< coarbitrary z >< coarbitrary v >< coarbitrary w - + -- typical instance for primitive (numerical) types instance CoArbitrary Integer where hunk ./Test/QuickCheck/Arbitrary.hs 445 instance Arbitrary a => Arbitrary (Fixed a) where arbitrary = Fixed `fmap` arbitrary - + -- no shrink function -- | Ordered xs: guarantees that xs is ordered. hunk ./Test/QuickCheck/Arbitrary.hs 492 instance (Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a) where arbitrary = - frequency + frequency [ (5, (NonNegative . abs) `fmap` arbitrary) , (1, return 0) ] hunk ./Test/QuickCheck/Arbitrary.hs 523 [] `ilv` bs = bs as `ilv` [] = as (a:as) `ilv` (b:bs) = a : b : (as `ilv` bs) - + {- shrink (Smart i x) = part0 ++ part2 ++ part1 where hunk ./Test/QuickCheck/Arbitrary.hs 530 ys = [ Smart i y | (i,y) <- [0..] `zip` shrink x ] i' = 0 `max` (i-2) k = i `div` 10 - + part0 = take k ys part1 = take (i'-k) (drop k ys) part2 = drop i' ys hunk ./Test/QuickCheck/Arbitrary.hs 539 -- drop a (drop b xs) == drop (a+b) xs | a,b >= 0 -- take a (take b xs) == take (a `min` b) xs -- take a xs ++ drop a xs == xs - + -- take k ys ++ take (i'-k) (drop k ys) ++ drop i' ys -- == take k ys ++ take (i'-k) (drop k ys) ++ drop (i'-k) (drop k ys) -- == take k ys ++ take (i'-k) (drop k ys) ++ drop (i'-k) (drop k ys) hunk ./Test/QuickCheck/Function.hs 3 -- | Uses magic to show and shrink functions. module Test.QuickCheck.Function - ( + ( -- * \"Magic\" functions Function , function, getFunction hunk ./Test/QuickCheck/Function.hs 8 , getTable, showTable - + -- * Generating monotonic functions , MonotonicFunction(..), StrictlyMonotonicFunction(..) ) hunk ./Test/QuickCheck/Function.hs 19 import Test.QuickCheck.Gen import Test.QuickCheck.Arbitrary -import Test.QuickCheck.Property +import Test.QuickCheck.Property ((==>), expectFailure, Property) import Data.IORef import Data.List hunk ./Test/QuickCheck/Function.hs 24 -import System.IO.Unsafe - ( unsafePerformIO -- yes, it's popping up its evil head again! - ) +import System.IO.Unsafe (unsafePerformIO) -- yes, it's popping up its evil head again! -------------------------------------------------------------------------- -- | Functions from @a@ to @b@ which keep track of arguments hunk ./Test/QuickCheck/Function.hs 82 , y' <- shrink y ] where - update x' y' f x + update x' y' g x | x == x' = y' hunk ./Test/QuickCheck/Function.hs 84 - | otherwise = f x + | otherwise = g x -------------------------------------------------------------------------- -- monotonicity hunk ./Test/QuickCheck/Function.hs 117 | otherwise -> y0 - (downs !! (-x-1)) where arbIncSeq = - do as <- sequence [ arbitrary | _ <- [1..] ] + do as <- sequence [ arbitrary | _ <- [(1::Integer)..] ] let sums s (x:xs) = s `seq` (s : sums (val x+s) xs) hunk ./Test/QuickCheck/Function.hs 119 - return (tail (sums 0 as)) + return $ tail $ sums 0 as -------------------------------------------------------------------------- -- properties hunk ./Test/QuickCheck/Function.hs 123 - +prop_Monotonic, prop_StrictlyMonotonic_Wrong :: Int -> Int -> MonotonicFunction -> Property prop_Monotonic x y (Monotonic (Function _ f)) = hunk ./Test/QuickCheck/Function.hs 125 - x <= y ==> - f x <= f y - -prop_StrictlyMonotonic x y (StrictlyMonotonic (Function _ f)) = - x < y ==> - f x < f y + x <= y ==> f x <= f y prop_StrictlyMonotonic_Wrong x y (Monotonic (Function _ f)) = hunk ./Test/QuickCheck/Function.hs 128 - expectFailure $ - x < y ==> - f x < f y + expectFailure $ x < y ==> f x < f y + +prop_StrictlyMonotonic :: Int -> Int -> StrictlyMonotonicFunction -> Property +prop_StrictlyMonotonic x y (StrictlyMonotonic (Function _ f)) = + x < y ==> f x < f y -------------------------------------------------------------------------- -- the end. } [.cabal: don't forget the examples gwern0@gmail.com**20080407155003] < > { hunk ./QuickCheck.cabal 26 For more information, see the homepage or the Haskell wiki: . Homepage: http://www.cs.chalmers.se/~rjmh/QuickCheck/ + +Data-Files: examples/ExLambda.hs, examples/ExWords.hs, + examples/Example2.hs, examples/Set.hs, + examples/ExSimple.hs, examples/ExHeap.hs, + examples/ExSet2.hs, examples/ExMerge.hs, + examples/ExFol.hs, examples/ExTrie.hs, + examples/ExSet.hs, examples/Example1.hs Cabal-Version: >= 1.2 Build-type: Simple } Context: [Changed .cabal file to compile with GHC 6.8.1. Cabal >= 1.2 is now required, to get configurations support. bjorn@bringert.net**20071112154137] [Haddock tweak. bringert@cs.chalmers.se**20061126234053] [Added a version of sampling that returns the test cases dpt@math.columbia.edu**20061126220704] [Added LICENSE file. bringert@cs.chalmers.se**20061126232241] [Fixed silly missed use of Positive constructor. Reported by Audrey Tang. bringert@cs.chalmers.se**20061124212824] [Added README. bringert@cs.chalmers.se**20061123144917] [Some haddock mark-up fixes to support haddock 0.7. bringert@cs.chalmers.se**20061123144831] [Removed BUGS. bringert@cs.chalmers.se**20061123144204] [Changed distribution of NonNegative to 1:5 for 0:everything else (was 9:1). bringert@cs.chalmers.se**20061120210126] [Added NonZero and reimplemented Positive in terms of NonZero and NonNegative. bringert@cs.chalmers.se**20061120205417] [Added BUGS file. bringert@cs.chalmers.se**20061120205405] [Added Integral and Real instances for Positive and NonNegative. bringert@cs.chalmers.se**20061120204544] [Some haddock tweaks. bringert@cs.chalmers.se**20061120112922] [More haddock comments. bringert@cs.chalmers.se**20061120112532] [More haddock and export list fixes. bringert@cs.chalmers.se**20061117201830] [Added lots of Haddock comments and cleaned up export lists. bringert@cs.chalmers.se**20061117200346] [Commented out generics import that Haddock choked on. bringert@cs.chalmers.se**20061117152818] [Removed shrinkSub workarounds for old GHC bugs. bringert@cs.chalmers.se**20061117152630] [Get rid of the last uses of modules from the haskell98 package, replace with base modules. bringert@cs.chalmers.se**20061117152400] [Added Cabal build system. bringert@cs.chalmers.se**20061117152230] [Removed Koen's CVS update script. bringert@cs.chalmers.se**20061117151819] [Renamed modules to Test.QuickCheck.*. bringert@cs.chalmers.se**20061117151417] [More fixes to get examples to compile. bringert@cs.chalmers.se**20061114164526] [Fixed some imports in examples. bringert@cs.chalmers.se**20061114163012] [Fixed Chalmers/QuickCheck/Monadic.hs to compile with GHC 6.6. bringert@cs.chalmers.se**20061114162953] [Moved examples to a top-level directory. bringert@cs.chalmers.se**20061114160643] [Fixed ExSet2 and ExLambda to compile with GHC 6.6. bringert@cs.chalmers.se**20061114160531] [Comment out generics stuff to compile with GHC 6.6. bringert@cs.chalmers.se**20061114160414] [Renamed QuickCheck to Chalmers to get module names right. bringert@cs.chalmers.se**20061114160326] [Tailorization of QuickCheck tailor@momo.medic.chalmers.se**20061114165514 Import of the upstream sources from the repository /users/cs/koen/CvsRoot as of revision 2006-05-03 18:37:52 by koen ] Patch bundle hash: 704a28da1cf214b62bf51e0b65cff2847cae146f