module Fuzz
(
int,
intRange,
float,
floatRange,
percentage,
text,
bool,
maybe,
result,
list,
array,
Fuzzer,
oneOf,
constant,
frequency,
tuple,
tuple3,
char,
unit,
order,
)
where
import qualified Array
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Range as Range
import NriPrelude
import Test.Internal (Fuzzer (Fuzzer, unFuzzer))
import qualified Prelude
int :: Fuzzer Int
int :: Fuzzer Int
int =
Range Int -> GenT Identity Int
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral Range Int
forall a. (Bounded a, Integral a) => Range a
Range.exponentialBounded
GenT Identity Int
-> (GenT Identity Int -> Fuzzer Int) -> Fuzzer Int
forall a b. a -> (a -> b) -> b
|> GenT Identity Int -> Fuzzer Int
forall a. Gen a -> Fuzzer a
Fuzzer
intRange :: Int -> Int -> Fuzzer Int
intRange :: Int -> Int -> Fuzzer Int
intRange Int
min_ Int
max_ =
Range Int -> GenT Identity Int
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Int -> Int -> Int -> Range Int
forall a. Integral a => a -> a -> a -> Range a
Range.linearFrom (Int -> Int -> Int -> Int
forall number. Ord number => number -> number -> number -> number
clamp Int
min_ Int
max_ Int
0) Int
min_ Int
max_)
GenT Identity Int
-> (GenT Identity Int -> Fuzzer Int) -> Fuzzer Int
forall a b. a -> (a -> b) -> b
|> GenT Identity Int -> Fuzzer Int
forall a. Gen a -> Fuzzer a
Fuzzer
float :: Fuzzer Float
float :: Fuzzer Float
float =
Range Float -> GenT Identity Float
forall (m :: * -> *). MonadGen m => Range Float -> m Float
Gen.double (Float -> Float -> Float -> Range Float
forall a. (Floating a, Ord a) => a -> a -> a -> Range a
Range.exponentialFloatFrom Float
0 (-Float
1e100) Float
1e100)
GenT Identity Float
-> (GenT Identity Float -> Fuzzer Float) -> Fuzzer Float
forall a b. a -> (a -> b) -> b
|> GenT Identity Float -> Fuzzer Float
forall a. Gen a -> Fuzzer a
Fuzzer
floatRange :: Float -> Float -> Fuzzer Float
floatRange :: Float -> Float -> Fuzzer Float
floatRange Float
min_ Float
max_ =
Range Float -> GenT Identity Float
forall (m :: * -> *). MonadGen m => Range Float -> m Float
Gen.double (Float -> Float -> Float -> Range Float
forall a. (Fractional a, Ord a) => a -> a -> a -> Range a
Range.linearFracFrom (Float -> Float -> Float -> Float
forall number. Ord number => number -> number -> number -> number
clamp Float
min_ Float
max_ Float
0) Float
min_ Float
max_)
GenT Identity Float
-> (GenT Identity Float -> Fuzzer Float) -> Fuzzer Float
forall a b. a -> (a -> b) -> b
|> GenT Identity Float -> Fuzzer Float
forall a. Gen a -> Fuzzer a
Fuzzer
percentage :: Fuzzer Float
percentage :: Fuzzer Float
percentage =
Range Float -> GenT Identity Float
forall (m :: * -> *). MonadGen m => Range Float -> m Float
Gen.double (Float -> Float -> Range Float
forall a. (Fractional a, Ord a) => a -> a -> Range a
Range.linearFrac Float
0 Float
1)
GenT Identity Float
-> (GenT Identity Float -> Fuzzer Float) -> Fuzzer Float
forall a b. a -> (a -> b) -> b
|> GenT Identity Float -> Fuzzer Float
forall a. Gen a -> Fuzzer a
Fuzzer
text :: Fuzzer Text
text :: Fuzzer Text
text =
Range Int -> GenT Identity Char -> GenT Identity Text
forall (m :: * -> *). MonadGen m => Range Int -> m Char -> m Text
Gen.text (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.exponential Int
0 Int
1000) GenT Identity Char
forall (m :: * -> *). MonadGen m => m Char
Gen.ascii
GenT Identity Text
-> (GenT Identity Text -> Fuzzer Text) -> Fuzzer Text
forall a b. a -> (a -> b) -> b
|> GenT Identity Text -> Fuzzer Text
forall a. Gen a -> Fuzzer a
Fuzzer
bool :: Fuzzer Bool
bool :: Fuzzer Bool
bool =
GenT Identity Bool
forall (m :: * -> *). MonadGen m => m Bool
Gen.bool
GenT Identity Bool
-> (GenT Identity Bool -> Fuzzer Bool) -> Fuzzer Bool
forall a b. a -> (a -> b) -> b
|> GenT Identity Bool -> Fuzzer Bool
forall a. Gen a -> Fuzzer a
Fuzzer
maybe :: Fuzzer a -> Fuzzer (Maybe a)
maybe :: Fuzzer a -> Fuzzer (Maybe a)
maybe (Fuzzer Gen a
gen) =
Gen a -> GenT Identity (Maybe a)
forall (m :: * -> *) a. MonadGen m => m a -> m (Maybe a)
Gen.maybe Gen a
gen
GenT Identity (Maybe a)
-> (GenT Identity (Maybe a) -> Fuzzer (Maybe a))
-> Fuzzer (Maybe a)
forall a b. a -> (a -> b) -> b
|> GenT Identity (Maybe a) -> Fuzzer (Maybe a)
forall a. Gen a -> Fuzzer a
Fuzzer
result :: Fuzzer error -> Fuzzer value -> Fuzzer (Result error value)
result :: Fuzzer error -> Fuzzer value -> Fuzzer (Result error value)
result Fuzzer error
errorFuzzer Fuzzer value
valueFuzzer =
List (Fuzzer (Result error value)) -> Fuzzer (Result error value)
forall a. List (Fuzzer a) -> Fuzzer a
oneOf
[ (error -> Result error value)
-> Fuzzer error -> Fuzzer (Result error value)
forall (m :: * -> *) a value.
Functor m =>
(a -> value) -> m a -> m value
map error -> Result error value
forall error value. error -> Result error value
Err Fuzzer error
errorFuzzer,
(value -> Result error value)
-> Fuzzer value -> Fuzzer (Result error value)
forall (m :: * -> *) a value.
Functor m =>
(a -> value) -> m a -> m value
map value -> Result error value
forall error value. value -> Result error value
Ok Fuzzer value
valueFuzzer
]
list :: Fuzzer a -> Fuzzer (List a)
list :: Fuzzer a -> Fuzzer (List a)
list (Fuzzer Gen a
gen) =
Range Int -> Gen a -> GenT Identity (List a)
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list (Int -> Int -> Range Int
forall a. Integral a => a -> a -> Range a
Range.exponential Int
0 Int
100) Gen a
gen
GenT Identity (List a)
-> (GenT Identity (List a) -> Fuzzer (List a)) -> Fuzzer (List a)
forall a b. a -> (a -> b) -> b
|> GenT Identity (List a) -> Fuzzer (List a)
forall a. Gen a -> Fuzzer a
Fuzzer
array :: Fuzzer a -> Fuzzer (Array.Array a)
array :: Fuzzer a -> Fuzzer (Array a)
array Fuzzer a
itemFuzzer =
Fuzzer a -> Fuzzer (List a)
forall a. Fuzzer a -> Fuzzer (List a)
list Fuzzer a
itemFuzzer
Fuzzer (List a)
-> (Fuzzer (List a) -> Fuzzer (Array a)) -> Fuzzer (Array a)
forall a b. a -> (a -> b) -> b
|> (List a -> Array a) -> Fuzzer (List a) -> Fuzzer (Array a)
forall (m :: * -> *) a value.
Functor m =>
(a -> value) -> m a -> m value
map List a -> Array a
forall a. List a -> Array a
Array.fromList
oneOf :: List (Fuzzer a) -> Fuzzer a
oneOf :: List (Fuzzer a) -> Fuzzer a
oneOf List (Fuzzer a)
optionFuzzers =
(Fuzzer a -> Gen a) -> List (Fuzzer a) -> [Gen a]
forall (m :: * -> *) a value.
Functor m =>
(a -> value) -> m a -> m value
map Fuzzer a -> Gen a
forall a. Fuzzer a -> Gen a
unFuzzer List (Fuzzer a)
optionFuzzers
[Gen a] -> ([Gen a] -> Gen a) -> Gen a
forall a b. a -> (a -> b) -> b
|> [Gen a] -> Gen a
forall (m :: * -> *) a. MonadGen m => [m a] -> m a
Gen.choice
Gen a -> (Gen a -> Fuzzer a) -> Fuzzer a
forall a b. a -> (a -> b) -> b
|> Gen a -> Fuzzer a
forall a. Gen a -> Fuzzer a
Fuzzer
constant :: a -> Fuzzer a
constant :: a -> Fuzzer a
constant a
x =
a -> GenT Identity a
forall (m :: * -> *) a. MonadGen m => a -> m a
Gen.constant a
x
GenT Identity a -> (GenT Identity a -> Fuzzer a) -> Fuzzer a
forall a b. a -> (a -> b) -> b
|> GenT Identity a -> Fuzzer a
forall a. Gen a -> Fuzzer a
Fuzzer
frequency :: List (Float, Fuzzer a) -> Fuzzer a
frequency :: List (Float, Fuzzer a) -> Fuzzer a
frequency List (Float, Fuzzer a)
optionFuzzers =
List (Float, Fuzzer a)
optionFuzzers
List (Float, Fuzzer a)
-> (List (Float, Fuzzer a) -> [(Int, Gen a)]) -> [(Int, Gen a)]
forall a b. a -> (a -> b) -> b
|> ((Float, Fuzzer a) -> (Int, Gen a))
-> List (Float, Fuzzer a) -> [(Int, Gen a)]
forall (m :: * -> *) a value.
Functor m =>
(a -> value) -> m a -> m value
map (\(Float
float', (Fuzzer Gen a
gen)) -> (Float -> Int
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.round (Float
float' Float -> Float -> Float
forall number. Num number => number -> number -> number
* Float
1000000), Gen a
gen))
[(Int, Gen a)] -> ([(Int, Gen a)] -> Gen a) -> Gen a
forall a b. a -> (a -> b) -> b
|> [(Int, Gen a)] -> Gen a
forall (m :: * -> *) a. MonadGen m => [(Int, m a)] -> m a
Gen.frequency
Gen a -> (Gen a -> Fuzzer a) -> Fuzzer a
forall a b. a -> (a -> b) -> b
|> Gen a -> Fuzzer a
forall a. Gen a -> Fuzzer a
Fuzzer
tuple :: (Fuzzer a, Fuzzer b) -> Fuzzer (a, b)
tuple :: (Fuzzer a, Fuzzer b) -> Fuzzer (a, b)
tuple (Fuzzer a
fuzzerA, Fuzzer b
fuzzerB) =
(a -> b -> (a, b)) -> Fuzzer a -> Fuzzer b -> Fuzzer (a, b)
forall (m :: * -> *) a b value.
Applicative m =>
(a -> b -> value) -> m a -> m b -> m value
map2 (,) Fuzzer a
fuzzerA Fuzzer b
fuzzerB
tuple3 :: (Fuzzer a, Fuzzer b, Fuzzer c) -> Fuzzer (a, b, c)
tuple3 :: (Fuzzer a, Fuzzer b, Fuzzer c) -> Fuzzer (a, b, c)
tuple3 (Fuzzer a
fuzzerA, Fuzzer b
fuzzerB, Fuzzer c
fuzzerC) =
(a -> b -> c -> (a, b, c))
-> Fuzzer a -> Fuzzer b -> Fuzzer c -> Fuzzer (a, b, c)
forall (m :: * -> *) a b c value.
Applicative m =>
(a -> b -> c -> value) -> m a -> m b -> m c -> m value
map3 (,,) Fuzzer a
fuzzerA Fuzzer b
fuzzerB Fuzzer c
fuzzerC
char :: Fuzzer Char
char :: Fuzzer Char
char =
GenT Identity Char
forall (m :: * -> *). MonadGen m => m Char
Gen.ascii
GenT Identity Char
-> (GenT Identity Char -> Fuzzer Char) -> Fuzzer Char
forall a b. a -> (a -> b) -> b
|> GenT Identity Char -> Fuzzer Char
forall a. Gen a -> Fuzzer a
Fuzzer
unit :: Fuzzer ()
unit :: Fuzzer ()
unit = () -> Fuzzer ()
forall a. a -> Fuzzer a
constant ()
order :: Fuzzer Ordering
order :: Fuzzer Ordering
order = List (Fuzzer Ordering) -> Fuzzer Ordering
forall a. List (Fuzzer a) -> Fuzzer a
oneOf [Ordering -> Fuzzer Ordering
forall a. a -> Fuzzer a
constant Ordering
EQ, Ordering -> Fuzzer Ordering
forall a. a -> Fuzzer a
constant Ordering
LT, Ordering -> Fuzzer Ordering
forall a. a -> Fuzzer a
constant Ordering
GT]