Module Test.QuickCheckArbitrary

Imports

import Data.Char as Char
import Data.List as List
import Prelude.Math as Math
import frege.Prelude as Prelude
import Prelude.PreludeArrays as PreludeArrays
import Prelude.PreludeBase as PreludeBase
import Prelude.PreludeDecimal as PreludeDecimal
import Prelude.PreludeIO as PreludeIO
import Prelude.PreludeList as PreludeList
import Prelude.PreludeMonad as PreludeMonad
import Prelude.PreludeText as PreludeText
import Test.QuickCheckGen as QuickCheckGen
import System.Random as Random
import Java.util.Regex as Regexp
import Data.TreeMap as TM

Table of Content

Definitions

class Arbitrary a

class CoArbitrary a

shrinkList ∷ (a → [a]) → [a] → [[a]]

arbitrarySizedIntegral ∷ Num a ⇒ Gen a

arbitrarySizedFloating ∷ Floating a ⇒ Gen a

arbitraryBoundedIntegral ∷ (Bounded a, Integral a) ⇒ Gen a

arbitraryBoundedRandom ∷ (Bounded a, Random a) ⇒ Gen a

arbitraryBoundedEnum ∷ (Bounded a, Enum a) ⇒ Gen a

arbitrarySizedBoundedIntegral ∷ (Bounded a, Integral a) ⇒ Gen a

shrinkNothing ∷ a → [a]

shrinkIntegral ∷ Integral a ⇒ a → [a]

shrinkFloating ∷ Floating a ⇒ a → [a]

>< ∷ (Gen a → Gen a) → (Gen a → Gen a) → Gen a → Gen a

coarbitraryIntegral ∷ Integral a ⇒ a → Gen b → Gen b

coarbitraryShow ∷ Show a ⇒ a → Gen b → Gen b

coarbitraryEnum ∷ Enum a ⇒ a → Gen b → Gen b

vector ∷ Arbitrary a ⇒ Int → Gen [a]

orderedList ∷ (Ord a, Arbitrary a) ⇒ Gen [a]
Re-Exported Items

isDigit ∷ Char → Bool Int → Bool

isLowerCase ∷ Char → Bool Int → Bool

isWhitespace ∷ Char → Bool Int → Bool

isUpperCase ∷ Char → Bool Int → Bool

toLowerCase ∷ Char → Char Int → Int
Instances

instance Arbitrary ()

instance (Arbitrary a, Arbitrary b) ⇒ Arbitrary (a, b)

instance (Arbitrary a, Arbitrary b, Arbitrary c) ⇒ Arbitrary (a, b, c)

instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) ⇒ Arbitrary (a, b, c, d)

instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e) ⇒ Arbitrary (a, b, c, d, e)

instance (CoArbitrary a, Arbitrary b) ⇒ Arbitrary (a→b)

instance Arbitrary Bool

instance Arbitrary Byte

instance Arbitrary Char

instance Arbitrary Double

instance (Arbitrary a, Arbitrary b) ⇒ Arbitrary (a | b)

instance Arbitrary Float

instance Arbitrary Int

instance Arbitrary Integer

instance (ArrayElement a, Arbitrary a) ⇒ Arbitrary (JArray a)

instance Arbitrary Long

instance Arbitrary a ⇒ Arbitrary (Maybe a)

instance Arbitrary Ordering

instance Arbitrary Short

instance Arbitrary String

instance (Ord k, Arbitrary k, Arbitrary v) ⇒ Arbitrary (TreeMap k v)

instance Arbitrary a ⇒ Arbitrary [a]

instance Bounded Ordering

instance CoArbitrary ()

instance (CoArbitrary a, CoArbitrary b) ⇒ CoArbitrary (a, b)

instance (CoArbitrary a, CoArbitrary b, CoArbitrary c) ⇒ CoArbitrary (a, b, c)

instance (CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d) ⇒ CoArbitrary (a, b, c, d)

instance (CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d, CoArbitrary e) ⇒ CoArbitrary (a, b, c, d, e)

instance (Arbitrary a, CoArbitrary b) ⇒ CoArbitrary (a→b)

instance CoArbitrary Bool

instance CoArbitrary Char

instance CoArbitrary Double

instance (CoArbitrary a, CoArbitrary b) ⇒ CoArbitrary (a | b)

instance CoArbitrary Float

instance CoArbitrary Int

instance CoArbitrary Integer

instance CoArbitrary Long

instance CoArbitrary a ⇒ CoArbitrary (Maybe a)

instance CoArbitrary Ordering

instance CoArbitrary String

instance (Ord k, CoArbitrary k, CoArbitrary v) ⇒ CoArbitrary (TreeMap k v)

instance CoArbitrary a ⇒ CoArbitrary [a]
Functions and Values by Type

Definitions

class Arbitrary a

class Arbitrary

Random generation and shrinking of values.

Minimal complete definition: Arbitrary.arbitrary

Known Instances

Maybe, Bool, (,,,), (,), (), (,,), ->, (,,,,), Integer, Either, Char, Lang.Byte, Double, Int, Float, JArray, Long, TM.TreeMap, Lang.Short, Ordering, StringJ, []

Member Functions

arbitrary ∷ Arbitrary a ⇒ Gen a: A generator for values of the given type.
shrink ∷ Arbitrary a ⇒ a → [a]: Produces a (possibly) empty list of all the possible immediate shrinks of the given value.

shrinkList ∷ (a → [a]) → [a] → [[a]]

arbitrarySizedIntegral ∷ Num a ⇒ Gen a

Generates an integral number. The number can be positive or negative and its maximum absolute value depends on the size parameter.

arbitrarySizedFloating ∷ Floating a ⇒ Gen a

Generates a fractional number. The number can be positive or negative and its maximum absolute value depends on the size parameter.

arbitraryBoundedIntegral ∷ (Bounded a, Integral a) ⇒ Gen a

arbitraryBoundedRandom ∷ (Bounded a, Random a) ⇒ Gen a

Generates an element of a bounded type. The element is chosen from the entire range of the type.

arbitraryBoundedEnum ∷ (Bounded a, Enum a) ⇒ Gen a

arbitrarySizedBoundedIntegral ∷ (Bounded a, Integral a) ⇒ Gen a

shrinkNothing ∷ a → [a]

Returns no shrinking alternatives.

shrinkIntegral ∷ Integral a ⇒ a → [a]

Shrink an integral number.

shrinkFloating ∷ Floating a ⇒ a → [a]

Shrink a fraction.

class CoArbitrary a

CoArbitrary

Used for random generation of functions.

Known Instances

->, (,), (), (,,,), (,,), (,,,,), Maybe, Either, Char, Bool, Double, Integer, Int, Float, Long, TM.TreeMap, Ordering, StringJ, []

Member Functions

coarbitrary ∷ CoArbitrary a ⇒ a → Gen c → Gen c

Used to generate a function of type a -> c. The implementation should use the first argument to perturb the random generator given as the second argument. The returned generator is then used to generate the function result.

You can often use QuickCheckGen.variant and >< to implement CoArbitrary.coarbitrary.

>< ∷ (Gen a → Gen a) → (Gen a → Gen a) → Gen a → Gen a
infixr 1

coarbitraryIntegral ∷ Integral a ⇒ a → Gen b → Gen b

coarbitraryShow ∷ Show a ⇒ a → Gen b → Gen b

CoArbitrary.coarbitrary helper for lazy people :-).

coarbitraryEnum ∷ Enum a ⇒ a → Gen b → Gen b

A CoArbitrary.coarbitrary implementation for enums.

vector ∷ Arbitrary a ⇒ Int → Gen [a]

----------------------------------------------------------------------

Generates a list of a given length.

orderedList ∷ (Ord a, Arbitrary a) ⇒ Gen [a]

Generates an ordered list of a given length.

Instances

instance Arbitrary ()

Member Functions

arbitrary ∷ Gen ()
shrink ∷ () → [()]: inherited from Arbitrary.shrink

instance (Arbitrary a, Arbitrary b) ⇒ Arbitrary (a, b)

Member Functions

arbitrary ∷ (Arbitrary 𝖇, Arbitrary 𝖆) ⇒ Gen (𝖇, 𝖆)
shrink ∷ (Arbitrary 𝖇, Arbitrary 𝖆) ⇒ (𝖇, 𝖆) → [(𝖇, 𝖆)]

instance (Arbitrary a, Arbitrary b, Arbitrary c) ⇒ Arbitrary (a, b, c)

Member Functions

arbitrary ∷ (Arbitrary 𝖇, Arbitrary 𝖈, Arbitrary 𝖆) ⇒ Gen (𝖇, 𝖈, 𝖆)
shrink ∷ (Arbitrary 𝖇, Arbitrary 𝖈, Arbitrary 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → [(𝖇, 𝖈, 𝖆)]

instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) ⇒ Arbitrary (a, b, c, d)

Member Functions

arbitrary ∷ (Arbitrary 𝖈, Arbitrary 𝖉, Arbitrary 𝖇, Arbitrary 𝖆) ⇒ Gen (𝖈, 𝖉, 𝖇, 𝖆)
shrink ∷ (Arbitrary 𝖈, Arbitrary 𝖉, Arbitrary 𝖇, Arbitrary 𝖆) ⇒ (𝖈, 𝖉, 𝖇, 𝖆) → [(𝖈, 𝖉, 𝖇, 𝖆)]

instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e) ⇒ Arbitrary (a, b, c, d, e)

Member Functions

arbitrary ∷ (Arbitrary 𝖉, Arbitrary 𝖊, Arbitrary 𝖇, Arbitrary 𝖈, Arbitrary 𝖆) ⇒ Gen (𝖉, 𝖊, 𝖇, 𝖈, 𝖆)
shrink ∷ (Arbitrary 𝖉, Arbitrary 𝖊, Arbitrary 𝖇, Arbitrary 𝖈, Arbitrary 𝖆) ⇒ (𝖉, 𝖊, 𝖇, 𝖈, 𝖆) → [(𝖉, 𝖊, 𝖇, 𝖈, 𝖆)]

instance (CoArbitrary a, Arbitrary b) ⇒ Arbitrary (a→b)