main

Arbitrary
Fuzz
- keep
- alloc_count!
- live_alloc_count!
- measure_allocs!
- expect_allocs_at_most!
- expect_allocs_at_least!
- expect_no_leaks!
- reject
- target
- target_with
- target_with!
- from_bytes!
- from_bytes
- constant
- map
- map2
- u8
- u8_in
- u64
- u64_in
- f32
- f32_in
- f64
- f64_in
- bytes
- raw_bytes
- str
- list
- Outcome
- Generator
- FuzzEncoding
Target
- new
- name
- run!
- show

Arbitrary.new : List(U8) -> Arbitrary
Arbitrary.remaining : Arbitrary -> List(U8)
Arbitrary.len : Arbitrary -> U64
Arbitrary.is_empty : Arbitrary -> Bool
Arbitrary.bytes : Arbitrary, U64 -> Try({ value : List(U8), state : Arbitrary }, [NotEnoughData(U64)])
Arbitrary.u64_in_inclusive_range : Arbitrary, U64, U64 -> { value : U64, state : Arbitrary }
Arbitrary.ratio : Arbitrary, U64, U64 -> { value : Bool, state : Arbitrary }
Arbitrary.arbitrary_byte_size : Arbitrary -> { value : U64, state : Arbitrary }
Arbitrary.next_power_of_two : U64 -> U64
Arbitrary.arbitrary_list_u8 : Arbitrary -> { value : List(U8), state : Arbitrary }
Arbitrary.arbitrary_str : Arbitrary -> { value : Str, state : Arbitrary }
Fuzz.keep : Outcome
Fuzz.alloc_count! : () => U64
Fuzz.live_alloc_count! : () => U64
Fuzz.measure_allocs! : ({} => a) => { value : a, allocations : U64 }
Fuzz.expect_allocs_at_most! : U64, ({} => a) => a
Fuzz.expect_allocs_at_least! : U64, ({} => a) => a
Fuzz.expect_no_leaks! : ({} => a) => {}
Fuzz.reject : Outcome
Fuzz.target : { name : Str, test : a -> Outcome, show : a -> Str } -> Target where [a.generator_for : FuzzEncoding -> Generator(a)]
Fuzz.target_with : { name : Str, generator : Generator(a), test : a -> Outcome, show : a -> Str } -> Target
Fuzz.target_with! : { name : Str, generator : Generator(a), test! : a => Outcome, show : a -> Str } -> Target
Fuzz.from_bytes! : { name : Str, test! : List(U8) => U8 } -> Target
Fuzz.from_bytes : { name : Str, test : List(U8) -> U8 } -> Target
Fuzz.constant : a -> Generator(a)
Fuzz.map : Generator(a), (a -> b) -> Generator(b)
Fuzz.map2 : Generator(a), Generator(b), (a, b -> c) -> Generator(c)
Fuzz.u8 : Generator(U8)
Fuzz.u8_in : U8, U8 -> Generator(U8)
Fuzz.u64 : Generator(U64)
Fuzz.u64_in : U64, U64 -> Generator(U64)
Fuzz.f32 : Generator(F32)
Fuzz.f32_in : F32, F32 -> Generator(F32)
Fuzz.f64 : Generator(F64)
Fuzz.f64_in : F64, F64 -> Generator(F64)
Fuzz.bytes : Generator(List(U8))
Fuzz.raw_bytes : Generator(List(U8))
Fuzz.str : Generator(Str)
Fuzz.list : Generator(a), U64 -> Generator(List(a))
Fuzz.Outcome := [Keep, Reject]
Fuzz.Generator : Arbitrary -> { value : a, state : Arbitrary }
Fuzz.FuzzEncoding := [Default]
Target.new : { name : Str, run! : List(U8) => U8, show : List(U8) -> Str } -> Target
Target.name : Target -> Str
Target.run! : Target, List(U8) => U8
Target.show : Target, List(U8) -> Str

Made by people who like to make nice things.