test_kit helium-α

test_kit/fuzzy

Functions

Tuple Fuzzers

tuple(a: Fuzzer<a>, b: Fuzzer<b>) -> Fuzzer<(a, b)>

A convenient way of generating tuples instead of doing map2

fuzz.map2(
  fuzzer_a, fuzzer_b,
  fn(a, b) { (a, b) }
)


tuple3(a: Fuzzer<a>, b: Fuzzer<b>, c: Fuzzer<c>) -> Fuzzer<(a, b, c)>

A convenient way of generating tuple3 instead of doing map3

fuzz.map3(
  fuzzer_a, fuzzer_b, fuzzer_c,
  fn(a, b, c) { (a, b, c) }
)


tuple4(
  a: Fuzzer<a>,
  b: Fuzzer<b>,
  c: Fuzzer<c>,
  d: Fuzzer<d>,
) -> Fuzzer<(a, b, c, d)>

A convenient way of generating tuple4 instead of doing map4

fuzz.map4(
  fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d,
  fn(a, b, c, d) { (a, b, c, d) }
)


tuple5(
  a: Fuzzer<a>,
  b: Fuzzer<b>,
  c: Fuzzer<c>,
  d: Fuzzer<d>,
  e: Fuzzer<e>,
) -> Fuzzer<(a, b, c, d, e)>

A convenient way of generating tuple5 instead of doing map5

fuzz.map5(
  fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e,
  fn(a, b, c, d, e) { (a, b, c, d, e) }
)


tuple6(
  a: Fuzzer<a>,
  b: Fuzzer<b>,
  c: Fuzzer<c>,
  d: Fuzzer<d>,
  e: Fuzzer<e>,
  f: Fuzzer<f>,
) -> Fuzzer<(a, b, c, d, e, f)>

A convenient way of generating tuple6 instead of doing map6

fuzz.map6(
  fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f,
  fn(a, b, c, d, e, f) { (a, b, c, d, e, f) }
)


tuple7(
  a: Fuzzer<a>,
  b: Fuzzer<b>,
  c: Fuzzer<c>,
  d: Fuzzer<d>,
  e: Fuzzer<e>,
  f: Fuzzer<f>,
  g: Fuzzer<g>,
) -> Fuzzer<(a, b, c, d, e, f, g)>

A convenient way of generating tuple7 instead of doing map7

fuzz.map7(
  fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f, fuzzer_g,
  fn(a, b, c, d, e, f, g) { (a, b, c, d, e, f, g) }
)


tuple8(
  a: Fuzzer<a>,
  b: Fuzzer<b>,
  c: Fuzzer<c>,
  d: Fuzzer<d>,
  e: Fuzzer<e>,
  f: Fuzzer<f>,
  g: Fuzzer<g>,
  h: Fuzzer<h>,
) -> Fuzzer<(a, b, c, d, e, f, g, h)>

A convenient way of generating tuple8 instead of doing map8

fuzz.map8(
  fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f, fuzzer_g, fuzzer_h,
  fn(a, b, c, d, e, f, g, h) { (a, b, c, d, e, f, g, h) }
)


tuple9(
  a: Fuzzer<a>,
  b: Fuzzer<b>,
  c: Fuzzer<c>,
  d: Fuzzer<d>,
  e: Fuzzer<e>,
  f: Fuzzer<f>,
  g: Fuzzer<g>,
  h: Fuzzer<h>,
  i: Fuzzer<i>,
) -> Fuzzer<(a, b, c, d, e, f, g, h, i)>

A convenient way of generating tuple9 instead of doing map9

fuzz.map9(
  fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f, fuzzer_g, fuzzer_h, fuzzer_i,
  fn(a, b, c, d, e, f, g, h, i) { (a, b, c, d, e, f, g, h, i) }
)

Unique Fuzzers

unique(fuzzer: Fuzzer<a>, count: Int) -> Fuzzer<List<a>>

Generates a list of n unique elements from the given fuzzer.

unique2(fuzzer: Fuzzer<a>) -> Fuzzer<(a, a)>

Generates a tuple of 2 unique elements from the given fuzzer.

unique3(fuzzer: Fuzzer<a>) -> Fuzzer<(a, a, a)>

Generates a tuple of 3 unique elements from the given fuzzer.

unique4(fuzzer: Fuzzer<a>) -> Fuzzer<(a, a, a, a)>

Generates a tuple of 4 unique elements from the given fuzzer.

unique5(fuzzer: Fuzzer<a>) -> Fuzzer<(a, a, a, a, a)>

Generates a tuple of 5 unique elements from the given fuzzer.

unique6(fuzzer: Fuzzer<a>) -> Fuzzer<(a, a, a, a, a, a)>

Generates a tuple of 6 unique elements from the given fuzzer.

unique7(fuzzer: Fuzzer<a>) -> Fuzzer<(a, a, a, a, a, a, a)>

Generates a tuple of 7 unique elements from the given fuzzer.

unique8(fuzzer: Fuzzer<a>) -> Fuzzer<(a, a, a, a, a, a, a, a)>

Generates a tuple of 8 unique elements from the given fuzzer.

unique9(fuzzer: Fuzzer<a>) -> Fuzzer<(a, a, a, a, a, a, a, a, a)>

Generates a tuple of 9 unique elements from the given fuzzer.

Search Document