-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | QuickCheck common typeclasses -- -- This library provides quickcheck properties to ensure that typeclass -- instances 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. @package quickcheck-classes @version 0.4.6 -- | This library provides lists of properties that should hold for common -- typeclasses. All of these take a Proxy argument that is used to -- nail down the type for which the typeclass dictionaries should be -- tested. For example, at GHCi: -- --

--   >>> lawsCheck (monoidLaws (Proxy :: Proxy Ordering))
--   Monoid: Associative +++ OK, passed 100 tests.
--   Monoid: Left Identity +++ OK, passed 100 tests.
--   Monoid: Right Identity +++ OK, passed 100 tests.
--

-- -- Assuming that the Arbitrary instance for Ordering is -- good, we now have confidence that the Monoid instance for -- Ordering satisfies the monoid laws. We can check multiple -- typeclasses with: -- --

--   >>> foldMap (lawsCheck . ($ (Proxy :: Proxy Word))) [jsonLaws,showReadLaws]
--   ToJSON/FromJSON: Encoding Equals Value +++ OK, passed 100 tests.
--   ToJSON/FromJSON: Partial Isomorphism +++ OK, passed 100 tests.
--   Show/Read: Partial Isomorphism +++ OK, passed 100 tests.
--

module Test.QuickCheck.Classes -- | A convenience function for working testing properties in GHCi. See the -- test suite of this library for an example of how to integrate multiple -- properties into larger test suite. lawsCheck :: Laws -> IO () -- | A convenience function for checking multiple typeclass instances of -- multiple types. lawsCheckMany :: [(String, [Laws])] -> IO () -- | Tests everything from monoidProps plus the following: -- --

Commutative mappend a b ≡ mappend b a

commutativeMonoidLaws :: (Monoid a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws -- | Tests the following properties: -- --

Transitive a == b ∧ b == c ⇒ a == c
Symmetric a == b ⇒ b == a
Reflexive a == a

-- -- Some of these properties involve implication. In the case that the -- left hand side of the implication arrow does not hold, we do not -- retry. Consequently, these properties only end up being useful when -- the data type has a small number of inhabitants. eqLaws :: (Eq a, Arbitrary a, Show a) => Proxy a -> Laws -- | Tests the following properties: -- --

Antisymmetry @a ≤ b ∧ b ≤ a ⇒ a = b
Transitivity a ≤ b ∧ b ≤ c ⇒ a ≤ c
Totality a ≤ b ∨ a > b

ordLaws :: (Ord a, Arbitrary a, Show a) => Proxy a -> Laws showReadLaws :: (Show a, Read a, Eq a, Arbitrary a) => Proxy a -> Laws -- | Tests the following properties: -- --

Partial Isomorphism decode . encode ≡ -- Just
Encoding Equals Value decode . encode ≡ Just . -- toJSON

-- -- Note that in the second propertiy, the type of decode is -- ByteString -> Value, not ByteString -> a jsonLaws :: (ToJSON a, FromJSON a, Show a, Arbitrary a, Eq a) => Proxy a -> Laws -- | Tests the following properties: -- --

Quotient Remainder (quot x y) * y + (rem x y) ≡ -- x
Division Modulus (div x y) * y + (mod x y) ≡ -- x
Integer Roundtrip fromInteger (toInteger x) ≡ -- x

integralLaws :: (Integral a, Arbitrary a, Show a) => Proxy a -> Laws -- | Tests the following properties: -- --

Associative mappend a (mappend b c) ≡ mappend -- (mappend a b) c
Left Identity mappend mempty a ≡ a
Right Identity mappend a mempty ≡ a

monoidLaws :: (Monoid a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws -- | Tests the following properties: -- --

Antisymmetry @a ≤ b ∧ b ≤ a ⇒ a = b
Transitivity a ≤ b ∧ b ≤ c ⇒ a ≤ c
Totality a ≤ b ∨ a > b

ordLaws :: (Ord a, Arbitrary a, Show a) => Proxy a -> Laws -- | Test that a Prim instance obey the several laws. primLaws :: (Prim a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws -- | Tests the following properties: -- --

Associative a <> (b <> c) ≡ (a -- <> b) <> c

semigroupLaws :: (Semigroup a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws showReadLaws :: (Show a, Read a, Eq a, Arbitrary a) => Proxy a -> Laws storableLaws :: (Storable a, Eq a, Arbitrary a, Show a) => Proxy a -> Laws -- | Tests the following properties: -- --

Quotient Remainder (quot x y) * y + (rem x y) ≡ -- x
Division Modulus (div x y) * y + (mod x y) ≡ -- x
Integer Roundtrip fromInteger (toInteger x) ≡ -- x

integralLaws :: (Integral a, Arbitrary a, Show a) => Proxy a -> Laws -- | Tests the following properties: -- --

Conjunction Idempotence n .&. n ≡ -- n
Disjunction Idempotence n .|. n ≡ n
Double Complement complement (complement n) ≡ -- n
Set Bit setBit n i ≡ n .|. bit i
Clear Bit clearBit n i ≡ n .&. complement -- (bit i)
Complement Bit complementBit n i ≡ xor n (bit -- i)
Clear Zero clearBit zeroBits i ≡ -- zeroBits
Set Zero setBit zeroBits i ≡ bit i
Test Zero testBit zeroBits i ≡ False
Pop Zero popCount zeroBits ≡ 0
Count Leading Zeros of Zero countLeadingZeros -- zeroBits ≡ finiteBitSize ⊥
Count Trailing Zeros of Zero countTrailingZeros -- zeroBits ≡ finiteBitSize ⊥

-- -- All of the useful instances of the Bits typeclass also have -- FiniteBits instances, so these property tests actually require -- that instance as well. -- -- Note: This property test is only available when using -- base-4.7 or newer. bitsLaws :: (FiniteBits a, Arbitrary a, Show a) => Proxy a -> Laws -- | Tests the following properties: -- --

Partial Isomorphism fromList . toList ≡ -- id
Length Preservation fromList xs ≡ fromListN -- (length xs) xs

-- -- Note: This property test is only available when using -- base-4.7 or newer. isListLaws :: (IsList a, Show a, Show (Item a), Arbitrary a, Arbitrary (Item a), Eq a) => Proxy a -> Laws -- | Tests the following alt properties: -- --

Associativity (a <!> b) -- <!> c ≡ a <!> (b <!> -- c)
Left Distributivity @f <$> (a -- <!> b) = (f <$> a) <!> (f -- <$> b)

altLaws :: (Alt f, Eq1 f, Show1 f, Arbitrary1 f) => proxy f -> Laws -- | Tests the following alternative properties: -- --

Identity empty <|> x ≡ -- x x <|> empty ≡ x
Associativity a <|> (b -- <|> c) ≡ (a <|> b) <|> -- c)

alternativeLaws :: (Alternative f, Eq1 f, Show1 f, Arbitrary1 f) => proxy f -> Laws -- | Tests the following applicative properties: -- --

Identity pure id <*> -- v ≡ v
Composition pure (.) <*> u -- <*> v <*> w ≡ u <*> (v -- <*> w)
Homomorphism pure f <*> -- pure x ≡ pure (f x)
Interchange u <*> pure y ≡ -- pure ($ y) <*> u
LiftA2 (1) (<*>) ≡ liftA2 -- id

applicativeLaws :: (Applicative f, Eq1 f, Show1 f, Arbitrary1 f) => proxy f -> Laws -- | Tests the following Foldable properties: -- --

fold fold ≡ foldMap -- id
foldMap foldMap f ≡ foldr -- (mappend . f) mempty
foldr foldr f z t ≡ appEndo -- (foldMap (Endo . f) t ) z
foldr' foldr' f z0 xs = let f' k x z = -- k $! f x z in foldl f' id xs z0
foldr1 foldr1 f t ≡ let Just (xs,x) = -- unsnoc (toList t) in foldr f x xs
foldl foldl f z t ≡ appEndo -- (getDual (foldMap (Dual . Endo . -- flip f) t)) z
foldl' foldl' f z0 xs ≡ let f' x k z = -- k $! f z x in foldr f' id xs z0
foldl1 foldl1 f t ≡ let x : xs = -- toList t in foldl f x xs
toList toList ≡ foldr (:) -- []
null null ≡ foldr (const -- (const False)) True
length length ≡ getSum . foldMap -- (const (Sum 1))

-- -- Note that this checks to ensure that foldl' and -- foldr' are suitably strict. foldableLaws :: (Foldable f, Eq1 f, Show1 f, Arbitrary1 f) => proxy f -> Laws -- | Tests the following Traversable properties: -- --

Naturality t . traverse f = -- traverse (t . f) for every applicative transformation -- t
Identity traverse Identity = -- Identity
Composition traverse (Compose . -- fmap g . f) = Compose . fmap (traverse g) . -- traverse f
Sequence Naturality t . sequenceA = -- sequenceA . fmap t for every applicative -- transformation t
Sequence Identity sequenceA . fmap -- Identity = Identity
Sequence Composition sequenceA . -- fmap Compose = Compose . fmap sequenceA . -- sequenceA
foldMap foldMap = -- foldMapDefault
fmap fmap = fmapDefault

-- -- Where an applicative transformation is a function -- --

--   t :: (Applicative f, Applicative g) => f a -> g a
--

-- -- preserving the Applicative operations, i.e. -- --

Identity: t (pure x) = pure x
Distributivity: t (x <*> y) = t x -- <*> t y

traversableLaws :: (Traversable f, Eq1 f, Show1 f, Arbitrary1 f) => proxy f -> Laws -- | Tests the following functor properties: -- --

Identity fmap id ≡ -- id
Composition fmap (f . g) ≡ fmap f . -- fmap g
Const (<$) ≡ fmap -- const

functorLaws :: (Functor f, Eq1 f, Show1 f, Arbitrary1 f) => proxy f -> Laws -- | Tests the following monadic properties: -- --

Left Identity return a >>= k -- ≡ k a
Right Identity m >>= return -- ≡ m
Associativity m >>= (\x -> k x -- >>= h) ≡ (m >>= k) >>= -- h
Return pure ≡ return
Ap (<*>) ≡ ap

monadLaws :: (Monad f, Applicative f, Eq1 f, Show1 f, Arbitrary1 f) => proxy f -> Laws -- | Tests the following monad plus properties: -- --

Left Identity mplus empty x ≡ -- x
Right Identity mplus x empty ≡ -- x
Associativity mplus a (mplus b c) -- ≡ mplus (mplus a b) c)
Left Zero mzero >>= f ≡ -- mzero
Right Zero m >> mzero ≡ -- mzero

monadPlusLaws :: (MonadPlus f, Eq1 f, Show1 f, Arbitrary1 f) => proxy f -> Laws -- | Tests the following monadic zipping properties: -- --

Naturality liftM (f *** g) (mzip ma mb) = mzip -- (liftM f ma) (liftM g mb)

-- -- In the laws above, the infix function *** refers to a -- typeclass method of Arrow. monadZipLaws :: (MonadZip f, Applicative f, Eq1 f, Show1 f, Arbitrary1 f) => proxy f -> Laws -- | Tests the following Bifunctor properties: -- --

Identity bimap id id ≡ -- id
First Identity first id ≡ -- id
Second Identity second id ≡ -- id
Bifunctor Composition bimap f g ≡ -- first f . second g

-- -- Note: This property test is only available when this package is -- built with base-4.9+ or transformers-0.5+. bifunctorLaws :: (Bifunctor f, Eq2 f, Show2 f, Arbitrary2 f) => proxy f -> Laws -- | A set of laws associated with a typeclass. data Laws Laws :: String -> [(String, Property)] -> Laws -- | Name of the typeclass whose laws are tested [lawsTypeclass] :: Laws -> String -- | Pairs of law name and property [lawsProperties] :: Laws -> [(String, Property)] instance GHC.Classes.Eq Test.QuickCheck.Classes.EquationTwo instance GHC.Classes.Eq Test.QuickCheck.Classes.Equation instance GHC.Classes.Eq Test.QuickCheck.Classes.LinearEquation instance GHC.Classes.Eq a => GHC.Classes.Eq (Test.QuickCheck.Classes.Bottom a) instance GHC.Classes.Eq Test.QuickCheck.Classes.LastNothing instance GHC.Classes.Eq Test.QuickCheck.Classes.ChooseFirst instance GHC.Classes.Eq Test.QuickCheck.Classes.ChooseSecond instance GHC.Classes.Eq a => GHC.Classes.Eq (Test.QuickCheck.Classes.Triple a) instance GHC.Show.Show a => GHC.Show.Show (Test.QuickCheck.Classes.Triple a) instance (GHC.Classes.Eq a, Data.Primitive.Types.Prim a) => GHC.Classes.Eq (Test.QuickCheck.Classes.PrimArray a) instance Data.Primitive.Types.Prim a => GHC.Exts.IsList (Test.QuickCheck.Classes.PrimArray a) instance Data.Bits.FiniteBits a => Test.QuickCheck.Arbitrary.Arbitrary (Test.QuickCheck.Classes.BitIndex a) instance GHC.Show.Show Test.QuickCheck.Classes.EquationTwo instance Test.QuickCheck.Arbitrary.Arbitrary Test.QuickCheck.Classes.EquationTwo instance GHC.Show.Show Test.QuickCheck.Classes.Equation instance Test.QuickCheck.Arbitrary.Arbitrary Test.QuickCheck.Classes.Equation instance Data.Functor.Classes.Eq1 m => GHC.Classes.Eq (Test.QuickCheck.Classes.LinearEquationM m) instance Data.Functor.Classes.Show1 m => GHC.Show.Show (Test.QuickCheck.Classes.LinearEquationM m) instance Test.QuickCheck.Arbitrary.Arbitrary1 m => Test.QuickCheck.Arbitrary.Arbitrary (Test.QuickCheck.Classes.LinearEquationM m) instance GHC.Show.Show Test.QuickCheck.Classes.LinearEquation instance Test.QuickCheck.Arbitrary.Arbitrary Test.QuickCheck.Classes.LinearEquation instance (Data.Functor.Classes.Eq2 f, GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (Test.QuickCheck.Classes.Apply2 f a b) instance (Data.Functor.Classes.Show2 f, GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Test.QuickCheck.Classes.Apply2 f a b) instance (Test.QuickCheck.Arbitrary.Arbitrary2 f, Test.QuickCheck.Arbitrary.Arbitrary a, Test.QuickCheck.Arbitrary.Arbitrary b) => Test.QuickCheck.Arbitrary.Arbitrary (Test.QuickCheck.Classes.Apply2 f a b) instance (Data.Functor.Classes.Eq1 f, GHC.Classes.Eq a) => GHC.Classes.Eq (Test.QuickCheck.Classes.Apply f a) instance (GHC.Base.Applicative f, GHC.Base.Monoid a) => Data.Semigroup.Semigroup (Test.QuickCheck.Classes.Apply f a) instance (GHC.Base.Applicative f, GHC.Base.Monoid a) => GHC.Base.Monoid (Test.QuickCheck.Classes.Apply f a) instance (Data.Functor.Classes.Show1 f, GHC.Show.Show a) => GHC.Show.Show (Test.QuickCheck.Classes.Apply f a) instance (Test.QuickCheck.Arbitrary.Arbitrary1 f, Test.QuickCheck.Arbitrary.Arbitrary a) => Test.QuickCheck.Arbitrary.Arbitrary (Test.QuickCheck.Classes.Apply f a) instance GHC.Show.Show a => GHC.Show.Show (Test.QuickCheck.Classes.Bottom a) instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Test.QuickCheck.Classes.Bottom a) instance GHC.Show.Show Test.QuickCheck.Classes.LastNothing instance Test.QuickCheck.Arbitrary.Arbitrary Test.QuickCheck.Classes.LastNothing instance GHC.Show.Show Test.QuickCheck.Classes.ChooseFirst instance Test.QuickCheck.Arbitrary.Arbitrary Test.QuickCheck.Classes.ChooseFirst instance GHC.Show.Show Test.QuickCheck.Classes.ChooseSecond instance Test.QuickCheck.Arbitrary.Arbitrary Test.QuickCheck.Classes.ChooseSecond instance Data.Functor.Classes.Eq1 Test.QuickCheck.Classes.Triple instance Data.Functor.Classes.Show1 Test.QuickCheck.Classes.Triple instance Test.QuickCheck.Arbitrary.Arbitrary1 Test.QuickCheck.Classes.Triple instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Test.QuickCheck.Classes.Triple a) instance GHC.Base.Functor Test.QuickCheck.Classes.Triple instance GHC.Base.Applicative Test.QuickCheck.Classes.Triple instance Data.Foldable.Foldable Test.QuickCheck.Classes.Triple instance Data.Traversable.Traversable Test.QuickCheck.Classes.Triple instance (GHC.Base.Applicative f, Data.Semigroup.Semigroup a) => Data.Semigroup.Semigroup (Test.QuickCheck.Classes.Ap f a) instance (GHC.Base.Applicative f, GHC.Base.Monoid a, Data.Semigroup.Semigroup a) => GHC.Base.Monoid (Test.QuickCheck.Classes.Ap f a) instance Data.Semigroup.Semigroup Test.QuickCheck.Classes.Status instance GHC.Base.Monoid Test.QuickCheck.Classes.Status -- | This module provides property tests for functions that operate on -- list-like data types. If your data type is fully polymorphic in its -- element type, is it recommended that you use foldableLaws and -- traversableLaws from Test.QuickCheck.Classes. -- However, if your list-like data type is either monomorphic in its -- element type (like Text or ByteString) or if it -- requires a typeclass constraint on its element (like -- Data.Vector.Unboxed), the properties provided here can be -- helpful for testing that your functions have the expected behavior. -- All properties in this module require your data type to have an -- IsList instance. module Test.QuickCheck.Classes.IsList foldrProp :: (IsList c, Item c ~ a, Arbitrary c, Show c, Show a, CoArbitrary a, Function a) => Proxy a -> (forall b. (a -> b -> b) -> b -> c -> b) -> Property foldlProp :: (IsList c, Item c ~ a, Arbitrary c, Show c, Show a, CoArbitrary a, Function a) => Proxy a -> (forall b. (b -> a -> b) -> b -> c -> b) -> Property foldlMProp :: (IsList c, Item c ~ a, Arbitrary c, Show c, Show a, CoArbitrary a, Function a) => Proxy a -> (forall s b. (b -> a -> ST s b) -> b -> c -> ST s b) -> Property mapProp :: (IsList c, IsList d, Eq d, Show d, Show b, Item c ~ a, Item d ~ b, Arbitrary c, Arbitrary b, Show c, Show a, CoArbitrary a, Function a) => Proxy a -> Proxy b -> ((a -> b) -> c -> d) -> Property imapProp :: (IsList c, IsList d, Eq d, Show d, Show b, Item c ~ a, Item d ~ b, Arbitrary c, Arbitrary b, Show c, Show a, CoArbitrary a, Function a) => Proxy a -> Proxy b -> ((Int -> a -> b) -> c -> d) -> Property imapMProp :: (IsList c, IsList d, Eq d, Show d, Show b, Item c ~ a, Item d ~ b, Arbitrary c, Arbitrary b, Show c, Show a, CoArbitrary a, Function a) => Proxy a -> Proxy b -> (forall s. (Int -> a -> ST s b) -> c -> ST s d) -> Property traverseProp :: (IsList c, IsList d, Eq d, Show d, Show b, Item c ~ a, Item d ~ b, Arbitrary c, Arbitrary b, Show c, Show a, CoArbitrary a, Function a) => Proxy a -> Proxy b -> (forall s. (a -> ST s b) -> c -> ST s d) -> Property -- | Property for the generate function, which builds a container -- of a given length by applying a function to each index. generateProp :: (Item c ~ a, Eq c, Show c, IsList c, Arbitrary a, Show a) => Proxy a -> (Int -> (Int -> a) -> c) -> Property generateMProp :: (Item c ~ a, Eq c, Show c, IsList c, Arbitrary a, Show a) => Proxy a -> (forall s. Int -> (Int -> ST s a) -> ST s c) -> Property replicateProp :: (Item c ~ a, Eq c, Show c, IsList c, Arbitrary a, Show a) => Proxy a -> (Int -> a -> c) -> Property replicateMProp :: (Item c ~ a, Eq c, Show c, IsList c, Arbitrary a, Show a) => Proxy a -> (forall s. Int -> ST s a -> ST s c) -> Property -- | Property for the filter function, which keeps elements for -- which the predicate holds true. filterProp :: (IsList c, Item c ~ a, Arbitrary c, Show c, Show a, Eq c, CoArbitrary a, Function a) => Proxy a -> ((a -> Bool) -> c -> c) -> Property -- | Property for the filterM function, which keeps elements for -- which the predicate holds true in an applicative context. filterMProp :: (IsList c, Item c ~ a, Arbitrary c, Show c, Show a, Eq c, CoArbitrary a, Function a) => Proxy a -> (forall s. (a -> ST s Bool) -> c -> ST s c) -> Property -- | Property for the mapMaybe function, which keeps elements for -- which the predicate holds true. mapMaybeProp :: (IsList c, Item c ~ a, Item d ~ b, Eq d, IsList d, Arbitrary b, Show d, Show b, Arbitrary c, Show c, Show a, Eq c, CoArbitrary a, Function a) => Proxy a -> Proxy b -> ((a -> Maybe b) -> c -> d) -> Property mapMaybeMProp :: (IsList c, IsList d, Eq d, Show d, Show b, Item c ~ a, Item d ~ b, Arbitrary c, Arbitrary b, Show c, Show a, CoArbitrary a, Function a) => Proxy a -> Proxy b -> (forall s. (a -> ST s (Maybe b)) -> c -> ST s d) -> Property