QuickCheck 2.17.1.0 → 2.18.0.0

raw patch · 23 files changed

+826/−542 lines, 23 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• QuickCheck.cabal +5/−4
• changelog +0/−446
• changelog.md +457/−0
• examples/Heap.hs +2/−2
• examples/Heap_Program.hs +1/−1
• examples/Heap_ProgramAlgebraic.hs +1/−1
• examples/Merge.hs +1/−1
• examples/Set.hs +1/−1
• examples/Simple.hs +1/−1
• src/Test/QuickCheck.hs +8/−2
• src/Test/QuickCheck/Arbitrary.hs +125/−60
• src/Test/QuickCheck/Compat.hs +34/−0
• src/Test/QuickCheck/Features.hs +2/−2
• src/Test/QuickCheck/Function.hs +134/−1
• src/Test/QuickCheck/Modifiers.hs +6/−7
• src/Test/QuickCheck/Property.hs +12/−1
• src/Test/QuickCheck/Test.hs +1/−1
• tests/CollectDataTypes.hs +29/−5
• tests/GCoArbitraryExample.hs +1/−1
• tests/Generators.hs +2/−2
• tests/Misc.hs +1/−1
• tests/Monoids.hs +1/−1
• tests/Terminal.hs +1/−1

@@ -1,5 +1,5 @@ Name: QuickCheck-Version: 2.17.1.0+Version: 2.18.0.0 Cabal-Version: >= 1.10 Build-type: Simple License: BSD3@@ -8,7 +8,7 @@ Author: Koen Claessen <koen@chalmers.se> Maintainer: Nick Smallbone <nick@smallbone.se> Bug-reports: https://github.com/nick8325/quickcheck/issues-Tested-with: GHC >= 8.10 && < 9.13, hugs+Tested-with: GHC >= 8.10 && < 9.15, hugs Homepage: https://github.com/nick8325/quickcheck Category:       Testing Synopsis:       Automatic testing of Haskell programs@@ -39,7 +39,7 @@  extra-source-files:   README-  changelog+  changelog.md   examples/Heap.hs   examples/Heap_Program.hs   examples/Heap_ProgramAlgebraic.hs@@ -58,7 +58,7 @@ source-repository this   type:     git   location: https://github.com/nick8325/quickcheck-  tag:      2.16+  tag:      2.18  flag templateHaskell   Description: Build Test.QuickCheck.All, which uses Template Haskell.@@ -97,6 +97,7 @@   -- Modules that are always built.   Exposed-Modules:     Test.QuickCheck,+    Test.QuickCheck.Compat,     Test.QuickCheck.Arbitrary,     Test.QuickCheck.Gen,     Test.QuickCheck.Gen.Unsafe,

@@ -1,446 +0,0 @@-QuickCheck 2.17.1-	* Fix random-1.2 support (thanks bodigrim)-	* Update docs (thanks effectfully)--QuickCheck 2.17-	* Lower the memory use of `arbitrary` for `Double` and `Float` (thanks-	ChickenProp)-	* BREAKING: Remove `Gen.Class`-	* BREAKING: Add `Arbitrary` instances for most of the types in `base`-	* Add microHS support (thanks Lennart)--QuickCheck 2.16-	* Add a `Safe` declaration to `Test.QuickCheck.Monoids`-	* Fix `Test.QuickCheck.Features` to not depend on the internal testing loop-	* Add `withProgress` to install common callbacks for downstream tools-	* Relax bounds on `random` dependency (thanks to LaurentRDC and-	Andreas Abel)-	* Fix some haddock issues (thanks to pgujjula)-	* Use `displayException` instead of `show` (thanks Edsko)-	* Added helper monoids `Every` and `Some` for predicates (thanks-	Marcin)--QuickCheck 2.15-	* BREAKING: properties without quantification are no longer implicitly-	  wrapped in once-	* Add witness property modifier and witnesses field in result on-	compilers that support Typeable to allow conveniently exposing-	counterexamples-	* Add assertException, assertExceptionIO, assertDeepException, and-	assertDeepExceptionIO (thanks to Alexey Kuleshevich)-	* Add withMaxSize, withMaxShrinks, and withMaxDiscardRatio combinators-	* Add recheck-	* Add HasCallStack to partial top-level functions-	* Updated some documentation-	* Fix overflow bug when calculating discard ratio-	* Fix error printing bug when shrinks are discarded-	* Fix withMaxSuccess not working when checkCoverage is turned on-	* Fix a bug whereby an unfortunately timed discard could unduly fail a-	property running with checkCoverage-	* Fix Arbitrary intance for Map breaking invariants from-	Data.Map.Strict (thanks to Neil Mayhew)-	* Fix non-covered classes not showing up in output as 0% covered-	* Fix Negative's Arbitrary instance discarding an unnecessary number-	of generated values.-	* Fix promote doing an unnecessary seed split-	* Fix a bug whereby maxSuccess and discardRatio would interact poorly-	to produce too few size increases.-	* Fix a couple of underflow bugs in generators for Small Natural and-	Ratio Natural-	* Fix a bug whereby the internal DISCARDED exception would show up-	user-side in sample--QuickCheck 2.14.3 (released 2023-05-31)-	* Add shrinkBoundedEnum (thanks to Jonathan Knowles)-	* Add discardAfter for discarding tests on timeout (thanks to Justus Sagemüller)-	* Add assertWith for monadic testing (thanks to KtorZ)-	* Add functionElements to Test.QuickCheck.Function (thanks to Oleg Grenrus)-	* Add Arbitrary instance for Newline (thanks to Daniel Bramucci)-	* Improve Arbitrary instances for Float and Double (thanks to Oleg Grenrus)-	* Improve arbitrarySizedFractional (thanks to Bodigrim)-	* Fix shrinkRealFrac and shrinkDecimal, which were broken-	* Speed up printing of progress messages (thanks to Bodigrim)-	* Add COMPLETE pragmas for Fn and family (thanks to ilkecan)-	* Make templateHaskell flag manual (thanks to Oleg Grenrus)--QuickCheck 2.14.2 (released 2020-11-14)-	* Add Arbitrary instances for Tree (thanks to Oleg Grenrus)-	* GHC 9.0 compatibility (thanks to Vilem-Benjamin Liepelt)--QuickCheck 2.14.1 (released 2020-07-05)-	* Compatibility with random >= 1.2.--QuickCheck 2.14 (released 2020-03-28)-	* QuickCheck is now much faster at generating test data!-	  As a result, many properties can now be tested a lot faster;-	  the examples distributed with QuickCheck run about twice as-	  fast as before, for example. Of course, your mileage may vary.--	  The reason for this is that there are now specialised versions-	  of the 'choose' combinator for various types. These are:-	  chooseInt, chooseInteger, chooseBoundedIntegral, and chooseEnum.-	  These combinators are identical to 'choose' but much faster.-	  All QuickCheck combinators, with the exception of 'choose'-	  itself, use the new combinators behind the scenes.--	  You should see a speedup without doing anything, but to get a-	  further speedup, consider replacing any uses of 'choose' in your-	  own generators with the new combinators.--	  We are hoping that future releases of the 'random' library may-	  speed up 'choose', in which case these combinators may no longer-	  be needed.--	  Thanks to Oleg Grenrus for suggesting to bypass 'choose' for-	  random number generation, and providing the appropriate-	  primitive in his 'splitmix' random number library.--	* Smaller changes and bugfixes:-		- RecursivelyShrink and GSubterms are exported from-		  Test.QuickCheck.Test (thanks to Tom Mortiboy).-		- Don't generate invalid unicode characters-		  (thanks to Boris Stepanov).-		- When a call to 'within' fails, include the duration of the-		  timeout in the failure report (thanks to William Rusnack).-		- In Gen, avoid splitting the seed in the implementation of-		  >>, *> and <* (thanks to David Feuer).-		- Fix a couple of bugs with shrinking of floating-point-		  numbers.-		- Export functionMapWith, functionEitherWith and-		  functionPairWith from Test.QuickCheck.Function-		  (thanks to Oleg Grenrus).-		- Remove redundant RealFloat constraint from-		  Arbitrary/CoArbitrary instances for Complex-		  (thanks to Bodigrim).--QuickCheck 2.13.2 (released 2019-06-30)-	* Compatibility with GHC 8.8 (thanks to Bodigrim)-	* Improve error message when 'frequency' is used with only zero weights-	* Add 'functionVoid' combinator (thanks to Oleg Grenrus)-	* Tighten bounds for random package (thanks to Oleg Grenrus)--QuickCheck 2.13.1 (released 2019-03-29)-	* A couple of bug fixes--QuickCheck 2.13 (released 2019-03-26)-	* Properties with multiple arguments now shrink better.-	  Previously, the first argument was shrunk, then the second, and-	  so on. Now, the arguments are shrunk as a whole, so shrink steps-	  for different arguments can be interleaved.--	* New features:-		- New modifiers Negative and NonPositive-		- A Testable instance for Maybe prop (where Nothing means 'discard-		  the test case')-	* Dependencies on C code removed:-		- Use splitmix instead of tf-random for random number generation-		- Remove dependency on 'erf' package-	* Small changes:-		- Say 'Falsified' instead of 'Falsifiable' when a property fails-	* Compatibility improvements:-		- Explicitly derive instance Typeable Args-		- Lower bound on deepseq-		- A script for building Hugs packages--QuickCheck 2.12.6 (released 2018-10-02)-	* Make arbitrarySizedBoundedIntegral handle huge sizes correctly.-	* Add changelog for QuickCheck 2.12.5 :)--QuickCheck 2.12.5 (released 2018-09-30)-	* Export isSuccess from Test.QuickCheck.-	* Export CoArbitrary even when generics are disabled (bugfix).-	* Fix bug in shrinkDecimal.-	* Include Test.QuickCheck.Gen in exposed modules for Haddock.--QuickCheck 2.12.3, 2.12.4 (released 2018-09-12)-	* Shrinking for Float and Decimal now works by reducing the number-	  of digits in the number. The new function shrinkDecimal-	  implements this shrinking behaviour.-	* Shrinking for Rational now tries to make the numerator and-	  denominator of the number smaller. Previously it tried to reduce-	  the magnitude of the number.--QuickCheck 2.12.2 (released 2018-09-10)-	* Fix infinite shrinking loop for fractional types.-	* Add SortedList modifier.--QuickCheck 2.12.1 (released 2018-09-06)-	* Fix bug in 'classify'.--QuickCheck 2.12 (released 2018-09-03)-	* Silently breaking changes!-		- The Arbitrary instance for Word now generates only small-		  values, the same as Int-		- cover no longer causes a property failure if coverage is-		  insufficient. It just prints a warning. (But see next item!)--	* Overhaul of label/cover family of combinators:-		- New property combinator checkCoverage, which checks coverage-		  requirements in a statistically sound way, and *does* fail if-		  they are not met.-		- Order of arguments to cover swapped, to make it easier to-		  switch between classify and cover-		- New combinators tabulate and coverTable, for reporting test-		  case distribution more flexibly than label.-		- When label is called multiple times in a property, each call-		  produces a separate table of frequencies.--	* New functions:-		- (=/=): like (/=), but prints a counterexample-		  (thanks to tom-bop)-		- forAllShow/forAllShrinkShow: quantification using an-		  explicit show function (thanks to Stevan Andjelkovic)-		- forAllBlind/forAllShrinkBlind: quantification without-		  printing anything-		- verboseShrinking: see how a counterexample is shrunk-		- labelledExamples: given a property which uses label,-		  generate an example test case for each label-		- idempotentIOProperty: a variant of ioProperty which shrinks-		  better but only works for idempotent I/O actions--	* Other improvements:-		- MonadFix Gen instance (thanks to Jon Fowler)-		- Rational numbers shrink using continued fractions-		  (thanks to Justus Sagemüller)-		- Function instances for Const, Identity, and the types in-		  Data.Monoid; instance Functor Fun (thanks to Erik Schnetter-		  and Xia Li-yao)-		- More of Test.QuickCheck.Function is exported from-		  Test.QuickCheck-		- Semantics of .||. changed to improve short-circuiting:-		  if the left argument's precondition is false, the right-		  argument is not evaluated and the whole disjunction is-		  considered to have a false precondition-		- Bug fix: suchThatMaybe always increased size to at least 1--	* Miscellaneous API changes:-		- Result type has changed a bit:-			- InsufficientCovered constructor is gone-			- Type of labels has changed-			- New fields classes, tables--QuickCheck 2.11.1 - 2.11.3 (released 2018-01-12)-	* Cosmetic fixes.--QuickCheck 2.11 (released 2018-01-12)-	* New features:-		- InfiniteList modifier generates infinite lists and shows-		  only the relevant part.-		- applyArbitrary2/3/4 for applying a function to random-		  arguments.-		- Template Haskell function allProperties returns all-		  properties in a module.--	* Applicative Gen instances do less splitting.-	* Property now has a Typeable instance.-	* (===) now prints correct output when the property is true.-	* Test.QuickCheck now exports Fun constructor.-	* verboseCheck output is now slightly less confusing.--QuickCheck 2.10.1 (released 2017-10-06)-	* Arbitrary instances for Foreign.C.Types are available in more-	  GHC versions.-	* Fixed a bug where withMaxSuccess didn't adjust the allowed-	  number of discarded tests.-	* Remove quadratic behaviour in terminal output.--QuickCheck 2.10 (released 2017-06-15)-	* New combinators:-		- withMaxSuccess sets the maximum number of test cases for a property.-		- shrinkMap/shrinkMapBy are helpers for defining shrink functions.-		- total checks that a value is non-crashing.-		- suchThatMap is similar to 'suchThat'-		  but takes a Maybe-returning function instead of a predicate.-		- getSize returns the current test case size.--	* Random strings and characters now include Unicode characters by-	  default. To generate only ASCII characters, use the new-	  ASCIIString modifier or arbitraryASCIIChar generator.-	  The following modifiers and generators also control the-	  kind of strings generated: UnicodeString, PrintableString,-	  arbitraryUnicodeChar, arbitraryPrintableChar.--	* QuickCheck no longer catches asynchronous exceptions, which-	  means that pressing ctrl-C will now cancel testing without-	  printing a counterexample. If you are debugging an infinite loop,-	  please use the 'within' combinator or 'verboseCheck' instead.-	  ('within' is better as it allows the counterexample to be-	  shrunk.)--	* Much of Test.QuickCheck.Function (showable random functions)-	  is now exported from Test.QuickCheck.-		- Test.QuickCheck.Function now defines functions and-		  pattern synonyms which simplify testing functions of-		  more than one argument: apply2, apply3, Fn2, Fn3.--	* New typeclasses Arbitrary1 and Arbitrary2 which lift Arbitrary-	  to unary/binary type constructors, like in Data.Functor.Classes.--	* Some Arbitrary instances have been removed: NonEmpty, Natural.-	  This is because they resulted in a lot of extra dependencies.-	  You can now find them in the quickcheck-instances package.-	  Alternatively, use the NonEmptyList and NonNegative modifiers.--	* New Arbitrary instances for the following types: Proxy, ExitCode,-	  WrappedMonad, WrappedArrow, QCGen, and the types in-	  Foreign.C.Types and Data.Functor.{Product,Compose}.-	  Also a Function instance for Word.--	* The functions in Test.QuickCheck.Monadic which take an argument-	  of type PropertyM m a now expect that 'a' to be Testable, and test it.-	  To reduce breakage from this, () is now an instance of Testable which-	  always succeeds.-		- PropertyM now has a MonadFail instance on recent GHCs.-		  Furthermore, the constraints on some instances were loosened.--	* Miscellaneous API changes:-		- Result now returns the counterexample as a list of strings.-		  See the "failingTestCase" field.-		- Args now has a `maxShrinks` argument, the maximum number of-		  shrinks to try before giving up shrinking.-		- The 'labels' field of Result now encodes frequencies as Doubles-		  rather than Ints.--	* Bugfixes:-		- 'Test.QuickCheck.Function', 'Test.QuickCheck.Poly', and-		  'Test.QuickCheck.Monadic' are now Safe modules.-		- Result.theException and Result.reason were taken from-		  the pre-shrunk counterexample, not the shrunk one.-		- The Testable Property instance improperly used 'again'.-		- Gen.>>= is strict in the result of split, fixing a space leak.-		- within now gives a better error message on timeout--	* Some more examples and links have been added to the documentation.--QuickCheck 2.9.2 (released 2016-09-15)-	* Fix a bug where some properties were only being tested once-	* Make shrinking of floating-point values less aggressive-	* Add function chooseAny :: Random a => Gen a--QuickCheck 2.9.1 (released 2016-07-11)-	* 'again' was only used in forAllShrink, not forAll--QuickCheck 2.9 (released 2016-07-10)-	* Arbitrary, CoArbitrary and Function instances for more types-	* Generics for automatic Function instances-	* A new combinator "again" which undoes the effect of "once"-	* Remove "exhaustive" from Testable typeclass;-	  instead, combinators which are nonexhaustive (such as forAll)-	  call "again", which should be more robust--	* Drop support for GHC 6.x--	* Fixed bugs:-		* arbitrarySizedBoundedIntegral wasn't generating huge integers-		* verboseCheck failed with Test.QuickCheck.Function-		* label had a space leak--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-	* Don't export Test.QuickCheck.Property.result--QuickCheck 2.8 (released 2015-03-18)-	* New features:-		* Support for GHC 7.10-		* Arbitrary instance for Natural-		* New generators shuffle and sublistOf-		* Support for generic coarbitrary-		* When using the cover combinator, insufficient coverage now-		  causes the property to fail--	* API changes:-		* Test.QuickCheck.Function: new pattern synonym Fn-		* genericShrink no longer requires Typeable-		* Result has a new constructor InsufficientCoverage-		* resize throws an error if the size is negative--	* Bug fixes:-		* Fix memory leaks-		* Exceptions thrown by callbacks now cause the test to fail-		* Fixed a bug where the cover combinator wouldn't give a-		  warning if coverage was 0%--QuickCheck 2.7.3 (released 2014-03-24)-	* Add annotations for Safe Haskell.--QuickCheck 2.7.2 (released 2014-03-22)-	* Fix bug in cabal file which broke cabal test--QuickCheck 2.7.1 (released 2014-03-20)-	* Fixed bug - the Small modifier didn't work on unsigned types-	* Changed arbitrarySizedIntegral to have an Integral constraint-	  instead of just Num--QuickCheck 2.7 (released 2014-03-19)--	* New features:-		* New genericShrink function provides generic shrinking with GHC.-		* New combinator x === y: fails if x /= y, but also prints their values-		* New function generate :: Gen a -> IO a for running a generator.-		* New combinators infiniteList and infiniteListOf for generating infinite lists.-		* Several combinators added to the main Test.QuickCheck module which-		  were previously languishing in other modules. Of particular interest:-		  quickCheckAll, ioProperty.-		* New combinators delay and capture which can be used (unsafely!)-		  to reuse the random number seed. Useful for generating-		  polymorphic (rank-2) values.-		* A new Discard data type and a Testable instance for discarding test cases.-		* All modifiers now have Functor instances and accessor functions.-		* Pressing ctrl-C during shrinking now shows the last failed-		  test case, rather than the current shrinking candidate.-		* Experimental support for UHC. You will need the latest version of Cabal from git.--	* Better distribution of test data:-		* The Int generator now only generates fairly small numbers.-		* The new Small and Large modifiers control the distribution of integers-		  (Small generates small numbers, Large from the whole range).-		* Floating-point numbers shrink better.--	* Improved random number generation:-		* QuickCheck now uses TFGen rather than StdGen on newer versions-		  of GHC, because StdGen's random numbers aren't always random.-		* 'variant' now uses a prefix code. This should prevent some-		  potential bananaskins with coarbitrary.--	* API changes:-		* The Gen monad now uses an abstract type QCGen rather than StdGen.-		* The Result type now returns the thrown exception and number-		  of failed shrink attempts.-		* Property is now a newtype rather than Gen Prop as it was before.-		* promote is moved into the new module Test.QuickCheck.Gen.Unsafe.-		* 'printTestCase' is deprecated - its new name is 'counterexample'-		* 'morallyDubiousIOProperty' is deprecated - its new name is-		  'ioProperty', no moral judgement involved :)--QuickCheck 2.6, released 2013-03-07--	* Add convenience Function instances for up to 7-tuples-	* Make stderr line buffered to reduce console I/O.-	* Return a flag to say whether the test case was interrupted.--QuickCheck 2.5, released 2012-06-18--	* Replace maxDiscard with maxDiscardRatio-	* Remove Testable () instance.-	* Added a 'discard' exception that discards the current test case-	* Add accessors for modifiers (where it makes sense)-	* Rename 'stop' to 'abort' to avoid a name clash-	* Added a 'once' combinator-	* If a property is of type Bool, only run it once-	* Add coarbitraryEnum to Test.QuickCheck module.-	* Add 'coarbitrary' helper for Enums.-	* Rejiggled the formatting code to support multi-line error messages-	* Add instances for Ordering and Fixed.-	* Added arbitraryBoundedEnum generator (thanks to Antoine Latter).-	* Add verboseCheckAll and polyverboseCheck function for usability.

@@ -0,0 +1,457 @@+## UNRELEASED++## QuickCheck 2.18.0.0 (released 2026-02-26)+* BREAKING: Added a number of `CoArbitrary` and `Function` instances for types in `base`+* Improve implementation of `shrinkIntegral` (thanks tom93)+* Improve implementation of `Arbitrary NonEmptyList` (thanks konsumlamm)+* Convert changelog to markdown (thanks Artem)+* Deprecate `withMaxSuccess` in favour of the renamed `withNumTests`+* `Test.QuickCheck.Function` marked as `Trustworthy` not `Safe`+* Fix bug in heap example++## QuickCheck 2.17.1.0 (released 2025-10-13)+* Fix random-1.2 support (thanks bodigrim)+* Update docs (thanks effectfully)++## QuickCheck 2.17.0.0 (released 2025-10-07)+* Lower the memory use of `arbitrary` for `Double` and `Float` (thanks+ChickenProp)+* BREAKING: Remove `Gen.Class`+* BREAKING: Add `Arbitrary` instances for most of the types in `base`+* Add microHS support (thanks Lennart)++## QuickCheck 2.16.0.0 (released 2025-06-17)+* Add a `Safe` declaration to `Test.QuickCheck.Monoids`+* Fix `Test.QuickCheck.Features` to not depend on the internal testing loop+* Add `withProgress` to install common callbacks for downstream tools+* Relax bounds on `random` dependency (thanks to LaurentRDC and+Andreas Abel)+* Fix some haddock issues (thanks to pgujjula)+* Use `displayException` instead of `show` (thanks Edsko)+* Added helper monoids `Every` and `Some` for predicates (thanks+Marcin)++## QuickCheck 2.15 (released 2024-04-22)+* BREAKING: properties without quantification are no longer implicitly+  wrapped in once+* Add witness property modifier and witnesses field in result on+compilers that support Typeable to allow conveniently exposing+counterexamples+* Add assertException, assertExceptionIO, assertDeepException, and+assertDeepExceptionIO (thanks to Alexey Kuleshevich)+* Add withMaxSize, withMaxShrinks, and withMaxDiscardRatio combinators+* Add recheck+* Add HasCallStack to partial top-level functions+* Updated some documentation+* Fix overflow bug when calculating discard ratio+* Fix error printing bug when shrinks are discarded+* Fix withMaxSuccess not working when checkCoverage is turned on+* Fix a bug whereby an unfortunately timed discard could unduly fail a+property running with checkCoverage+* Fix Arbitrary intance for Map breaking invariants from+Data.Map.Strict (thanks to Neil Mayhew)+* Fix non-covered classes not showing up in output as 0% covered+* Fix Negative's Arbitrary instance discarding an unnecessary number+of generated values.+* Fix promote doing an unnecessary seed split+* Fix a bug whereby maxSuccess and discardRatio would interact poorly+to produce too few size increases.+* Fix a couple of underflow bugs in generators for Small Natural and+Ratio Natural+* Fix a bug whereby the internal DISCARDED exception would show up+user-side in sample++## QuickCheck 2.14.3 (released 2023-05-31)+* Add shrinkBoundedEnum (thanks to Jonathan Knowles)+* Add discardAfter for discarding tests on timeout (thanks to Justus Sagemüller)+* Add assertWith for monadic testing (thanks to KtorZ)+* Add functionElements to Test.QuickCheck.Function (thanks to Oleg Grenrus)+* Add Arbitrary instance for Newline (thanks to Daniel Bramucci)+* Improve Arbitrary instances for Float and Double (thanks to Oleg Grenrus)+* Improve arbitrarySizedFractional (thanks to Bodigrim)+* Fix shrinkRealFrac and shrinkDecimal, which were broken+* Speed up printing of progress messages (thanks to Bodigrim)+* Add COMPLETE pragmas for Fn and family (thanks to ilkecan)+* Make templateHaskell flag manual (thanks to Oleg Grenrus)++## QuickCheck 2.14.2 (released 2020-11-14)+* Add Arbitrary instances for Tree (thanks to Oleg Grenrus)+* GHC 9.0 compatibility (thanks to Vilem-Benjamin Liepelt)++## QuickCheck 2.14.1 (released 2020-07-05)+* Compatibility with random >= 1.2.++## QuickCheck 2.14 (released 2020-03-28)+* QuickCheck is now much faster at generating test data!+  As a result, many properties can now be tested a lot faster;+  the examples distributed with QuickCheck run about twice as+  fast as before, for example. Of course, your mileage may vary.++  The reason for this is that there are now specialised versions+  of the 'choose' combinator for various types. These are:+  chooseInt, chooseInteger, chooseBoundedIntegral, and chooseEnum.+  These combinators are identical to 'choose' but much faster.+  All QuickCheck combinators, with the exception of 'choose'+  itself, use the new combinators behind the scenes.++  You should see a speedup without doing anything, but to get a+  further speedup, consider replacing any uses of 'choose' in your+  own generators with the new combinators.++  We are hoping that future releases of the 'random' library may+  speed up 'choose', in which case these combinators may no longer+  be needed.++  Thanks to Oleg Grenrus for suggesting to bypass 'choose' for+  random number generation, and providing the appropriate+  primitive in his 'splitmix' random number library.++* Smaller changes and bugfixes:+- RecursivelyShrink and GSubterms are exported from+  Test.QuickCheck.Test (thanks to Tom Mortiboy).+- Don't generate invalid unicode characters+  (thanks to Boris Stepanov).+- When a call to 'within' fails, include the duration of the+  timeout in the failure report (thanks to William Rusnack).+- In Gen, avoid splitting the seed in the implementation of+  >>, *> and <* (thanks to David Feuer).+- Fix a couple of bugs with shrinking of floating-point+  numbers.+- Export functionMapWith, functionEitherWith and+  functionPairWith from Test.QuickCheck.Function+  (thanks to Oleg Grenrus).+- Remove redundant RealFloat constraint from+  Arbitrary/CoArbitrary instances for Complex+  (thanks to Bodigrim).++## QuickCheck 2.13.2 (released 2019-06-30)+* Compatibility with GHC 8.8 (thanks to Bodigrim)+* Improve error message when 'frequency' is used with only zero weights+* Add 'functionVoid' combinator (thanks to Oleg Grenrus)+* Tighten bounds for random package (thanks to Oleg Grenrus)++## QuickCheck 2.13.1 (released 2019-03-29)+* A couple of bug fixes++## QuickCheck 2.13 (released 2019-03-26)+* Properties with multiple arguments now shrink better.+  Previously, the first argument was shrunk, then the second, and+  so on. Now, the arguments are shrunk as a whole, so shrink steps+  for different arguments can be interleaved.++* New features:+    - New modifiers Negative and NonPositive+    - A Testable instance for Maybe prop (where Nothing means 'discard+      the test case')+* Dependencies on C code removed:+    - Use splitmix instead of tf-random for random number generation+    - Remove dependency on 'erf' package+* Small changes:+    - Say 'Falsified' instead of 'Falsifiable' when a property fails+* Compatibility improvements:+    - Explicitly derive instance Typeable Args+    - Lower bound on deepseq+    - A script for building Hugs packages++## QuickCheck 2.12.6 (released 2018-10-02)+* Make arbitrarySizedBoundedIntegral handle huge sizes correctly.+* Add changelog for QuickCheck 2.12.5 :)++## QuickCheck 2.12.5 (released 2018-09-30)+* Export isSuccess from Test.QuickCheck.+* Export CoArbitrary even when generics are disabled (bugfix).+* Fix bug in shrinkDecimal.+* Include Test.QuickCheck.Gen in exposed modules for Haddock.++## QuickCheck 2.12.3, 2.12.4 (released 2018-09-12)+* Shrinking for Float and Decimal now works by reducing the number+  of digits in the number. The new function shrinkDecimal+  implements this shrinking behaviour.+* Shrinking for Rational now tries to make the numerator and+  denominator of the number smaller. Previously it tried to reduce+  the magnitude of the number.++## QuickCheck 2.12.2 (released 2018-09-10)+* Fix infinite shrinking loop for fractional types.+* Add SortedList modifier.++## QuickCheck 2.12.1 (released 2018-09-06)+* Fix bug in 'classify'.++## QuickCheck 2.12 (released 2018-09-03)+* Silently breaking changes!+    - The Arbitrary instance for Word now generates only small+      values, the same as Int+    - cover no longer causes a property failure if coverage is+      insufficient. It just prints a warning. (But see next item!)++* Overhaul of label/cover family of combinators:+    - New property combinator checkCoverage, which checks coverage+      requirements in a statistically sound way, and *does* fail if+      they are not met.+    - Order of arguments to cover swapped, to make it easier to+      switch between classify and cover+    - New combinators tabulate and coverTable, for reporting test+      case distribution more flexibly than label.+    - When label is called multiple times in a property, each call+      produces a separate table of frequencies.++* New functions:+    - (=/=): like (/=), but prints a counterexample+      (thanks to tom-bop)+    - forAllShow/forAllShrinkShow: quantification using an+      explicit show function (thanks to Stevan Andjelkovic)+    - forAllBlind/forAllShrinkBlind: quantification without+      printing anything+    - verboseShrinking: see how a counterexample is shrunk+    - labelledExamples: given a property which uses label,+      generate an example test case for each label+    - idempotentIOProperty: a variant of ioProperty which shrinks+      better but only works for idempotent I/O actions++* Other improvements:+    - MonadFix Gen instance (thanks to Jon Fowler)+    - Rational numbers shrink using continued fractions+      (thanks to Justus Sagemüller)+    - Function instances for Const, Identity, and the types in+      Data.Monoid; instance Functor Fun (thanks to Erik Schnetter+      and Xia Li-yao)+    - More of Test.QuickCheck.Function is exported from+      Test.QuickCheck+    - Semantics of .||. changed to improve short-circuiting:+      if the left argument's precondition is false, the right+      argument is not evaluated and the whole disjunction is+      considered to have a false precondition+    - Bug fix: suchThatMaybe always increased size to at least 1++* Miscellaneous API changes:+    - Result type has changed a bit:+        - InsufficientCovered constructor is gone+        - Type of labels has changed+        - New fields classes, tables++## QuickCheck 2.11.1 - 2.11.3 (released 2018-01-12)+* Cosmetic fixes.++## QuickCheck 2.11 (released 2018-01-12)+* New features:+    - InfiniteList modifier generates infinite lists and shows+      only the relevant part.+    - applyArbitrary2/3/4 for applying a function to random+      arguments.+    - Template Haskell function allProperties returns all+      properties in a module.++* Applicative Gen instances do less splitting.+* Property now has a Typeable instance.+* (===) now prints correct output when the property is true.+* Test.QuickCheck now exports Fun constructor.+* verboseCheck output is now slightly less confusing.++## QuickCheck 2.10.1 (released 2017-10-06)+* Arbitrary instances for Foreign.C.Types are available in more+  GHC versions.+* Fixed a bug where withMaxSuccess didn't adjust the allowed+  number of discarded tests.+* Remove quadratic behaviour in terminal output.++## QuickCheck 2.10 (released 2017-06-15)+* New combinators:+    - withMaxSuccess sets the maximum number of test cases for a property.+    - shrinkMap/shrinkMapBy are helpers for defining shrink functions.+    - total checks that a value is non-crashing.+    - suchThatMap is similar to 'suchThat'+      but takes a Maybe-returning function instead of a predicate.+    - getSize returns the current test case size.++* Random strings and characters now include Unicode characters by+  default. To generate only ASCII characters, use the new+  ASCIIString modifier or arbitraryASCIIChar generator.+  The following modifiers and generators also control the+  kind of strings generated: UnicodeString, PrintableString,+  arbitraryUnicodeChar, arbitraryPrintableChar.++* QuickCheck no longer catches asynchronous exceptions, which+  means that pressing ctrl-C will now cancel testing without+  printing a counterexample. If you are debugging an infinite loop,+  please use the 'within' combinator or 'verboseCheck' instead.+  ('within' is better as it allows the counterexample to be+  shrunk.)++* Much of Test.QuickCheck.Function (showable random functions)+  is now exported from Test.QuickCheck.+    - Test.QuickCheck.Function now defines functions and+      pattern synonyms which simplify testing functions of+      more than one argument: apply2, apply3, Fn2, Fn3.++* New typeclasses Arbitrary1 and Arbitrary2 which lift Arbitrary+  to unary/binary type constructors, like in Data.Functor.Classes.++* Some Arbitrary instances have been removed: NonEmpty, Natural.+  This is because they resulted in a lot of extra dependencies.+  You can now find them in the quickcheck-instances package.+  Alternatively, use the NonEmptyList and NonNegative modifiers.++* New Arbitrary instances for the following types: Proxy, ExitCode,+  WrappedMonad, WrappedArrow, QCGen, and the types in+  Foreign.C.Types and Data.Functor.{Product,Compose}.+  Also a Function instance for Word.++* The functions in Test.QuickCheck.Monadic which take an argument+  of type PropertyM m a now expect that 'a' to be Testable, and test it.+  To reduce breakage from this, () is now an instance of Testable which+  always succeeds.+    - PropertyM now has a MonadFail instance on recent GHCs.+      Furthermore, the constraints on some instances were loosened.++* Miscellaneous API changes:+    - Result now returns the counterexample as a list of strings.+      See the "failingTestCase" field.+    - Args now has a `maxShrinks` argument, the maximum number of+      shrinks to try before giving up shrinking.+    - The 'labels' field of Result now encodes frequencies as Doubles+      rather than Ints.++* Bugfixes:+    - 'Test.QuickCheck.Function', 'Test.QuickCheck.Poly', and+      'Test.QuickCheck.Monadic' are now Safe modules.+    - Result.theException and Result.reason were taken from+      the pre-shrunk counterexample, not the shrunk one.+    - The Testable Property instance improperly used 'again'.+    - Gen.>>= is strict in the result of split, fixing a space leak.+    - within now gives a better error message on timeout++* Some more examples and links have been added to the documentation.++## QuickCheck 2.9.2 (released 2016-09-15)+* Fix a bug where some properties were only being tested once+* Make shrinking of floating-point values less aggressive+* Add function chooseAny :: Random a => Gen a++## QuickCheck 2.9.1 (released 2016-07-11)+* 'again' was only used in forAllShrink, not forAll++## QuickCheck 2.9 (released 2016-07-10)+* Arbitrary, CoArbitrary and Function instances for more types+* Generics for automatic Function instances+* A new combinator "again" which undoes the effect of "once"+* Remove "exhaustive" from Testable typeclass;+  instead, combinators which are nonexhaustive (such as forAll)+  call "again", which should be more robust++* Drop support for GHC 6.x++* Fixed bugs:+    * arbitrarySizedBoundedIntegral wasn't generating huge integers+    * verboseCheck failed with Test.QuickCheck.Function+    * label had a space leak++## 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+* Don't export Test.QuickCheck.Property.result++## QuickCheck 2.8 (released 2015-03-18)+* New features:+    * Support for GHC 7.10+    * Arbitrary instance for Natural+    * New generators shuffle and sublistOf+    * Support for generic coarbitrary+    * When using the cover combinator, insufficient coverage now+      causes the property to fail++* API changes:+    * Test.QuickCheck.Function: new pattern synonym Fn+    * genericShrink no longer requires Typeable+    * Result has a new constructor InsufficientCoverage+    * resize throws an error if the size is negative++* Bug fixes:+    * Fix memory leaks+    * Exceptions thrown by callbacks now cause the test to fail+    * Fixed a bug where the cover combinator wouldn't give a+      warning if coverage was 0%++## QuickCheck 2.7.3 (released 2014-03-24)+* Add annotations for Safe Haskell.++## QuickCheck 2.7.2 (released 2014-03-22)+* Fix bug in cabal file which broke cabal test++## QuickCheck 2.7.1 (released 2014-03-20)+* Fixed bug - the Small modifier didn't work on unsigned types+* Changed arbitrarySizedIntegral to have an Integral constraint+  instead of just Num++## QuickCheck 2.7 (released 2014-03-19)++* New features:+    * New genericShrink function provides generic shrinking with GHC.+    * New combinator x === y: fails if x /= y, but also prints their values+    * New function generate :: Gen a -> IO a for running a generator.+    * New combinators infiniteList and infiniteListOf for generating infinite lists.+    * Several combinators added to the main Test.QuickCheck module which+      were previously languishing in other modules. Of particular interest:+      quickCheckAll, ioProperty.+    * New combinators delay and capture which can be used (unsafely!)+      to reuse the random number seed. Useful for generating+      polymorphic (rank-2) values.+    * A new Discard data type and a Testable instance for discarding test cases.+    * All modifiers now have Functor instances and accessor functions.+    * Pressing ctrl-C during shrinking now shows the last failed+      test case, rather than the current shrinking candidate.+    * Experimental support for UHC. You will need the latest version of Cabal from git.++* Better distribution of test data:+    * The Int generator now only generates fairly small numbers.+    * The new Small and Large modifiers control the distribution of integers+      (Small generates small numbers, Large from the whole range).+    * Floating-point numbers shrink better.++* Improved random number generation:+    * QuickCheck now uses TFGen rather than StdGen on newer versions+      of GHC, because StdGen's random numbers aren't always random.+    * 'variant' now uses a prefix code. This should prevent some+      potential bananaskins with coarbitrary.++* API changes:+    * The Gen monad now uses an abstract type QCGen rather than StdGen.+    * The Result type now returns the thrown exception and number+      of failed shrink attempts.+    * Property is now a newtype rather than Gen Prop as it was before.+    * promote is moved into the new module Test.QuickCheck.Gen.Unsafe.+    * 'printTestCase' is deprecated - its new name is 'counterexample'+    * 'morallyDubiousIOProperty' is deprecated - its new name is+      'ioProperty', no moral judgement involved :)++## QuickCheck 2.6 (released 2013-03-07)++* Add convenience Function instances for up to 7-tuples+* Make stderr line buffered to reduce console I/O.+* Return a flag to say whether the test case was interrupted.++## QuickCheck 2.5 (released 2012-06-18)++* Replace maxDiscard with maxDiscardRatio+* Remove Testable () instance.+* Added a 'discard' exception that discards the current test case+* Add accessors for modifiers (where it makes sense)+* Rename 'stop' to 'abort' to avoid a name clash+* Added a 'once' combinator+* If a property is of type Bool, only run it once+* Add coarbitraryEnum to Test.QuickCheck module.+* Add 'coarbitrary' helper for Enums.+* Rejiggled the formatting code to support multi-line error messages+* Add instances for Ordering and Fixed.+* Added arbitraryBoundedEnum generator (thanks to Antoine Latter).+* Add verboseCheckAll and polyverboseCheck function for usability.

@@ -72,7 +72,7 @@  toSortedList :: Ord a => Heap a -> [a] toSortedList Empty          = []-toSortedList (Node x h1 h2) = x : toList (h1 `merge` h2)+toSortedList (Node x h1 h2) = x : toSortedList (h1 `merge` h2)  -------------------------------------------------------------------------- -- specification@@ -144,7 +144,7 @@ -- main  return []-main = $quickCheckAll+main = do True <- $quickCheckAll; return ()  -------------------------------------------------------------------------- -- the end.

@@ -187,7 +187,7 @@ -- main  return []-main = $(quickCheckAll)+main = do True <- $quickCheckAll; return ()  -------------------------------------------------------------------------- -- the end.

@@ -245,7 +245,7 @@ -- main  return []-main = $(quickCheckAll)+main = do True <- $quickCheckAll; return ()  -------------------------------------------------------------------------- -- the end.

@@ -110,7 +110,7 @@ --  mapSize (`div` 2) $ \(xss :: [OrderedList Int]) ->  return []-main = $quickCheckAll+main = do True <- $quickCheckAll; return ()  -------------------------------------------------------------------------- -- the end.

@@ -201,7 +201,7 @@ -- main  return []-main = $quickCheckAll+main = do True <- $quickCheckAll; return ()  -------------------------------------------------------------------------- -- the end.

@@ -40,7 +40,7 @@ prop_disj = counterexample "reverse" $(monomorphic 'prop_Reverse) .||.             counterexample "Simon Thompson" $(monomorphic 'prop_SimonThompson) return []-main = $quickCheckAll+main = do True <- $quickCheckAll; return ()  -------------------------------------------------------------------------- -- the end.

@@ -19,9 +19,9 @@ >>> quickCheck prop_reverse +++ OK, passed 100 tests. -To run more tests you can use the 'withMaxSuccess' combinator:+To run more tests you can use the 'withNumTests' combinator: ->>> quickCheck (withMaxSuccess 10000 prop_reverse)+>>> quickCheck (withNumTests 10000 prop_reverse) +++ OK, passed 10000 tests.  To use QuickCheck on your own data types you will need to write 'Arbitrary'@@ -132,6 +132,11 @@   , choose   , chooseInt   , chooseInteger+#ifndef NO_SPLITMIX+  , chooseWord64+  , chooseInt64+  , chooseUpTo+#endif   , chooseBoundedIntegral   , chooseEnum   , chooseAny@@ -302,6 +307,7 @@   , verbose   , verboseShrinking   , noShrinking+  , withNumTests   , withMaxSuccess   , within   , discardAfter

@@ -104,14 +104,6 @@ import Control.WrappedMonad #endif -{--import Data.Generics-  ( (:*:)(..)-  , (:+:)(..)-  , Unit(..)-  )--}- import Data.Char   ( ord   , isLower@@ -196,6 +188,9 @@ import qualified Data.Tree as Tree  import qualified Data.Monoid as Monoid+#if defined(MIN_VERSION_base)+import qualified Data.Semigroup as Semigroup+#endif  #ifndef NO_TRANSFORMERS import Data.Functor.Identity@@ -205,10 +200,6 @@ #endif  #if defined(MIN_VERSION_base)-#if MIN_VERSION_base(4,16,0)---import Data.Type.Ord-#endif- import qualified Data.Semigroup as Semigroup import Data.Ord @@ -228,6 +219,8 @@ import Data.Bits import Text.Printf +import Test.QuickCheck.Compat+ -------------------------------------------------------------------------- -- ** class Arbitrary @@ -1111,6 +1104,9 @@ instance Arbitrary a => Arbitrary (Semigroup.Option a) where   arbitrary = Semigroup.Option <$> arbitrary   shrink = map Semigroup.Option . shrink . Semigroup.getOption++instance CoArbitrary a => CoArbitrary (Semigroup.Option a) where+  coarbitrary = coarbitrary . Semigroup.getOption #endif  #if MIN_VERSION_base(4,16,0)@@ -1129,6 +1125,18 @@ instance Arbitrary a => Arbitrary (And a) where   arbitrary = And <$> arbitrary   shrink = map And . shrink . getAnd++instance CoArbitrary a => CoArbitrary (And a) where+  coarbitrary = coarbitrary . getAnd++instance CoArbitrary a => CoArbitrary (Iff a) where+  coarbitrary = coarbitrary . getIff++instance CoArbitrary a => CoArbitrary (Ior a) where+  coarbitrary = coarbitrary . getIor++instance CoArbitrary a => CoArbitrary (Xor a) where+  coarbitrary = coarbitrary . getXor #endif  #if !defined(__MHS__)@@ -1142,43 +1150,31 @@   arbitrary = Exts.fromList <$> arbitrary #endif   shrink = map Exts.fromList . shrink . Exts.toList-#else++instance CoArbitrary ByteArray where+  coarbitrary = coarbitrary . Exts.toList+ -- MicroHs does not have Exts.fromList #endif /* !defined(__MHS__) */  #if MIN_VERSION_base(4,16,0) -#if !MIN_VERSION_base(4,18,0)--getSolo :: Solo a -> a-getSolo (Solo a) = a--mkSolo :: a -> Solo a-mkSolo = Solo--#elif !MIN_VERSION_base(4,19,0)--getSolo :: Solo a -> a-getSolo (MkSolo a) = a--mkSolo :: a -> Solo a-mkSolo = MkSolo--#else--mkSolo :: a -> Solo a-mkSolo = MkSolo--#endif- instance Arbitrary a => Arbitrary (Solo a) where   arbitrary = mkSolo <$> arbitrary   shrink = map mkSolo . shrink . getSolo++instance CoArbitrary a => CoArbitrary (Solo a) where+  coarbitrary = coarbitrary . getSolo+ #endif  instance Arbitrary a => Arbitrary (Down a) where   arbitrary = fmap Down arbitrary   shrink = map Down . shrink . getDown++instance CoArbitrary a => CoArbitrary (Down a) where+  coarbitrary = coarbitrary . getDown+ #endif  #ifdef __GLASGOW_HASKELL__@@ -1231,14 +1227,13 @@   shrink (Op f) = [ Op f' | f' <- shrink f ]  instance CoArbitrary a => Arbitrary (Equivalence a) where-  arbitrary = Equivalence <$> arbitrary--  shrink (Equivalence e) = [ Equivalence e' | e' <- shrink e ]+  arbitrary = do+    Comparison cmp <- arbitrary+    return $ Equivalence (\x y -> cmp x y == EQ)  instance CoArbitrary a => Arbitrary (Comparison a) where-  arbitrary = Comparison <$> arbitrary--  shrink (Comparison c) = [ Comparison c' | c' <- shrink c ]+  arbitrary = do+    Comparison . comparing <$> (liftArbitrary arbitrary :: Gen (a -> Integer))  #endif @@ -1487,20 +1482,8 @@ -- | Shrink an integral number. shrinkIntegral :: Integral a => a -> [a] shrinkIntegral x =-  nub $-  [ -x-  | x < 0, -x > x-  ] ++-  [ x'-  | x' <- takeWhile (<< x) (0:[ x - i | i <- tail (iterate (`quot` 2) x) ])-  ]- where-   -- a << b is "morally" abs a < abs b, but taking care of overflow.-   a << b = case (a >= 0, b >= 0) of-            (True,  True)  -> a < b-            (False, False) -> a > b-            (True,  False) -> a + b < 0-            (False, True)  -> a + b > 0+  [ -x | x < 0, -x > x ] +++  [ x - i | i <- takeWhile (/= 0) (iterate (`quot` 2) x)]  -- | Shrink an element of a bounded enumeration. --@@ -1767,6 +1750,11 @@ instance CoArbitrary Double where   coarbitrary = coarbitraryReal +#if defined(MIN_VERSION_base)+instance CoArbitrary Natural where+  coarbitrary = coarbitraryIntegral+#endif+ -- Coarbitrary instances for container types instance CoArbitrary a => CoArbitrary (Set.Set a) where   coarbitrary = coarbitrary. Set.toList@@ -1785,6 +1773,12 @@ instance CoArbitrary a => CoArbitrary (ZipList a) where   coarbitrary = coarbitrary . getZipList +-- CoArbitrary instance for NonEmpty+#if defined(MIN_VERSION_base)+instance CoArbitrary a => CoArbitrary (NonEmpty a) where+  coarbitrary (a NonEmpty.:| as) = coarbitrary (a, as)+#endif+ #ifndef NO_TRANSFORMERS -- CoArbitrary instance for transformers' Functors instance CoArbitrary a => CoArbitrary (Identity a) where@@ -1826,19 +1820,90 @@  instance CoArbitrary (f a) => CoArbitrary (Monoid.Alt f a) where   coarbitrary = coarbitrary . Monoid.getAlt-#endif -instance CoArbitrary Version where-  coarbitrary (Version a b) = coarbitrary (a, b)+instance CoArbitrary a => CoArbitrary (Semigroup.Max a) where+  coarbitrary = coarbitrary . Semigroup.getMax -#if defined(MIN_VERSION_base)+instance CoArbitrary a => CoArbitrary (Semigroup.Min a) where+  coarbitrary = coarbitrary . Semigroup.getMin++instance CoArbitrary a => CoArbitrary (Semigroup.First a) where+  coarbitrary = coarbitrary . Semigroup.getFirst++instance CoArbitrary a => CoArbitrary (Semigroup.Last a) where+  coarbitrary = coarbitrary . Semigroup.getLast+ instance CoArbitrary Newline where   coarbitrary LF = variant 0   coarbitrary CRLF = variant 1  instance CoArbitrary NewlineMode where   coarbitrary (NewlineMode inNL outNL) = coarbitrary inNL . coarbitrary outNL++instance (CoArbitrary a, CoArbitrary b) => CoArbitrary (Semigroup.Arg a b) where+  coarbitrary (Semigroup.Arg a b) = coarbitrary (a, b)++instance CoArbitrary GeneralCategory where+  coarbitrary = coarbitrary . fromEnum++instance CoArbitrary SeekMode where+  coarbitrary = coarbitrary . fromEnum++instance CoArbitrary IOMode where+#if !defined(__MHS__)+  coarbitrary = coarbitrary . fromEnum+#else+  coarbitrary ReadMode = variant 0+  coarbitrary WriteMode = variant 1+  coarbitrary AppendMode = variant 2+  coarbitrary ReadWriteMode = variant 3 #endif++instance CoArbitrary FieldFormat where+  coarbitrary ff = coarbitrary (fmtWidth ff)+                 . coarbitrary (fmtPrecision ff)+                 . coarbitrary (fmtAdjust ff)+                 . coarbitrary (fmtSign ff)+                 . coarbitrary (fmtAlternate ff)+                 . coarbitrary (fmtModifiers ff)+                 . coarbitrary (fmtChar ff)++instance CoArbitrary FormatParse where+  coarbitrary fp = coarbitrary (fpModifiers fp)+                 . coarbitrary (fpChar fp)+                 . coarbitrary (fpRest fp)++instance CoArbitrary FormatAdjustment where+  coarbitrary LeftAdjust = coarbitrary True+  coarbitrary ZeroPad = coarbitrary False++instance CoArbitrary FormatSign where+  coarbitrary SignPlus = coarbitrary True+  coarbitrary SignSpace = coarbitrary False++instance CoArbitrary BufferMode where+  coarbitrary = coarbitrary . embed+    where embed NoBuffering = Left True+          embed LineBuffering = Left False+          embed (BlockBuffering m) = Right m++instance CoArbitrary ExitCode where+  coarbitrary = coarbitrary . embed+    where embed ExitSuccess = Nothing+          embed (ExitFailure i) = Just i++#if !defined(__MHS__)+instance CoArbitrary TextEncoding where+  coarbitrary = coarbitrary . show -- No other way as far as I can tell :(+#endif++instance CoArbitrary a => CoArbitrary (Semigroup.WrappedMonoid a) where+  coarbitrary = coarbitrary . Semigroup.unwrapMonoid++#endif++instance CoArbitrary Version where+  coarbitrary (Version a b) = coarbitrary (a, b)  -- ** Helpers for implementing coarbitrary 

@@ -0,0 +1,34 @@+-- This module provides tools to simplify compat code across different compiler and library versions+{-# LANGUAGE CPP #-}+module Test.QuickCheck.Compat where++#if MIN_VERSION_base(4,16,0)+import Data.Tuple+#endif++#if MIN_VERSION_base(4,16,0)++#if !MIN_VERSION_base(4,18,0)++getSolo :: Solo a -> a+getSolo (Solo a) = a++mkSolo :: a -> Solo a+mkSolo = Solo++#elif !MIN_VERSION_base(4,19,0)++getSolo :: Solo a -> a+getSolo (MkSolo a) = a++mkSolo :: a -> Solo a+mkSolo = MkSolo++#else++mkSolo :: a -> Solo a+mkSolo = MkSolo++#endif++#endif

@@ -86,11 +86,11 @@  -- | A variant of 'labelledExamples' that takes test arguments and returns a result. labelledExamplesWithResult :: Testable prop => Args -> prop -> IO Result-labelledExamplesWithResult args prop = loop Set.empty Nothing+labelledExamplesWithResult args prop = loop Set.empty $ replay args   where     loop :: Set String -> Maybe (QCGen, Int) -> IO Result     loop feats replay = withNullTerminal $ \nullterm -> do-      res <- quickCheckWithResult stdArgs{chatty = False, replay = replay} (prop_noNewFeatures feats prop)+      res <- quickCheckWithResult args{chatty = False, replay = replay} (prop_noNewFeatures feats prop)       let feats' = features (failingLabels res) (failingClasses res)       case res of         Failure{reason = "New feature found"} -> do

@@ -1,6 +1,6 @@ {-# LANGUAGE TypeOperators, GADTs, CPP, Rank2Types #-} #ifndef NO_SAFE_HASKELL-{-# LANGUAGE Safe #-}+{-# LANGUAGE Trustworthy #-} #endif #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 708 {-# LANGUAGE PatternSynonyms, ViewPatterns #-}@@ -84,7 +84,25 @@ import Data.Foldable(toList) import Data.Functor.Identity import qualified Data.Monoid as Monoid+import qualified Data.Semigroup as Semigroup+import qualified Data.List.NonEmpty as NonEmpty+import Numeric.Natural+import qualified Data.Bits as Bits+import Data.Tuple+import Data.Ord+import Data.Functor.Contravariant+import Text.Printf+import System.IO+import System.Exit+import Data.Version+import Data.Array.Byte+import qualified GHC.Exts as Exts +#if defined(__MHS__)+import Data.ZipList+import Control.WrappedMonad+#endif+ #if defined(MIN_VERSION_base) import System.IO   ( Newline(..)@@ -100,6 +118,8 @@ import GHC.Generics hiding (C) #endif +import Test.QuickCheck.Compat+ -------------------------------------------------------------------------- -- concrete functions @@ -267,6 +287,12 @@     h (Left _)       = []     h (Right (x,xs)) = x:xs +instance Function a => Function (NonEmpty.NonEmpty a) where+  function = functionMap (\(a NonEmpty.:| as) -> (a, as)) (\(a, as) -> a NonEmpty.:| as)++instance Function a => Function (ZipList a) where+  function = functionMap getZipList ZipList+ instance Function a => Function (Maybe a) where   function = functionMap g h    where@@ -315,6 +341,9 @@ instance Function Double where   function = functionRealFrac +instance Function Natural where+  function = functionIntegral+ -- instances for assorted types in the base package  instance Function Ordering where@@ -429,6 +458,110 @@  instance Function (f a) => Function (Monoid.Alt f a) where   function = functionMap Monoid.getAlt Monoid.Alt++instance Function a => Function (Semigroup.Min a) where+  function = functionMap Semigroup.getMin Semigroup.Min++instance Function a => Function (Semigroup.Max a) where+  function = functionMap Semigroup.getMax Semigroup.Max++instance Function a => Function (Semigroup.Last a) where+  function = functionMap Semigroup.getLast Semigroup.Last++instance Function a => Function (Semigroup.First a) where+  function = functionMap Semigroup.getFirst Semigroup.First++instance Function a => Function (Semigroup.WrappedMonoid a) where+  function = functionMap Semigroup.unwrapMonoid Semigroup.WrapMonoid++instance (Function a, Function b) => Function (Semigroup.Arg a b) where+  function = functionMap (\(Semigroup.Arg a b) -> (a, b)) (uncurry Semigroup.Arg)++#if MIN_VERSION_base(4,16,0)+instance Function a => Function (Bits.And a) where+  function = functionMap Bits.getAnd Bits.And++instance Function a => Function (Bits.Ior a) where+  function = functionMap Bits.getIor Bits.Ior++instance Function a => Function (Bits.Xor a) where+  function = functionMap Bits.getXor Bits.Xor++instance Function a => Function (Bits.Iff a) where+  function = functionMap Bits.getIff Bits.Iff+#endif++instance Function FormatSign where+  function = functionMap (\x -> case x of SignPlus -> True; _ -> False) (\b -> if b then SignPlus else SignSpace)++instance Function FormatAdjustment where+  function = functionMap (\x -> case x of LeftAdjust -> True; _ -> False) (\b -> if b then LeftAdjust else ZeroPad)++instance Function FormatParse where+  function = functionMap to from+    where to fp = (fpModifiers fp, fpChar fp, fpRest fp)+          from (a, b, c) = FormatParse a b c++instance Function FieldFormat where+  function = functionMap to from+    where to ff = ( fmtWidth ff+                  , fmtPrecision ff+                  , fmtAdjust ff+                  , fmtSign ff+                  , fmtAlternate ff+                  , fmtModifiers ff+                  , fmtChar ff)+          from (a, b, c, d, e, f, g) = FieldFormat a b c d e f g++instance Function GeneralCategory where+  function = functionBoundedEnum++instance Function SeekMode where+  function = functionElements [AbsoluteSeek, RelativeSeek, SeekFromEnd]++instance Function IOMode where+  function = functionElements [ReadMode, WriteMode, AppendMode, ReadWriteMode]++instance Function BufferMode where+  function = functionMap to from+    where to NoBuffering = Left True+          to LineBuffering = Left False+          to (BlockBuffering m) = Right m++          from (Left True) = NoBuffering+          from (Left False) = LineBuffering+          from (Right m)    = BlockBuffering m++instance Function ExitCode where+  function = functionMap to from+    where to ExitSuccess = Nothing+          to (ExitFailure c) = Just c++          from Nothing = ExitSuccess+          from (Just c) = ExitFailure c++instance Function Version where+  function = functionMap to from+    where to (Version a b) = (a, b)+          from (a, b) = Version a b++#if !defined(__MHS__)+instance Function ByteArray where+  function = functionMap Exts.toList Exts.fromList+#endif++#if MIN_VERSION_base(4,16,0)+instance Function a => Function (Solo a) where+  function = functionMap getSolo mkSolo+#endif++instance Function a => Function (Down a) where+  function = functionMap getDown Down++#if !MIN_VERSION_base(4,15,0)+instance Function a => Function (Semigroup.Option a) where+  function = functionMap Semigroup.getOption Semigroup.Option+#endif  -- poly instances 

@@ -165,14 +165,13 @@ instance Functor NonEmptyList where   fmap f (NonEmpty x) = NonEmpty (map f x) -instance Arbitrary a => Arbitrary (NonEmptyList a) where-  arbitrary = NonEmpty `fmap` (arbitrary `suchThat` (not . null))+instance Arbitrary1 NonEmptyList where+  liftArbitrary = fmap NonEmpty . listOf1+  liftShrink shr = map NonEmpty . filter (not . null) . shrinkList shr . getNonEmpty -  shrink (NonEmpty xs) =-    [ NonEmpty xs'-    | xs' <- shrink xs-    , not (null xs')-    ]+instance Arbitrary a => Arbitrary (NonEmptyList a) where+  arbitrary = arbitrary1+  shrink = shrink1  ---------------------------------------------------------------------- -- | @InfiniteList xs _@: guarantees that xs is an infinite list.

@@ -523,8 +523,19 @@ -- > quickCheck (withMaxSuccess 1000 p) -- -- will test @p@ up to 1000 times.+{-# DEPRECATED withMaxSuccess "Use withNumTests instead" #-} withMaxSuccess :: Testable prop => Int -> prop -> Property-withMaxSuccess n = n `seq` mapTotalResult (\res -> res{ maybeNumTests = Just n })+withMaxSuccess = withNumTests++-- | Configures how many times a property will be tested.+--+-- For example,+--+-- > quickCheck (withNumTests 1000 p)+--+-- will test @p@ up to 1000 times.+withNumTests :: Testable prop => Int -> prop -> Property+withNumTests n = n `seq` mapTotalResult (\res -> res{ maybeNumTests = Just n })  -- | Configures how many times a property is allowed to be discarded before failing. --

@@ -179,7 +179,7 @@ -- | Tests a property and prints the results to 'System.IO.stdout'. -- -- By default up to 100 tests are performed, which may not be enough--- to find all bugs. To run more tests, use 'withMaxSuccess'.+-- to find all bugs. To run more tests, use 'withNumTests'. -- -- If you want to get the counterexample as a Haskell value, -- rather than just printing it, try the

@@ -1,4 +1,4 @@-{-# LANGUAGE TemplateHaskell, RecordWildCards, DeriveLift, TupleSections, CPP #-}+{-# LANGUAGE TemplateHaskell, RecordWildCards, DeriveLift, TupleSections, CPP, TypeOperators #-} module CollectDataTypes where  import Language.Haskell.TH@@ -16,6 +16,8 @@ import Data.Either import Data.Char import Data.Function+import Test.QuickCheck+import Test.QuickCheck.Function  data DataType =   DataType {@@ -88,11 +90,17 @@       Just arity -> do         Just name <- lookupTypeName (haskellName dt)         Just int <- lookupTypeName "Int"-        Just gen <- lookupTypeName "Gen"         nm <- newName ("prop_" ++ filter isAlphaNum (haskellName dt))+        nmCo <- newName ("prop_co_" ++ filter isAlphaNum (haskellName dt))+        nmFunction <- newName ("prop_function_" ++ filter isAlphaNum (haskellName dt))         let propName = pure $ VarP nm-        let ty = pure $ AppT (ConT gen) $ foldl AppT (ConT name) $ replicate arity (ConT int)-        map (nm,) <$> [d| $propName = forAllBlind (arbitrary :: $ty) (\ x -> x `seq` True) |]+        let propNameCo = pure $ VarP nmCo+        let propNameFunction = pure $ VarP nmFunction+        let ty = pure $ foldl AppT (ConT name) $ replicate arity (ConT int)+        dArbitrary <- map (nm,) <$> [d| $propName = forAllBlind (arbitrary :: Gen $ty) (\ x -> x `seq` True) |]+        dCoArbitrary <- map (nmCo,) <$> [d| $propNameCo = forAllBlind (arbitrary :: Gen ($ty -> Integer)) (\ x -> x `seq` True) |]+        dFunction <- map (nmFunction,) <$> [d| $propNameFunction = forAllBlind (arbitrary :: Gen ($ty :-> Integer)) (\ x -> x `seq` True) |]+        return $ dArbitrary ++ dCoArbitrary ++ dFunction  typeBlacklist :: [String] typeBlacklist = [ "Prelude.IO"@@ -118,6 +126,8 @@                 , "System.IO.Handle"                 , "Text.Printf.FieldFormatter" -- This is a function type and it                                                -- requires an annoying coarbitrary instance+                , "Text.Printf.ModifierParser"+                , "Text.Show.ShowS"                 ] ++                 -- These are phantom types used for indexing                 [ "Data.Fixed.E" ++ show i | i <- [0,1,2,3,6,9,12] ] ++@@ -126,9 +136,20 @@                 [ "Data.Semigroup.Option" ] ++ #endif                 -- TODO: Some controversial ones?-                [ "System.IO.Error.IOErrorType" ]+                [ "System.IO.Error.IOErrorType" ] +++                -- Some higher order types we ignore for the sake of CoArbitrary and Function issues+                [ "System.Console.GetOpt.OptDescr"+                , "System.Console.GetOpt.ArgOrder"+                , "System.Console.GetOpt.ArgDescr"+                ] +++                -- System specific and, likewise, not easily doable in Function+                [ "System.IO.TextEncoding" ] +++                -- Ignored for `Function` because the test monomorphises to `Int`. fixme.+                [ "Data.Complex.Complex" ]  ++ modulePrefixBlacklist :: [String] modulePrefixBlacklist = [ "GHC"                         , "Foreign"@@ -169,6 +190,9 @@                         -- useful work you can do with it and it should be OK                         -- not to provide instances for it                         , "Text.ParserCombinators.ReadP"+                        -- Slightly controversial, but this is only ignored for+                        -- the sake of CoArbitrary and Function+                        , "Data.Functor.Contravariant"                         ]  isValidModule :: String -> Bool

@@ -17,7 +17,7 @@  prop_coarbitrary (Fun _ f) =   expectFailure $-  withMaxSuccess 1000 $+  withNumTests 1000 $   f (C1 (2::Int)) `elem` [0, 1 :: Int]  return []

@@ -29,7 +29,7 @@ path p (Path xs) = all p xs  somePath :: (a -> Bool) -> Path a -> Property-somePath p = expectFailure . withMaxSuccess 1000 . path (not . p)+somePath p = expectFailure . withNumTests 1000 . path (not . p)  newtype Extremal a = Extremal { getExtremal :: a } deriving (Show, Eq, Ord, Num, Enum, Real, Integral) @@ -139,7 +139,7 @@  reachesBound :: (Bounded a, Integral a, Arbitrary a) =>   a -> Property-reachesBound x = withMaxSuccess 1000 (expectFailure (x < 3 * (maxBound `div` 4)))+reachesBound x = withNumTests 1000 (expectFailure (x < 3 * (maxBound `div` 4)))  prop_reachesBound_Int8 = reachesBound :: Int8 -> Property prop_reachesBound_Int16 = reachesBound :: Int16 -> Property

@@ -26,7 +26,7 @@ prop_maxSize = withMaxSize 10 (forAll (arbitrary :: Gen Int) $ \ x -> abs x < 10)  prop_cover :: Property-prop_cover = withMaxSuccess 1000+prop_cover = withNumTests 1000            $ checkCoverage            $ forAll (arbitrary :: Gen Int)            $ \ x -> cover 5 (x > 0) "positive" True

@@ -142,5 +142,5 @@ prop_some_mconcat_law = check_mconcat_law  return []-main = $quickCheckAll+main = do True <- $quickCheckAll; return () 

@@ -63,7 +63,7 @@ -- * Anything written to stderr (presumably by putTemp) is erased prop_terminal :: [Command] -> Property prop_terminal cmds =-  withMaxSuccess 1000 $ ioProperty $+  withNumTests 1000 $ ioProperty $   withPipe $ \stdout_read stdout_write ->   withPipe $ \stderr_read stderr_write -> do     out <- withHandleTerminal stdout_write (Just stderr_write) $ \tm -> do