test
The testing framework
let run: <a, b>(_: (_: a) => b) => (_: a) => michelson_program
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.run` from `Test.Next` is encouraged for a smoother migration.Run a function on an input, all in Michelson. More concretely:
a) compiles the function argument to Michelson f_mich; b)
compiles the value argument (which was evaluated already) to
Michelson v_mich; c) runs the Michelson interpreter on the code
f_mich with starting stack [v_mich].
let eval: <a>(_: a) => michelson_program
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.eval` from `Test.Next` is encouraged for a smoother migration.Compile a LIGO value to Michelson. Currently it is a renaming of
compile_value.
let decompile: <a>(_: michelson_program) => a
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.decompile` from `Test.Next` is encouraged for a smoother migration.Decompile a Michelson value to LIGO, following the (mandatory)
type annotation. Note: This operation can fail at run-time, in case
that the michelson_program given cannot be decompiled to something
compatible with the annotated type.
let compile_value: <a>(_: a) => michelson_program
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.eval` from `Test.Next` is encouraged for a smoother migration.Compile a LIGO value to Michelson.
let get_total_voting_power: (_: unit) => nat
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.get_total_voting_power` from `Test.Next` is encouraged for a smoother migration.Returns the total voting power of all contracts. The total voting power coincides with the sum of the rolls count of every contract in the voting listings. The voting listings is calculated at the beginning of every voting period.
let failwith: <a, b>(_: a) => b
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Assert.failwith` from `Test.Next` is encouraged for a smoother migration.Cause the testing framework to fail.
let to_contract: <p, s>(_: typed_address<p, s>) => contract<p>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Typed_address.to_contract` from `Test.Next` is encouraged for a smoother migration.Gets the contract corresponding to the default entrypoint of a
typed address: the contract parameter in the result will be the
type of the default entrypoint (generally 'param, but this might
differ if 'param includes a "default" entrypoint).
let set_source: (_: address) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.set_source` from `Test.Next` is encouraged for a smoother migration.Sets the source for Test.transfer and Test.originate.
let cast_address: <a, b>(_: address) => typed_address<a, b>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Address.to_typed_address` from `Test.Next` is encouraged for a smoother migration.This function casts an address to a typed address. You will need to annotate the result with the type you expect.
let to_address: <a, b>(_: typed_address<a, b>) => address
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Typed_address.to_address` from `Test.Next` is encouraged for a smoother migration.let get_storage: <p, s>(_: typed_address<p, s>) => s
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Typed_address.get_storage` from `Test.Next` is encouraged for a smoother migration.Gets the storage of a typed account.
let get_storage_of_address: <b>(_: address) => b
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Address.get_storage` from `Test.Next` is encouraged for a smoother migration.Gets the storage of an account in michelson_program.
let get_balance_of_address: (_: address) => tez
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Address.get_balance` from `Test.Next` is encouraged for a smoother migration.Gets the balance of an account (given as an address) in tez.
let get_balance: <p, s>(_: typed_address<p, s>) => tez
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Typed_address.get_balance` from `Test.Next` is encouraged for a smoother migration.Gets the balance of an account in tez.
let print: (_: string) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `IO.print` from `Test.Next` is encouraged for a smoother migration.Prints an string to stdout.
let eprint: (_: string) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `IO.eprint` from `Test.Next` is encouraged for a smoother migration.Prints an string to stderr.
let get_voting_power: (_: key_hash) => nat
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.get_voting_power` from `Test.Next` is encouraged for a smoother migration.Return the voting power of a given contract. This voting power coincides with the weight of the contract in the voting listings (i.e., the rolls count) which is calculated at the beginning of every voting period.
let nth_bootstrap_contract: (_: nat) => address
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Account.Contract.bootstrap` from `Test.Next` is encouraged for a smoother migration.Returns the address corresponding to the nth bootstrapped contract.
let nth_bootstrap_account: (_: int) => address
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Account.address` from `Test.Next` is encouraged for a smoother migration.Returns the address of the nth bootstrapped account.
let get_bootstrap_account: (_: nat) => [address, key, string]
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Account.info` from `Test.Next` is encouraged for a smoother migration.Returns the address, key and secret key of the nth bootstrapped account.
let nth_bootstrap_typed_address: <a, b>(_: nat) => typed_address<a, b>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Account.Contract.bootstrap_typed_address` from `Test.Next` is encouraged for a smoother migration.Returns the typed address corresponding to the nth bootstrapped
contract currently loaded. The types are inferred from those
contracts loaded with Test.bootstrap_contract (before reset).
let last_originations: (_: unit) => map<address, list<address>>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.last_originations` from `Test.Next` is encouraged for a smoother migration.Returns addresses of orginated accounts in the last transfer. It is given in the form of a map binding the address of the source of the origination operation to the addresses of newly originated accounts.
let random: <a>(_: unit) => a
This function creates a random value for a chosen type.let new_account: (_: unit) => [string, key]
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Account.new` from `Test.Next` is encouraged for a smoother migration.Creates and returns secret key & public key of a new account.
let bake_until_n_cycle_end: (_: nat) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.bake_until` from `Test.Next` is encouraged for a smoother migration.It bakes until a number of cycles pass, so that an account registered as delegate can effectively act as a baker. Note: It can be used in tests to manually advance time.
let get_time: (_: unit) => timestamp
let register_delegate: (_: key_hash) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.register_delegate` from `Test.Next` is encouraged for a smoother migration.Registers a key_hash corresponding to an account as a delegate.
let stake: (_: key_hash) => (_: tez) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.stake` from `Test.Next` is encouraged for a smoother migration.let register_constant: (_: michelson_program) => string
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.register_constant` from `Test.Next` is encouraged for a smoother migration.Registers a global constant, returns its hash as a string. See the documentation for global constants for an example of usage.
let to_typed_address: <a, b>(_: contract<a>) => typed_address<a, b>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Contract.to_typed_address` from `Test.Next` is encouraged for a smoother migration.let constant_to_michelson_program: (_: string) => michelson_program
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.parse` from `Test.Next` is encouraged for a smoother migration.Turn a constant (as a string) into a michelson_program. To be
used together with Test.register_constant.
let parse_michelson: (_: string) => michelson_program
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.parse` from `Test.Next` is encouraged for a smoother migration.Parses Michelson (as string) into a michelson_program.
let restore_context: (_: unit) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.restore` from `Test.Next` is encouraged for a smoother migration.Pops a testing framework context from the stack of contexts, and sets it up as the new current context. In case the stack was empty, the current context is kept.
let save_context: (_: unit) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.save` from `Test.Next` is encouraged for a smoother migration.Takes current testing framework context and saves it, pushing it into a stack of contexts.
let drop_context: (_: unit) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.drop` from `Test.Next` is encouraged for a smoother migration.Drops a testing framework context from the stack of contexts. In case the stack was empty, nothing is done.
let to_string: <a>(_: a) => string
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `String.show` from `Test.Next` is encouraged for a smoother migration.Converts a value to a string (same conversion as used by
Test.log).
let to_json: <a>(_: a) => string
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `String.json` from `Test.Next` is encouraged for a smoother migration.Converts a value to its JSON representation (as a string).
let to_debugger_json: <a>(_: a) => string
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `String.debugger_json` from `Test.Next` is encouraged for a smoother migration.let set_baker_policy: (_: test_baker_policy) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.set_baker_policy` from `Test.Next` is encouraged for a smoother migration.Forces the baking policy for Test.transfer and
Test.originate. By default, the first bootstrapped account.
let set_baker: (_: address) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.set_baker` from `Test.Next` is encouraged for a smoother migration.Forces the baker for Test.transfer and Test.originate,
implemented using Test.set_baker_policy with By_account. By
default, the first bootstrapped account.
let size: <p, s>(_: michelson_contract<p, s>) => int
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.Contract.size` from `Test.Next` is encouraged for a smoother migration.Measures the size of a contract.
let compile_contract: <p, s>(_: (_: [p, s]) => [list<operation>, s]) => michelson_contract<p, s>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.Contract.compile` from `Test.Next` is encouraged for a smoother migration.Compiles a contract from an entrypoint function.
let read_contract_from_file: <p, s>(_: string) => michelson_contract<p, s>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.Contract.from_file` from `Test.Next` is encouraged for a smoother migration.Reads a contract from a .tz file.
let chr: (_: nat) => option<string>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `String.chr` from `Test.Next` is encouraged for a smoother migration.String consisting of the character represented by a nat in the
interval [0, 255].
let nl: string
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `String.nl` from `Test.Next` is encouraged for a smoother migration.String consisting of only a newline.
let println: (_: string) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `IO.println` from `Test.Next` is encouraged for a smoother migration.Prints an string to stdout, ended with a newline.
let set_print_values: (_: unit) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `IO.set_test_print` from `Test.Next` is encouraged for a smoother migration.Turns on the printing of test prefixed values at the end of
tests. This is the default behaviour.
let unset_print_values: (_: unit) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `IO.unset_test_print` from `Test.Next` is encouraged for a smoother migration.Turns off the printing of test prefixed values at the end of
tests.
let get_last_events_from: <a, p, s>(_: typed_address<p, s>) => (_: string) => list<a>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.last_events` from `Test.Next` is encouraged for a smoother migration.Returns the list of all the event payloads emited with a given tag by a given address. Any call to this function must be annotated with the expected payload type.
let transfer: <p, s>(_: typed_address<p, s>) => (_: p) => (_: tez) => test_exec_result
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Typed_address.transfer` from `Test.Next` is encouraged for a smoother migration.Bakes a transaction by sending an amount of tez with a parameter from the current source to another account. Returns the amount of gas consumed by the execution of the contract.
let transfer_exn: <p, s>(_: typed_address<p, s>) => (_: p) => (_: tez) => nat
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Typed_address.transfer_exn` from `Test.Next` is encouraged for a smoother migration.Bakes a transaction by sending an amount of tez with a parameter
from the current source to another account. Returns the amount of
gas consumed by the execution of the contract. Similar as
Test.transfer, but fails when anything goes wrong.
let log: <a>(_: a) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `IO.log` from `Test.Next` is encouraged for a smoother migration.Logs a value.
let reset_state: (_: nat) => (_: list<tez>) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.reset` from `Test.Next` is encouraged for a smoother migration.Generates a number of random bootstrapped accounts with a
default amount of 4000000 tez. The passed list can be used to
overwrite the amount. By default, the state only has two
bootstrapped accounts. Notice that since Ithaca, a percentage of
an account's balance is frozen (5% in testing mode) in case the
account can be taken to be a validator, and thus
Test.get_balance can show a different amount to the one being
set with Test.reset_state.
let reset_state_at: (_: timestamp) => (_: nat) => (_: list<tez>) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.reset_at` from `Test.Next` is encouraged for a smoother migration.Generates a number of random bootstrapped accounts with a
default amount of 4000000 tez. The passed list can be used to
overwrite the amount. By default, the state only has two
bootstrapped accounts. Notice that since Ithaca, a percentage of
an account's balance is frozen (5% in testing mode) in case the
account can be taken to be a validator, and thus
Test.get_balance can show a different amount to the one being
set with Test.reset_state. It also takes a starting timestamp
for the genesis block.
let bootstrap_contract: <p, s>(_: (_: [p, s]) => [list<operation>, s]) => (_: s) => (_: tez) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.Reset.add_func_contract` from `Test.Next` is encouraged for a smoother migration.Setup a bootstrap contract with an entrypoint function, initial storage and initial balance. Bootstrap contracts will be loaded in order, and they will be available only after reset.
let mutate_value: <a>(_: nat) => (_: a) => option<[a, mutation]>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Mutation.value` from `Test.Next` is encouraged for a smoother migration.Mutates a value using a natural number as an index for the available mutations, returns an option for indicating whether mutation was successful or not.
let save_mutation: (_: string) => (_: mutation) => option<string>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Mutation.save` from `Test.Next` is encouraged for a smoother migration.This function reconstructs a file from a mutation (second
argument), and saves it to a file in the directory path (first
argument). It returns an optional string indicating the filename
where the mutation was saved, or None if there was an error.
let sign: (_: string) => (_: bytes) => signature
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Crypto.sign` from `Test.Next` is encouraged for a smoother migration.Creates a signature of bytes from a string representing a secret
key, it can be checked with Crypto.check.
let add_account: (_: string) => (_: key) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Account.add` from `Test.Next` is encouraged for a smoother migration.Adds an account specfied by secret key & public key to the test context.
let baker_account: (_: [string, key]) => (_: option<tez>) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.Reset.add_baker` from `Test.Next` is encouraged for a smoother migration.Adds an account (sk, pk) as a baker. The change is only
effective after Test.reset_state.
let set_big_map: <a, b>(_: int) => (_: big_map<a, b>) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `State.set_big_map` from `Test.Next` is encouraged for a smoother migration.The testing framework keeps an internal reference to the values corresponding to big map identifiers. This function allows to override the value of a particular big map identifier. It should not be normally needed, except in particular circumstances such as using custom bootstrap contracts that initialize big maps.
let transfer_to_contract: <p>(_: contract<p>) => (_: p) => (_: tez) => test_exec_result
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Contract.transfer` from `Test.Next` is encouraged for a smoother migration.Bake a transaction by sending an amount of tez with a parameter from the current source to a contract. Returns the amount of gas consumed by the execution of the contract.
let transfer_to_contract_exn: <p>(_: contract<p>) => (_: p) => (_: tez) => nat
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Contract.transfer_exn` from `Test.Next` is encouraged for a smoother migration.Bakes a transaction by sending an amount of tez with a parameter
from the current source to a contract. Returns the amount of gas
consumed by the execution of the contract. Similar as
Test.transfer_to_contract, but fails when anything goes
wrong.
let michelson_equal: (_: michelson_program) => (_: michelson_program) => bool
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Compare.eq` from `Test.Next` is encouraged for a smoother migration.Compares two Michelson values.
let to_entrypoint: <a, b, c>(_: string) => (_: typed_address<a, b>) => contract<c>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Typed_address.get_entrypoint` from `Test.Next` is encouraged for a smoother migration.Gets the contract corresponding to an entrypoint of a typed address: the contract parameter in the result will be the type of the entrypoint, it needs to be annotated, entrypoint string should omit the prefix "%", but if passed a string starting with "%", it will be removed (and a warning emitted).
let storage_with_dynamic_entrypoints: <p, s, s2>(_: module_contract<p, s>, s: s2) => { dynamic_entrypoints: dynamic_entrypoints; storage: s2 }
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Dynamic_entrypoints.storage` from `Test.Next` is encouraged for a smoother migration.let originate_contract: <p, s>(_: michelson_contract<p, s>) => (_: s) => (_: tez) => typed_address<p, s>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Originate.michelson` from `Test.Next` is encouraged for a smoother migration.Originate a contract with initial storage and initial balance.
let compile_contract_with_views: <p, s>(_: (_: [p, s]) => [list<operation>, s]) => (_: views<s>) => michelson_contract<p, s>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.Contract.compile_with_views` from `Test.Next` is encouraged for a smoother migration.let originate: <p, s>(_: module_contract<p, s>) => (_: s) => (_: tez) => origination_result<p, s>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Originate.contract` from `Test.Next` is encouraged for a smoother migration.Originate a contract with an entrypoint function in curried form, initial storage and initial balance.
let compile_contract_from_file: <p, s>(_: string) => michelson_contract<p, s>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Michelson.Contract.from_file` from `Test.Next` is encouraged for a smoother migration.Compiles a contract with a path to the contract file, an entrypoint, and a list of views.
let originate_from_file: <p, s>(_: string) => (_: s) => (_: tez) => origination_result<p, s>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Originate.from_file` from `Test.Next` is encouraged for a smoother migration.Originate a contract with a path to the contract file, an entrypoint, and a list of views, together with an initial storage and an initial balance.
let mutation_test: <a, b>(_: a) => (_: (_: a) => b) => option<[b, mutation]>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Mutation.func` from `Test.Next` is encouraged for a smoother migration.Given a value to mutate (first argument), it will try all the mutations available of it, passing each one to the function (second argument). On the first case of non failure when running the function on a mutation, the value and mutation involved will be returned.
let mutation_test_all: <a, b>(_: a) => (_: (_: a) => b) => list<[b, mutation]>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Mutation.All.func` from `Test.Next` is encouraged for a smoother migration.Given a value to mutate (first argument), it will try all the mutations of it, passing each one to the function (second argument). In case no failure arises when running the function on a mutation, the failure and mutation involved will be added to the list to be returned.
let originate_from_file_and_mutate: <b, p, s>(_: string) => (_: s) => (_: tez) => (_: (_: [typed_address<p, s>, michelson_contract<p, s>, int]) => b) => option< [b, mutation] >
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Mutation.from_file` from `Test.Next` is encouraged for a smoother migration.Given a contract from a file (passed by filepath, entrypoint and views), an initial storage and balance, it will originate mutants of the contract and pass the result to the function (last argument). On the first case of non failure when running the function on a mutation, the value and mutation involved will be returned.
let originate_from_file_and_mutate_all: <b, p, s>(_: string) => (_: s) => (_: tez) => (_: (_: [typed_address<p, s>, michelson_contract<p, s>, int]) => b) => list< [b, mutation] >
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Mutation.All.from_file` from `Test.Next` is encouraged for a smoother migration.Given a contract from a file (passed by filepath, entrypoint and views), an initial storage and balance, it will originate mutants of the contract and pass the result to the function (last argument). In case no failure arises when running the function on a mutation, the failure and mutation involved will be added to the list to be returned.
let originate_module_and_mutate: <p, s, b>(_: module_contract<p, s>) => (_: s) => (_: tez) => ( _: (_: typed_address<p, s>) => (_: michelson_contract<p, s>) => (_: int) => b ) => option<[b, mutation]>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Mutation.contract` from `Test.Next` is encouraged for a smoother migration.Given a contract as a module/namespace, an initial storage and balance, it will originate mutants of the contract and pass the result to the function (last argument). On the first case of non failure when running the function on a mutation, the value and mutation involved will be returned.
let originate_and_mutate_all: <p, s, b>(_: module_contract<p, s>) => (_: s) => (_: tez) => ( _: (_: typed_address<p, s>) => (_: michelson_contract<p, s>) => (_: int) => b ) => list<[b, mutation]>
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Mutation.All.contract` from `Test.Next` is encouraged for a smoother migration.Given a contract as a module/namespace, an initial storage and balance, it will originate mutants of the contract and pass the result to the function (last argument). In case no failure arises when running the function on a mutation, the failure and mutation involved will be added to the list to be returned.
let assert: (_: bool) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Assert.assert` from `Test.Next` is encouraged for a smoother migration.The call assert(cond) terminates the execution with the string
"failed assertion" if, and only if, the boolean condition cond
is false. The failure is handled by LIGO's testing framework and
not by Michelson's interpreter.
let assert_some: <a>(_: option<a>) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Assert.some` from `Test.Next` is encouraged for a smoother migration.The call assert_some(opt) terminates the execution with the
string "failed assert some" if, and only if, opt is None().
The failure is handled by LIGO's testing framework and
not by Michelson's interpreter.
let assert_none: <a>(_: option<a>) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Assert.none` from `Test.Next` is encouraged for a smoother migration.The call assert_none(opt) terminates the execution with the string
"failed assert none" if, and only if, opt is not None().
The failure is handled by LIGO's testing framework and
not by Michelson's interpreter.
let assert_with_error: (b: bool, s: string) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Assert.Error.assert` from `Test.Next` is encouraged for a smoother migration.The call assert_with_error(cond, error) terminates the execution
with the string error (that is, an error message) if, and only
if, the boolean condition cond is false. The failure is handled
by LIGO's testing framework and not by Michelson's interpreter.
let assert_some_with_error: <a>(_: option<a>) => (_: string) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Assert.Error.some` from `Test.Next` is encouraged for a smoother migration.The call assert_some_with_error(opt, err) terminates the
execution with the string err (that is, an error message) if,
and only if, opt is None(). The failure is handled by LIGO's
testing framework and not by Michelson's interpreter.
let assert_none_with_error: <a>(_: option<a>) => (_: string) => unit
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Assert.Error.none` from `Test.Next` is encouraged for a smoother migration.The call assert_none_with_error(opt, err) terminates the
execution with the string err (that is, an error message) if,
and only if, opt is an optional value different from
None(). The failure is handled by LIGO's testing framework and
not by Michelson's interpreter.
let equal: <a>(_: a) => (_: a) => bool
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Compare.eq` from `Test.Next` is encouraged for a smoother migration.The call equal(x, y) returns true if, and only if, x and y
are considered to be equal w.r.t. the order on the underlying
type.
let not_equal: <a>(_: a) => (_: a) => bool
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Compare.neq` from `Test.Next` is encouraged for a smoother migration.The call not_equal(x, y) returns true if, and only if, x and
y are not considered to be equal w.r.t. the order on the
underlying type.
let greater: <a>(_: a) => (_: a) => bool
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Compare.gt` from `Test.Next` is encouraged for a smoother migration.The call greater(x, y) returns true if, and only if, x is
considered to be greater than y w.r.t. the order on the
underlying type.
let less: <a>(_: a) => (_: a) => bool
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Compare.lt` from `Test.Next` is encouraged for a smoother migration.The call less(x, y) returns true if, and only if, x is
considered to be less than y w.r.t. the order on the underlying
type.
let greater_or_equal: <a>(_: a) => (_: a) => bool
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Compare.ge` from `Test.Next` is encouraged for a smoother migration.The call greater_or_equal(x, y) returns true if, and only if,
x is considered to be greater or equal than y w.r.t. the order
on the underlying type.
let less_or_equal: <a>(_: a) => (_: a) => bool
**Deprecated:** In a future version, `Test` will be replaced by `Test.Next`, and using `Compare.le` from `Test.Next` is encouraged for a smoother migration.The call less_or_equal(x, y) returns true if, and only if, x
is considered to be less or equal than y w.r.t. the order on the
underlying type.