For assert_failure, when expected error does not match the actual error.

For assert_failure, when scenario actually succeeds when expected to fail.

Usual threaded state for the tests. Contains the current block, pending operations and the known State.t

Sets the de facto baker for all future blocks

Exclude a list of delegates from baking

Unsets the baking policy, it returns to default (By_round 0)

Creates a snapshot of the current balances for the given account names. Can be used to check that balances at point A and B in the execution of a test are the same (either nothing happened, or a succession of actions resulted in getting the same values as before

Check balances against a previously defined snapshot

Save the current issuance rate for future use

Check that f saved_rate current_rate is true. f is typically a comparison function

Useful function to test expected failures: runs the given branch until it fails, then rollbacks to before execution. Fails if the given branch Succeeds

Check a scenario does not fail, and rolls back to before the assert

Loop

Check a specific balance field for a specific account is equal to a specific amount

Set delegate parameters for the given delegate

Add a new account with the given name

Reveal operation

Transfer from src to dst

Set delegate for src. If delegate_name_opt = None, then unset current delegate

Stake operation

unstake operation

finalize unstake operation

Double attestation helpers

double_bake_op delegate_names (block, state) performs a double baking with the given delegate names. The first delegate in the list bakes the new main branch. All delegates (including the first) will bake two other blocks at the same level/different round.

double_attest_op ?other_bakers ~op ~op_evidence ~kind delegate_names (block, state) performs a double (pre)attestation with the given delegate names. Starting at block level `n`, it creates two 2-block branches and all delegates will (pre)attest the two blocks at level `n+2`. other_bakers can be used to force using specific bakers to avoid reusing forbidden ones

make_denunciations_op ?single ?rev ?filter () denounces all double signers in the state. If single is set, only one denunciation is made. If rev is set, the denunciations are made in reverse order. If filter is set, only the double signers for which the filter returns true are denounced.

Create an account and give an initial balance funded by funder

A scenario is a succession of actions. We define a branching path as a way to create multiple tests from the same point. This allows easy compositionality of behaviors with minimal code sharing. The Tag allows to give meaningful identifiers to the branches. It is good practice to tag each case in a branch (it's not necessary, but since test names must be unique, at most one branch can remain unnamed, and even then it can create conflicting names.)

Unfolded scenario type

Continuation connector: execute a then b

Branching connector: creates two tests with different execution paths

Ends the test. Dump the state, returns unit

Transforms scenarios into tests

Arbitrary execution

Execute a function that does not modify the block, only the state

Execute a function that does not modify neither the block nor the state. Usually used for checks/asserts

fold f l folds f over l, fails on empty list

fold_tag f l folds f over l, l has a tag for each of its elements. Fails on empty list.

fold_tag_f f tag l folds f over l, tag returns a tag for each element of l. Fails on empty list.

unfold f l maps f over l, and runs them in order

Returns when the number of bootstrap accounts created by Context.init_n n is not equal to n

Initializes the constants for testing, with well chosen default values. Recommended over start or start_with

Initialize the test, given some initial parameters

Applies when baking the last block of a cycle

Applies when baking the first block of a cycle. Technically nothing special happens, but we need to update the unslashable unstakes since it's done lazily

After baking and applying rewards in state

Bake a block, with the given baker and the given operations.

Bake until a cycle is reached, using bake instead of Block.bake

Bake all the remaining blocks of the current cycle

Bake a single block

Bake a single block with a specific baker

Bake until the end of a cycle

Bake until the end of a cycle

Executes an operation: f should return a new state and a list of operations, which are then applied

Waiting functions

Waits until condition init_t current_t is fulfilled. It is checked on the first block of every cycle. If it returns false, another cycle is baked, until it succeeds.

Wait until we are in a cycle satisfying the given condition. Fails if AI_activation is requested and AI is not set to be activated in the future.

Wait until AI activates. Fails if AI is not set to be activated in the future.

wait delegate_parameters_activation_delay cycles