Home

main

  • Arbitrary
    • new
    • remaining
    • len
    • is_empty
    • bytes
    • u64_in_inclusive_range
    • ratio
    • arbitrary_byte_size
    • next_power_of_two
    • arbitrary_list_u8
    • arbitrary_str
  • Fuzz
    • keep
    • alloc_count!
    • live_alloc_count!
    • realloc_count!
    • dealloc_count!
    • requested_bytes!
    • scope_start!
    • scope_finish!
    • prepare_return_box!
    • scope_finish_return!
    • start_measure!
    • measure!
    • mark!
    • before!
    • count!
    • forbidden!
    • trace_rules!
    • expect_allocs_at_most!
    • expect_allocs_at_least!
    • expect_no_leaks!
    • reject
    • example
    • saved
    • encode
    • entropy
    • 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
    • Stats
    • Measurement
      • finish!
    • TraceRule
    • Generator
    • InputFormat
    • InputState
    • Encodable
    • Parseable
    • FuzzEncoding
    • Example
  • Target
    • new
    • name
    • run!
    • show
    • example_count
    • example
  • 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.realloc_count! : () => U64
  • Fuzz.dealloc_count! : () => U64
  • Fuzz.requested_bytes! : () => U64
  • Fuzz.scope_start! : Str => U64
  • Fuzz.scope_finish! : U64 => Stats
  • Fuzz.prepare_return_box! : () => {}
  • Fuzz.scope_finish_return! : U64, Box(a) => { value : Box(a), stats : Stats }
  • Fuzz.start_measure! : Str => Measurement
  • Fuzz.measure! : Str, (() => a) => { value : a, stats : Stats }
  • Fuzz.mark! : Str => {}
  • Fuzz.before! : Str, Str => {}
  • Fuzz.count! : Str, U64 => {}
  • Fuzz.forbidden! : Str => {}
  • Fuzz.trace_rules! : List(TraceRule) => {}
  • 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.example : { name : Str, revision : Str, make : () -> a } -> Example(a)
  • Fuzz.saved : { name : Str, revision : Str, bytes : List(U8) } -> Example(a)
  • Fuzz.encode : a -> List(U8) where [a.Encodable]
  • Fuzz.entropy : List(U8) -> List(U8)
  • Fuzz.target : { name : Str, examples : List(Example(a)), test : a -> Outcome, show : a -> Str } -> Target where [a.generator_for : FuzzEncoding -> Generator(a), a.Encodable, a.Parseable(errs)]
  • Fuzz.target_with : { name : Str, examples : List(Example(a)), generator : Generator(a), test : a -> Outcome, show : a -> Str } -> Target where [a.Encodable, a.Parseable(errs)]
  • Fuzz.target_with! : { name : Str, examples : List(Example(a)), generator : Generator(a), test! : a => Outcome, show : a -> Str } -> Target where [a.Encodable, a.Parseable(errs)]
  • Fuzz.from_bytes! : { name : Str, examples : List(Example(List(U8))), test! : List(U8) => U8 } -> Target
  • Fuzz.from_bytes : { name : Str, examples : List(Example(List(U8))), 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.Stats : { allocs : U64, reallocs : U64, deallocs : U64, requested_bytes : U64, entry_live_allocs : U64, entry_live_bytes : U64, exit_live_allocs : U64, exit_live_bytes : U64, peak_live_bytes : U64 }
  • Fuzz.Measurement := { id : U64 }
  • Fuzz.Measurement.finish! : Measurement => Stats
  • Fuzz.TraceRule := [Before(Str, Str), Count(Str, U64), Forbidden(Str)]
  • Fuzz.Generator : Arbitrary -> { value : a, state : Arbitrary }
  • Fuzz.InputFormat : Format
  • Fuzz.InputState : State
  • Fuzz.Encodable : a where [a.encoder_for : Format -> (a, List(U8) -> Try(List(U8), []))]
  • Fuzz.Parseable : a where [a.parser_for : Format -> (State -> Try({ value : a, rest : State }, [MalformedInput, BudgetExceeded, ..errs]))]
  • Fuzz.FuzzEncoding := [Default]
  • Fuzz.Example := [Typed({ name : Str, revision : Str, make : () -> a }), Saved({ name : Str, revision : Str, bytes : List(U8) })]
  • Target.new : { name : Str, run! : List(U8) => U8, show : List(U8) -> Str, example_count : () -> U64, example : U64 -> { name : Str, revision : Str, bytes : List(U8) } } -> Target
  • Target.name : Target -> Str
  • Target.run! : Target, List(U8) => U8
  • Target.show : Target, List(U8) -> Str
  • Target.example_count : Target -> U64
  • Target.example : Target, U64 -> { name : Str, revision : Str, bytes : List(U8) }

Made by people who like to make nice things.