quickcheck-groups: Testing group class instances with QuickCheck

[ apache, library, testing ] [ Propose Tags ]

QuickCheck support for testing instances of type classes defined in the groups library.


[Skip to Readme]

Modules

[Index] [Quick Jump]

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

  • No Candidates
Versions [RSS] 0.0.0.0, 0.0.1.0, 0.0.1.1
Change log CHANGELOG.md
Dependencies base (>=4.14.3.0 && <4.20), groups (>=0.5.3 && <0.6), pretty-show (>=1.10 && <1.11), QuickCheck (>=2.14.2 && <2.15), quickcheck-classes (>=0.6.5.0 && <0.7), quickcheck-groups, quickcheck-instances (>=0.3.28 && <0.4), semigroupoids (>=5.3.7 && <6.1) [details]
License Apache-2.0
Copyright 2022–2023 Jonathan Knowles
Author Jonathan Knowles
Maintainer mail@jonathanknowles.net
Category Testing
Bug tracker https://github.com/jonathanknowles/quickcheck-groups/issues
Source repo head: git clone https://github.com/jonathanknowles/quickcheck-groups
Uploaded by JonathanKnowles at 2023-12-23T06:08:56Z
Distributions LTSHaskell:0.0.1.1, NixOS:0.0.1.1, Stackage:0.0.1.1
Downloads 284 total (26 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2023-12-23 [all 1 reports]

Readme for quickcheck-groups-0.0.1.1

[back to package description]

quickcheck-groups

Overview

The quickcheck-groups library provides:

  • QuickCheck support for testing instances of type classes defined in the groups library.
  • Compatibility with the quickcheck-classes library.
  • Reusable properties for type class laws, in the form of Laws definitions.

Usage

In general, usage is identical to that of the quickcheck-classes library. If you're already familiar with quickcheck-classes, then using this library should be straightforward.

Testing laws for a single type class

To test that the laws of a particular class hold for a particular type, use the lawsCheck function with the Laws definition for the class you wish to test.

🌠 Example

To test that the Group laws hold for the Sum Integer type:

import Data.Monoid (Sum)
import Data.Proxy (Proxy (Proxy))
import Test.QuickCheck.Classes (lawsCheck)
import Test.QuickCheck.Classes.Group (groupLaws)

lawsCheck (groupLaws (Proxy :: Proxy (Sum Integer)))

If all tests pass, you should see output similar to:

Group: groupLaw_invert_mempty    +++ OK, passed 1 test.
Group: groupLaw_invert_invert    +++ OK, passed 100 tests.
Group: groupLaw_invert_mappend_1 +++ OK, passed 100 tests.
Group: groupLaw_invert_mappend_2 +++ OK, passed 100 tests.
Group: groupLaw_subtract_mempty  +++ OK, passed 100 tests.
Group: groupLaw_subtract_self    +++ OK, passed 100 tests.
Group: groupLaw_subtract_other   +++ OK, passed 100 tests.
Group: groupLaw_pow_zero         +++ OK, passed 100 tests.
Group: groupLaw_pow_nonNegative  +++ OK, passed 100 tests.
Group: groupLaw_pow_nonPositive  +++ OK, passed 100 tests.

Testing laws for multiple type classes

To test that the laws of multiple classes hold for a particular type, use the lawsCheckOne function with the Laws definitions for the classes you wish to test.

🌠 Example

To test that the Sum Integer type satisfies the laws of Abelian and all superclasses:

import Data.Monoid (Sum)
import Data.Proxy (Proxy (Proxy))
import Test.QuickCheck.Classes
import Test.QuickCheck.Classes.Group

lawsCheckOne (Proxy :: Proxy (Sum Integer))
    [ semigroupLaws
    , monoidLaws
    , groupLaws
    , abelianLaws
    ]

Subclasses and superclasses

Each of the Laws definitions provided by this library corresponds to exactly one type class, and includes just the laws for that class. Laws for subclasses and superclasses are not automatically included. Therefore, you'll need to explicitly test the laws of every single class you wish to cover.

Coverage checks

This library includes coverage checks to ensure that important cases are covered, and to reduce the probability of test passes that are false positives. These coverage checks are performed automatically.