Hedgehog is a property-based testing system, in the spirit of QuickCheck. Hedgehog uses integrated shrinking, so shrinks obey the invariants of generated values by construction.

To get started quickly, see the examples: https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example

To properly work, the doctest package needs plenty of configuration. This library provides the common bits for writing custom Setup.hs files.

Tasty-th automatically generates tasty TestTrees from functions of the current module, using TemplateHaskell. This is a fork the original test-framework-th package, modified to work with tasty instead of test-framework.

HUnit is a unit testing framework for Haskell, inspired by the JUnit tool for Java.

This package provides SmallCheck support for the Tasty Haskell test framework.

This package provides a Tasty provider for Hspec test suites.

This package adds the ability to run tests by filtering the test tree based on the result of a previous test run. You can use this to run only those tests that failed in the last run, or to only run the tests that have been added since previous test run.

This package lets programmers use SmallCheck properties in Haskell's test-framework. New projects should use ghc-tasty-smallcheck instead.

Some carefully crafted libraries make promises to their users beyond functionality and performance.

Examples are: Fusion libraries promise intermediate data structures to be eliminated. Generic programming libraries promise that the generic implementation is identical to the hand-written one. Some libraries may promise allocation-free or branch-free code.

Conventionally, the modus operandi in all these cases is that the library author manually inspects the (intermediate or final) code produced by the compiler. This is not only tedious, but makes it very likely that some change, either in the library itself or the surrounding eco-system, breaks the library's promised without anyone noticing.

This package provides a disciplined way of specifying such properties, and have them checked by the compiler. This way, this checking can be part of the regular development cycle and regressions caught early.

See the documentation in "Test.Inspection" or the project webpage for more examples and more information.

This package provides an orphan instance that allows you to use HUnit assertions as QuickCheck properties.

This package provides QuickCheck instances for types provided by the Haskell Platform.

This library provides catchy combinators for HUnit, see the README.

Feat (Functional Enumeration of Algebraic Types) provides enumerations as functions from natural numbers to values (similar to toEnum but for any algebraic data type). This can be used for SmallCheck-style systematic testing, QuickCheck-style random testing, and hybrids of the two.

This package provides a fancy test runner and support for golden testing. A golden test is an IO action that writes its result to a file. To pass the test, this output file should be identical to the corresponding ``golden'' file, which contains the correct result for the test. The test runner allows filtering tests using regexes, and to interactively inspect the result of golden tests.

This library exposes internal types and functions that can be used to extend Hspec's functionality.

Tasty is a modern testing framework for Haskell. It lets you combine your unit tests, golden tests, QuickCheck/SmallCheck properties, and any other types of tests into a single test suite.

This package provides QuickCheck support for the Tasty Haskell test framework.

This Haskell library provides convenient assertions with pretty-printed failure messages for QuickCheck properties, that are similar to those of HUnit.

This package provides HUnit support for the Tasty Haskell test framework.

With the function Test.Tasty.ExpectedFailure.expectFail in the provided module Test.Tasty.ExpectedFailure, you can mark that you expect test cases to fail, and not to pass. This can be used for test-driven development.

This library is a minimal variant of `quickcheck-classes` that only provides laws for typeclasses from `base`. The main purpose of splitting this out is so that `primitive` can depend on `quickcheck-classes-base` in its test suite, avoiding the circular dependency that arises if `quickcheck-classes` is used instead. This library provides QuickCheck properties to ensure that typeclass instances adhere to the set of laws that they are supposed to. There are other libraries that do similar things, such as `genvalidity-hspec` and `checkers`. This library differs from other solutions by not introducing any new typeclasses that the user needs to learn. Note: on GHC < 8.5, this library uses the higher-kinded typeclasses (Data.Functor.Classes.Show1, Data.Functor.Classes.Eq1, Data.Functor.Classes.Ord1, etc.), but on GHC >= 8.5, it uses `-XQuantifiedConstraints` to express these constraints more cleanly.

This package allows on to run Doctests in a Cabal.Test.exitcode-stdio environment.

This package provides a Known Answer Tests (KAT) framework for tasty.

This module provides Haskell bindings and extensions to the curve25519-donna codebase. It's a pretty straightforward implementation of the basic cryptographic routines you'd want from a project that uses curve25519: key generation, and key agreement. For further functionality, you'll want to look elsewhere.