diff --git a/QuickCheck.cabal b/QuickCheck.cabal --- a/QuickCheck.cabal +++ b/QuickCheck.cabal @@ -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 Maintainer: Nick Smallbone 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, diff --git a/changelog b/changelog deleted file mode 100644 --- a/changelog +++ /dev/null @@ -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. diff --git a/changelog.md b/changelog.md new file mode 100644 --- /dev/null +++ b/changelog.md @@ -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. diff --git a/examples/Heap.hs b/examples/Heap.hs --- a/examples/Heap.hs +++ b/examples/Heap.hs @@ -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. diff --git a/examples/Heap_Program.hs b/examples/Heap_Program.hs --- a/examples/Heap_Program.hs +++ b/examples/Heap_Program.hs @@ -187,7 +187,7 @@ -- main return [] -main = $(quickCheckAll) +main = do True <- $quickCheckAll; return () -------------------------------------------------------------------------- -- the end. diff --git a/examples/Heap_ProgramAlgebraic.hs b/examples/Heap_ProgramAlgebraic.hs --- a/examples/Heap_ProgramAlgebraic.hs +++ b/examples/Heap_ProgramAlgebraic.hs @@ -245,7 +245,7 @@ -- main return [] -main = $(quickCheckAll) +main = do True <- $quickCheckAll; return () -------------------------------------------------------------------------- -- the end. diff --git a/examples/Merge.hs b/examples/Merge.hs --- a/examples/Merge.hs +++ b/examples/Merge.hs @@ -110,7 +110,7 @@ -- mapSize (`div` 2) $ \(xss :: [OrderedList Int]) -> return [] -main = $quickCheckAll +main = do True <- $quickCheckAll; return () -------------------------------------------------------------------------- -- the end. diff --git a/examples/Set.hs b/examples/Set.hs --- a/examples/Set.hs +++ b/examples/Set.hs @@ -201,7 +201,7 @@ -- main return [] -main = $quickCheckAll +main = do True <- $quickCheckAll; return () -------------------------------------------------------------------------- -- the end. diff --git a/examples/Simple.hs b/examples/Simple.hs --- a/examples/Simple.hs +++ b/examples/Simple.hs @@ -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. diff --git a/src/Test/QuickCheck.hs b/src/Test/QuickCheck.hs --- a/src/Test/QuickCheck.hs +++ b/src/Test/QuickCheck.hs @@ -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 diff --git a/src/Test/QuickCheck/Arbitrary.hs b/src/Test/QuickCheck/Arbitrary.hs --- a/src/Test/QuickCheck/Arbitrary.hs +++ b/src/Test/QuickCheck/Arbitrary.hs @@ -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 diff --git a/src/Test/QuickCheck/Compat.hs b/src/Test/QuickCheck/Compat.hs new file mode 100644 --- /dev/null +++ b/src/Test/QuickCheck/Compat.hs @@ -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 diff --git a/src/Test/QuickCheck/Features.hs b/src/Test/QuickCheck/Features.hs --- a/src/Test/QuickCheck/Features.hs +++ b/src/Test/QuickCheck/Features.hs @@ -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 diff --git a/src/Test/QuickCheck/Function.hs b/src/Test/QuickCheck/Function.hs --- a/src/Test/QuickCheck/Function.hs +++ b/src/Test/QuickCheck/Function.hs @@ -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 diff --git a/src/Test/QuickCheck/Modifiers.hs b/src/Test/QuickCheck/Modifiers.hs --- a/src/Test/QuickCheck/Modifiers.hs +++ b/src/Test/QuickCheck/Modifiers.hs @@ -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. diff --git a/src/Test/QuickCheck/Property.hs b/src/Test/QuickCheck/Property.hs --- a/src/Test/QuickCheck/Property.hs +++ b/src/Test/QuickCheck/Property.hs @@ -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. -- diff --git a/src/Test/QuickCheck/Test.hs b/src/Test/QuickCheck/Test.hs --- a/src/Test/QuickCheck/Test.hs +++ b/src/Test/QuickCheck/Test.hs @@ -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 diff --git a/tests/CollectDataTypes.hs b/tests/CollectDataTypes.hs --- a/tests/CollectDataTypes.hs +++ b/tests/CollectDataTypes.hs @@ -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 diff --git a/tests/GCoArbitraryExample.hs b/tests/GCoArbitraryExample.hs --- a/tests/GCoArbitraryExample.hs +++ b/tests/GCoArbitraryExample.hs @@ -17,7 +17,7 @@ prop_coarbitrary (Fun _ f) = expectFailure $ - withMaxSuccess 1000 $ + withNumTests 1000 $ f (C1 (2::Int)) `elem` [0, 1 :: Int] return [] diff --git a/tests/Generators.hs b/tests/Generators.hs --- a/tests/Generators.hs +++ b/tests/Generators.hs @@ -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 diff --git a/tests/Misc.hs b/tests/Misc.hs --- a/tests/Misc.hs +++ b/tests/Misc.hs @@ -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 diff --git a/tests/Monoids.hs b/tests/Monoids.hs --- a/tests/Monoids.hs +++ b/tests/Monoids.hs @@ -142,5 +142,5 @@ prop_some_mconcat_law = check_mconcat_law return [] -main = $quickCheckAll +main = do True <- $quickCheckAll; return () diff --git a/tests/Terminal.hs b/tests/Terminal.hs --- a/tests/Terminal.hs +++ b/tests/Terminal.hs @@ -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