When used in an ExUnit test module, brings in ExUnitProperties (for the underlying property/2 and check all macros) and imports Bond.PropertyTest so contract_holds and invariants_hold are available.

Raises a CompileError at the use site if stream_data isn't available — see the module docs.

Generates an ExUnit property that calls a single function with random arguments and verifies that Bond's contracts (preconditions, postconditions, checks, invariants) are all satisfied.

Pass a function reference and a list of generators, one per argument:

contract_holds &Math.sqrt/1, args: [StreamData.float(min: 0.0)]

The macro expands to a property block. On each iteration it generates one value per argument and calls the function. Any contract violation raised by Bond's runtime instrumentation fails the property; StreamData then shrinks to the minimal counterexample.

Useful for catching edge cases your example-based tests didn't cover. The function's contracts are the oracle — no separate assertion is needed.

For stateful testing over a struct module — random sequences of operations checked against the module's @invariants — see invariants_hold/2.

Options

• :args (required) — list of StreamData generators, one per function argument.
• :name (optional) — a string used as the property's description. Defaults to "contract_holds <source>".

Generates an ExUnit property that runs random sequences of operations over a struct module and verifies that the module's @invariants (plus any per-function contracts) hold across every reachable state.

This is Bond's stateful, sequence-based property testing. The invariants are a free oracle — they hold at every entry and exit, so there's no need to write an explicit per-operation model of expected behaviour, which is what makes stateful PBT cheap here.

Pass a struct module plus constructor, transformer, and observer specs. The macro generates random sequences of operations over the struct, threads state through them, and runs them.

invariants_hold BoundedStack,
  constructors: [{:new, [StreamData.integer(1..100)]}],
  transformers: [{:push, [StreamData.term()]}, {:pop, []}],
  observers:    [{:size, []}, {:peek, []}]

Each spec is a list of {fun_name, [arg_generators]} tuples:

• Constructor — produces an initial struct. Called first in every sequence.
• Transformer — takes the current struct as its first argument plus generated args, returns a new struct (%Mod{} or {:ok, %Mod{}}). Advances the state.
• Observer — takes the current struct plus generated args, returns anything. Doesn't advance state. The pre-invariant still fires on entry.

Return shape rules for constructors and transformers:

• %Mod{} — becomes the new state.
• {:ok, %Mod{}} — same; the wrapper is stripped.
• {:error, _} — terminates the sequence cleanly (the property passes; an operation that refuses is not a contract violation).
• Anything else raises an ArgumentError; wrap your function or test it with contract_holds/2.

The oracle is invariants and per-function contracts

The runner also checks each operation's own @pre/@post/check contracts as it goes, so a struct module with per-function contracts but no @invariant is still meaningfully exercised. Invariants are the headline because they're what make the sequence form pull its weight — a module with no invariants buys little over testing each function with contract_holds/2.

Options

• :constructors (required, non-empty) — list of {fun_name, [arg_generators]}.
• :transformers (optional, default []) — same shape; state threaded in as the first argument.
• :observers (optional, default []) — same shape; state passed but not advanced.
• :name (optional) — a string used as the property's description. Defaults to "invariants_hold <module>".