diff --git a/CHANGES.rst b/CHANGES.rst index 6613a30c9c39d6b9fdab5ddc513db0adde67aa55..fee94b7b90aa61a3dded4a6a11eb492e8ca92224 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -38,6 +38,9 @@ Node Client ------ +- Extended the support for the TZT format when using the ``run unit + tests`` client command. (MR :gl:`!4474`) + Baker ----- diff --git a/docs/alpha/michelson.rst b/docs/alpha/michelson.rst index 65d2d48707aff2ce1ff1daf89640d4efc39636fa..009552a51155fad393892191dc1605596be765bd 100644 --- a/docs/alpha/michelson.rst +++ b/docs/alpha/michelson.rst @@ -2331,16 +2331,15 @@ raise: instruction and the topmost element of the stack at this point was ````; - - ``MutezOverflow``: an addition or multiplication on type ``mutez`` - produced a result which was too large to be represented as a value - of type ``mutez``; - - ``MutezUnderflow``: a mutez subtraction resulted in a negative value. This should only happen in the case of the deprecated ``mutez`` case of the ``SUB`` instruction; - - ``GeneralOverflow``: the number of bits to shift using the ``LSL`` - or ``LSR`` instruction was too large; + - ``Overflow``: an overflow was detected. This can happen when an + addition or multiplication on type ``mutez`` produces a result + which is too large to be represented as a value of type ``mutez``, + or when the number of bits to shift using the ``LSL`` or ``LSR`` + instruction is too large. The following example shows how to test a runtime failure; it asserts diff --git a/docs/nairobi/michelson.rst b/docs/nairobi/michelson.rst index 511ac5a9faa48ae67a14506c09cd77710be24a91..78334f5f4b82067764eb93848481f444cc84f7f3 100644 --- a/docs/nairobi/michelson.rst +++ b/docs/nairobi/michelson.rst @@ -3382,16 +3382,15 @@ raise: instruction and the topmost element of the stack at this point was ````; - - ``MutezOverflow``: an addition or multiplication on type ``mutez`` - produced a result which was too large to be represented as a value - of type ``mutez``; - - ``MutezUnderflow``: a mutez subtraction resulted in a negative value. This should only happen in the case of the deprecated ``mutez`` case of the ``SUB`` instruction; - - ``GeneralOverflow``: the number of bits to shift using the ``LSL`` - or ``LSR`` instruction was too large; + - ``Overflow``: an overflow was detected. This can happen when an + addition or multiplication on type ``mutez`` produces a result + which is too large to be represented as a value of type ``mutez``, + or when the number of bits to shift using the ``LSL`` or ``LSR`` + instruction is too large. The following example shows how to test a runtime failure; it asserts diff --git a/src/proto_alpha/lib_client/client_proto_tzt.ml b/src/proto_alpha/lib_client/client_proto_tzt.ml index a83b5894ad145163df644b4ee5229421324894be..1b2c2c4a2a1bcdbf784de97b9f95591219a8b050 100644 --- a/src/proto_alpha/lib_client/client_proto_tzt.ml +++ b/src/proto_alpha/lib_client/client_proto_tzt.ml @@ -7,56 +7,172 @@ open Protocol open Alpha_context +open Tezos_micheline type unit_test_with_source = { source : string; parsed : string Michelson_v1_parser.parser_result; } -let print_stack out l = Michelson_v1_printer.print_typed_stack out l +let convert_error trace = + let open Result_syntax in + let open Micheline in + function + | Script_interpreter.Reject (_loc, value, _trace) -> + let value = Michelson_v1_primitives.strings_of_prims value in + return (Prim (0, "Failed", [root value], [])) + | Tez_repr.Addition_overflow _ | Tez_repr.Multiplication_overflow _ + | Script_interpreter.Overflow _ -> + return (Prim (0, "Overflow", [], [])) + | Tez_repr.Subtraction_underflow (a, b) -> + return + (Prim + ( 0, + "MutezUnderflow", + [ + Int (0, Z.of_int64 @@ Tez_repr.to_mutez a); + Int (0, Z.of_int64 @@ Tez_repr.to_mutez b); + ], + [] )) + | Tez_repr.Negative_multiplicator _ -> return (Prim (0, "NegMul", [], [])) + | Tez_repr.Invalid_divisor _ -> return (Prim (0, "InvalidDivisor", [], [])) + | Raw_context.Operation_quota_exceeded | Raw_context.Block_quota_exceeded -> + return (Prim (0, "Gas_exhaustion", [], [])) + | _ -> + return + (Prim + ( 0, + "StaticError", + [String (0, Format.asprintf "%a" Error_monad.pp_print_trace trace)], + [] )) + +let convert_trace = function + | Environment.Ecoproto_error err :: _ as trace -> convert_error trace err + | _ -> assert false + +let match_output ~got ~expected = + let open Result_syntax in + let open Micheline in + let rec match_pattern pattern expression = + match (pattern, expression) with + (* Wildcard *) + | Prim (_, "_", [], []), _ -> true + (* Int *) + | Int (_p_loc, p), Int (_e_loc, e) -> Z.equal p e + | Int _, _ | _, Int _ -> false + (* String *) + | String (_p_loc, p), String (_e_loc, e) -> Compare.String.(p = e) + | String _, _ | _, String _ -> false + (* Bytes *) + | Bytes (_p_loc, p), Bytes (_e_loc, e) -> Compare.Bytes.(p = e) + | Bytes _, _ | _, Bytes _ -> false + (* Seq *) + | Seq (_p_loc, p), Seq (_e_loc, e) -> ( + match List.for_all2 ~when_different_lengths:() match_pattern p e with + | Ok b -> b + | Error () -> false) + | Seq _, _ | _, Seq _ -> false + (* Prim *) + | ( Prim (_p_loc, p_prim, p_args, p_annots), + Prim (_e_loc, e_prim, e_args, e_annots) ) -> ( + Compare.String.(p_prim = "_" || p_prim = e_prim) + && (match + List.for_all2 + ~when_different_lengths:() + match_pattern + p_args + e_args + with + | Ok b -> b + | Error () -> false) + && + match + List.for_all2 + ~when_different_lengths:() + Compare.String.( = ) + p_annots + e_annots + with + | Ok b -> b + | Error () -> false) + in + if match_pattern expected got then return_unit + else + let pp fmt e = + Micheline_printer.print_expr_unwrapped + fmt + (Micheline_printer.printable Fun.id (Micheline.strip_locations e)) + in + (* TODO: proper error instead of failwith *) + error_with "Got output: %a@.Expected: %a@." pp got pp expected let run_unit_test (cctxt : #Protocol_client_context.rpc_context) ~(chain : Chain_services.chain) ~block ~(test : unit_test_with_source) () = let open Lwt_result_syntax in let*? ut = Michelson_v1_stack.parse_unit_test test.parsed in - let* chain_id = Chain_services.chain_id cctxt ~chain () in - let amount = Tez.zero in - let* expected_output = - Plugin.RPC.Scripts.normalize_stack - cctxt - (chain, block) - ~stack:ut.output - ~unparsing_mode:Readable - ~legacy:true - ~other_contracts:None - ~extra_big_maps:None + let all_contracts = + let other_contracts = + Option.value ~default:[] ut.optional.other_contracts + in + match (ut.optional.self, ut.optional.parameter) with + | Some self, Some param -> + RPC.Scripts.S.{address = self; ty = param} :: other_contracts + | None, _ | Some _, None -> other_contracts + in + let* chain_id = + match ut.optional.chain_id with + | Some chain_id -> return chain_id + | None -> Chain_services.chain_id cctxt ~chain () + in + let amount = Option.value ~default:Tez.zero ut.optional.amount in + let*! res = + match ut.output with + | Micheline.Seq _ as stack -> + let*? stack = Michelson_v1_stack.parse_stack ~node:stack test.parsed in + let* stack = + Plugin.RPC.Scripts.normalize_stack + cctxt + (chain, block) + ~stack + ~unparsing_mode:Readable + ~legacy:true + ~other_contracts:(Some all_contracts) + ~extra_big_maps:ut.optional.extra_big_maps + in + return (Michelson_v1_printer.unparse_stack 0 stack) + | expected_output -> return expected_output in - let* output, _gas = + (* Wildcard patterns in output stack is incompatible with output stack normalization. + When the output stack contains a wildcard pattern, the normalization is expected + to fail. To support wildcard patterns, we silently skip output stack normalization + when it fails. *) + let expected_output = match res with Ok x -> x | Error _ -> ut.output in + let*! res = Plugin.RPC.Scripts.run_instr ~legacy:true ~gas:None ~input:ut.input ~code:ut.code - ~now:None - ~level:None - ~sender:None - ~source:None + ~now:ut.optional.now + ~level:ut.optional.level + ~sender:ut.optional.sender + ~source:ut.optional.source ~chain_id - ~self:None - ~parameter:None + ~self:ut.optional.self + ~parameter:ut.optional.parameter ~amount - ~balance:None - ~other_contracts:None - ~extra_big_maps:None + ~balance:ut.optional.balance + ~other_contracts:(Some all_contracts) + ~extra_big_maps:ut.optional.extra_big_maps ~unparsing_mode:None cctxt (chain, block) in - if output = expected_output then return_unit - else - failwith - "Output: %a@.Expected: %a@." - print_stack - output - print_stack - expected_output + let*? output = + match res with + | Ok (output, _gas) -> + Result_syntax.return (Michelson_v1_printer.unparse_stack 0 output) + | Error err -> convert_trace err + in + let*? () = match_output ~expected:expected_output ~got:output in + return_unit diff --git a/src/proto_alpha/lib_client/michelson_v1_printer.ml b/src/proto_alpha/lib_client/michelson_v1_printer.ml index 44568e84a4390f0b631e9ddb47c734d628b16b81..6b4086c46a5c613d6ae1003fa20b0868972b540e 100644 --- a/src/proto_alpha/lib_client/michelson_v1_printer.ml +++ b/src/proto_alpha/lib_client/michelson_v1_printer.ml @@ -31,21 +31,23 @@ open Micheline_printer let anon = {comment = None} -let node_of_expr expr = +let node_of_expr loc expr = expr |> Michelson_v1_primitives.strings_of_prims - |> Micheline.inject_locations (fun _ -> anon) + |> Micheline.inject_locations (fun _ -> loc) -let node_of_stack_elt (ty, x) = - let ty = node_of_expr ty in - let x = node_of_expr x in - Micheline.Prim (anon, "Stack_elt", [ty; x], []) +let node_of_stack_elt loc (ty, x) = + let ty = node_of_expr loc ty in + let x = node_of_expr loc x in + Micheline.Prim (loc, "Stack_elt", [ty; x], []) -let print_typed_stack out l = - print_expr out (Micheline.Seq (anon, List.map node_of_stack_elt l)) +let unparse_stack loc l = Micheline.Seq (loc, List.map (node_of_stack_elt loc) l) -let print_expr ppf expr = print_expr ppf (node_of_expr expr) +let print_typed_stack out l = print_expr out (unparse_stack anon l) -let print_expr_unwrapped ppf expr = print_expr_unwrapped ppf (node_of_expr expr) +let print_expr ppf expr = print_expr ppf (node_of_expr anon expr) + +let print_expr_unwrapped ppf expr = + print_expr_unwrapped ppf (node_of_expr anon expr) let print_stack ppf = function | [] -> Format.fprintf ppf "[]" diff --git a/src/proto_alpha/lib_client/michelson_v1_printer.mli b/src/proto_alpha/lib_client/michelson_v1_printer.mli index 01ee9c498a1180343cadaa9079e782d7a874dcaf..f70b423c058fbe511dc53f7f0557d735c8f79806 100644 --- a/src/proto_alpha/lib_client/michelson_v1_printer.mli +++ b/src/proto_alpha/lib_client/michelson_v1_printer.mli @@ -31,6 +31,11 @@ val print_expr : Format.formatter -> Script_repr.expr -> unit val print_expr_unwrapped : Format.formatter -> Script_repr.expr -> unit +val unparse_stack : + 'location -> + (Script_repr.expr * Script_repr.expr) list -> + ('location, string) Micheline.node + val print_typed_stack : Format.formatter -> (Script_repr.expr * Script_repr.expr) list -> unit diff --git a/src/proto_alpha/lib_client/michelson_v1_stack.ml b/src/proto_alpha/lib_client/michelson_v1_stack.ml index 70732e703a49978bba70a73367fce7bab92a28bb..00dad07eec4e3c7f18d0bf629a0a8b0f234dd668 100644 --- a/src/proto_alpha/lib_client/michelson_v1_stack.ml +++ b/src/proto_alpha/lib_client/michelson_v1_stack.ml @@ -405,10 +405,25 @@ let parse_extra_big_maps ?node parsed = ~error:(fun node -> Wrong_extra_big_maps node) parse_extra_big_map_item +type unit_test_optional = { + now : Script_timestamp.t option; + level : Script_int.n Script_int.num option; + sender : Contract.t option; + source : Signature.public_key_hash option; + chain_id : Chain_id.t option; + self : Contract_hash.t option; + parameter : Script.expr option; + amount : Tez.t option; + balance : Tez.t option; + other_contracts : RPC.Scripts.S.other_contract_description list option; + extra_big_maps : RPC.Scripts.S.extra_big_map_description list option; +} + type unit_test = { input : (Script.expr * Script.expr) list; code : Script.expr; - output : (Script.expr * Script.expr) list; + output : (Micheline.canonical_location, string) Micheline.node; + optional : unit_test_optional; } (* Same as unit_test but all fields are optional. Used only during @@ -416,9 +431,77 @@ type unit_test = { type temp_unit_test = { temp_input : (Script.expr * Script.expr) list option; temp_code : Script.expr option; - temp_output : (Script.expr * Script.expr) list option; + temp_output : (Micheline.canonical_location, string) Micheline.node option; + temp_optional : unit_test_optional; } +(* Same as Option.value_fe but takes an error instead of a trace. *) +let value_fe_err opt ~error = + Option.value_fe opt ~error:(fun () -> TzTrace.make (error ())) + +(* TODO: #6678 + Reuse protocol elaboration functions from the + Script_ir_translator module instead of duplicating them here. *) +let parse_mutez node ~error = + let mutez_opt = + match node with + | Micheline.Int (_loc, z) -> Tez.of_mutez (Z.to_int64 z) + | _ -> None + in + value_fe_err mutez_opt ~error + +let parse_chain_id node ~error = + match node with + | Micheline.String (_loc, s) -> + record_trace_eval error @@ Chain_id.of_b58check s + | Bytes (_loc, b) -> + value_fe_err ~error + @@ Data_encoding.Binary.of_bytes_opt Chain_id.encoding b + | _ -> Result_syntax.tzfail @@ error () + +let parse_timestamp node ~error = + value_fe_err ~error + @@ + match node with + | Micheline.String (_loc, s) -> Script_timestamp.of_string s + | Int (_loc, z) -> Some (Script_timestamp.of_zint z) + | _ -> None + +let parse_nat node ~error = + value_fe_err ~error + @@ + match node with + | Micheline.Int (_loc, z) -> Script_int.(is_nat (of_zint z)) + | _ -> None + +let parse_key_hash node ~error = + match node with + | Micheline.String (_loc, s) -> + record_trace_eval error @@ Signature.Public_key_hash.of_b58check s + | Bytes (_loc, b) -> + value_fe_err ~error + @@ Data_encoding.Binary.of_bytes_opt Signature.Public_key_hash.encoding b + | _ -> Result_syntax.tzfail @@ error () + +let parse_address node ~error = + match node with + | Micheline.String (_loc, s) -> + record_trace_eval error @@ Environment.wrap_tzresult + @@ Contract.of_b58check s + | Bytes (_loc, b) -> + value_fe_err ~error + @@ Data_encoding.Binary.of_bytes_opt Contract.encoding b + | _ -> Result_syntax.tzfail @@ error () + +let parse_contract_hash node ~error = + value_fe_err ~error + @@ + match node with + | Micheline.String (_loc, s) -> Contract_hash.of_b58check_opt s + | Bytes (_loc, b) -> + Data_encoding.Binary.of_bytes_opt Contract_hash.encoding b + | _ -> None + let parse_unit_test (parsed : string Michelson_v1_parser.parser_result) = let open Result_syntax in let open Micheline in @@ -441,12 +524,100 @@ let parse_unit_test (parsed : string Michelson_v1_parser.parser_result) = parse {ut with temp_input = Some items} l | "output" -> let* () = check_duplicated ut.temp_output in - let* items = trace_invalid_format @@ parse_stack ~node:arg parsed in - parse {ut with temp_output = Some items} l + parse {ut with temp_output = Some arg} l | "code" -> let* () = check_duplicated ut.temp_code in let* c = trace_invalid_format @@ parse_expression arg in parse {ut with temp_code = Some c} l + | "amount" -> + let* () = check_duplicated ut.temp_optional.amount in + let* t = parse_mutez arg ~error:invalid_format in + parse + {ut with temp_optional = {ut.temp_optional with amount = Some t}} + l + | "balance" -> + let* () = check_duplicated ut.temp_optional.balance in + let* t = parse_mutez arg ~error:invalid_format in + parse + {ut with temp_optional = {ut.temp_optional with balance = Some t}} + l + | "chain_id" -> + let* () = check_duplicated ut.temp_optional.chain_id in + let* chain_id = parse_chain_id arg ~error:invalid_format in + parse + { + ut with + temp_optional = {ut.temp_optional with chain_id = Some chain_id}; + } + l + | "now" -> + let* () = check_duplicated ut.temp_optional.now in + let* time = parse_timestamp arg ~error:invalid_format in + parse + {ut with temp_optional = {ut.temp_optional with now = Some time}} + l + | "level" -> + let* () = check_duplicated ut.temp_optional.level in + let* level = parse_nat arg ~error:invalid_format in + parse + { + ut with + temp_optional = {ut.temp_optional with level = Some level}; + } + l + | "sender" -> + let* () = check_duplicated ut.temp_optional.sender in + let* addr = parse_address arg ~error:invalid_format in + parse + { + ut with + temp_optional = {ut.temp_optional with sender = Some addr}; + } + l + | "source" -> + let* () = check_duplicated ut.temp_optional.source in + let* addr = parse_key_hash arg ~error:invalid_format in + parse + { + ut with + temp_optional = {ut.temp_optional with source = Some addr}; + } + l + | "self" -> + let* () = check_duplicated ut.temp_optional.self in + let* addr = parse_contract_hash arg ~error:invalid_format in + parse + {ut with temp_optional = {ut.temp_optional with self = Some addr}} + l + | "parameter" -> + let* () = check_duplicated ut.temp_optional.parameter in + let* ty = parse_expression arg in + parse + { + ut with + temp_optional = {ut.temp_optional with parameter = Some ty}; + } + l + | "other_contracts" -> + let* () = check_duplicated ut.temp_optional.other_contracts in + let* items = parse_other_contracts ~node:arg parsed in + parse + { + ut with + temp_optional = + {ut.temp_optional with other_contracts = Some items}; + } + l + | "big_maps" -> + let* () = check_duplicated ut.temp_optional.extra_big_maps in + let* items = parse_extra_big_maps ~node:arg parsed in + parse + { + ut with + temp_optional = + {ut.temp_optional with extra_big_maps = Some items}; + } + l | _ -> tzfail @@ Unknown_tzt_top_prim (prim, localize_node ~parsed e)) | (Prim (_loc, prim, ([] | _ :: _ :: _), _annots) as e) :: _ -> tzfail @@ Wrong_tzt_top_prim_arity (prim, localize_node ~parsed e, 1) @@ -459,7 +630,27 @@ let parse_unit_test (parsed : string Michelson_v1_parser.parser_result) = | node -> [node] in let* ut = - parse {temp_input = None; temp_code = None; temp_output = None} nodes + parse + { + temp_input = None; + temp_code = None; + temp_output = None; + temp_optional = + { + now = None; + level = None; + sender = None; + source = None; + chain_id = None; + self = None; + parameter = None; + amount = None; + balance = None; + other_contracts = None; + extra_big_maps = None; + }; + } + nodes in let check_mandatory opt prim = Option.value_e @@ -469,4 +660,4 @@ let parse_unit_test (parsed : string Michelson_v1_parser.parser_result) = let* input = check_mandatory ut.temp_input "input" in let* code = check_mandatory ut.temp_code "code" in let* output = check_mandatory ut.temp_output "output" in - return {input; code; output} + return {input; code; output; optional = ut.temp_optional} diff --git a/src/proto_alpha/lib_client/michelson_v1_stack.mli b/src/proto_alpha/lib_client/michelson_v1_stack.mli index 675758873474cfb431ae70abc16d4497d09d4be1..8408ea9004d87154d6040506e0a4a999541c2512 100644 --- a/src/proto_alpha/lib_client/michelson_v1_stack.mli +++ b/src/proto_alpha/lib_client/michelson_v1_stack.mli @@ -43,10 +43,25 @@ val parse_extra_big_maps : string Michelson_v1_parser.parser_result -> RPC.Scripts.S.extra_big_map_description list tzresult +type unit_test_optional = { + now : Script_timestamp.t option; + level : Script_int.n Script_int.num option; + sender : Contract.t option; + source : Signature.public_key_hash option; + chain_id : Chain_id.t option; + self : Contract_hash.t option; + parameter : Script.expr option; + amount : Tez.t option; + balance : Tez.t option; + other_contracts : RPC.Scripts.S.other_contract_description list option; + extra_big_maps : RPC.Scripts.S.extra_big_map_description list option; +} + type unit_test = { input : (Script.expr * Script.expr) list; code : Script.expr; - output : (Script.expr * Script.expr) list; + output : (Micheline.canonical_location, string) Micheline.node; + optional : unit_test_optional; } val parse_unit_test : diff --git a/tezt/lib_tezos/client.ml b/tezt/lib_tezos/client.ml index add64a658d982e2b6e1b5b6ef7a45a39a5eccbf6..b5020098f556f9afc178b5f902be9d6a65c7a52f 100644 --- a/tezt/lib_tezos/client.ml +++ b/tezt/lib_tezos/client.ml @@ -2203,6 +2203,22 @@ let typecheck_script ?hooks ?protocol_hash ~scripts ?no_base_dir_warnings client |> Process.check +let spawn_run_tzt_unit_tests ?hooks ?protocol_hash ~tests ?no_base_dir_warnings + client = + spawn_command ?hooks ?protocol_hash ?no_base_dir_warnings client + @@ ["run"; "unit"; "tests"; "from"] + @ tests + +let run_tzt_unit_tests ?hooks ?protocol_hash ~tests ?no_base_dir_warnings client + = + spawn_run_tzt_unit_tests + ?hooks + ?protocol_hash + ~tests + ?no_base_dir_warnings + client + |> Process.check + let spawn_run_tzip4_view ?hooks ?source ?payer ?gas ?unparsing_mode ?other_contracts ?extra_big_maps ~entrypoint ~contract ?input ?(unlimited_gas = false) client = diff --git a/tezt/lib_tezos/client.mli b/tezt/lib_tezos/client.mli index 4d0bea6f76f5251f0bb7ecaf9e9407958ce17972..da44505328c8c1524f4abcc50e98c6dc5218adf9 100644 --- a/tezt/lib_tezos/client.mli +++ b/tezt/lib_tezos/client.mli @@ -1691,6 +1691,24 @@ val spawn_typecheck_script : t -> Process.t +(** Run [octez-client run unit tests from ..]*) +val run_tzt_unit_tests : + ?hooks:Process.hooks -> + ?protocol_hash:string -> + tests:string list -> + ?no_base_dir_warnings:bool -> + t -> + unit Lwt.t + +(** Same as [run_tzt_unit_tests], but do not wait for the process to exit. *) +val spawn_run_tzt_unit_tests : + ?hooks:Process.hooks -> + ?protocol_hash:string -> + tests:string list -> + ?no_base_dir_warnings:bool -> + t -> + Process.t + (** Same as [run_tzip4_view] but does not wait for the process to exit. *) val spawn_run_tzip4_view : ?hooks:Process.hooks -> diff --git a/tezt/lib_tezos/michelson_script.ml b/tezt/lib_tezos/michelson_script.ml index 8eea2b95cdce3a0b6e64cf9484dece1c0f8fb169..14690d226d03cfea84dc8099a7e6de86ee295e78 100644 --- a/tezt/lib_tezos/michelson_script.ml +++ b/tezt/lib_tezos/michelson_script.ml @@ -25,6 +25,8 @@ let default_prefix = "michelson_test_scripts" +let default_tzt_prefix = "tzt_reference_test_suite" + type version_range = {range_start : int; range_end : int option} let unversioned_range = {range_start = 0; range_end = None} @@ -40,10 +42,12 @@ type t = { basename : string; name : string; version_range : version_range; + extension : string; depth : int; } -let pretty_string {prefix; dirname; basename; name; version_range; depth} = +let pretty_string + {prefix; dirname; basename; name; version_range; extension; depth} = let option_to_string f opt = match opt |> Option.map f with None -> "None" | Some s -> "Some " ^ s in @@ -61,34 +65,35 @@ let pretty_string {prefix; dirname; basename; name; version_range; depth} = " range_end = " ^ option_to_string string_of_int version_range.range_end; " }"; + " extension = " ^ extension; " depth = " ^ string_of_int depth; "}"; ] -let parse_basename : string -> (string * version_range) option = - let re3 = rex "(.*)_([0-9]{3,})_([0-9]{3,})\\.tz" in - let re2 = rex "(.*)_([0-9]{3,})\\.tz" in - let re1 = rex "(.*).tz" in +let parse_basename : string -> (string * version_range * string) option = + let re3 = rex "(.*)_([0-9]{3,})_([0-9]{3,})\\.(tz.*)" in + let re2 = rex "(.*)_([0-9]{3,})\\.(tz.*)" in + let re1 = rex "(.*).(tz.*)" in fun s -> - match s =~*** re3 with - | Some (name, range_start, range_end) -> + match s =~**** re3 with + | Some (name, range_start, range_end, extension) -> let version_range = { range_start = int_of_string range_start; range_end = Some (int_of_string range_end); } in - Some (name, version_range) + Some (name, version_range, extension) | None -> ( - match s =~** re2 with - | Some (name, range_start) -> + match s =~*** re2 with + | Some (name, range_start, extension) -> let version_range = {range_start = int_of_string range_start; range_end = None} in - Some (name, version_range) + Some (name, version_range, extension) | None -> ( - match s =~* re1 with - | Some name -> Some (name, unversioned_range) + match s =~** re1 with + | Some (name, extension) -> Some (name, unversioned_range, extension) | None -> None)) let memoize f = @@ -114,8 +119,18 @@ let walk (prefix, maxdepth) = else match parse_basename basename with | None -> [] - | Some (name, version_range) -> - [{prefix; dirname; basename; name; version_range; depth}] + | Some (name, version_range, extension) -> + [ + { + prefix; + dirname; + basename; + name; + version_range; + extension; + depth; + }; + ] in loop 1 [] |> List.sort (Stdlib.compare : t -> t -> int) @@ -320,3 +335,6 @@ let find_all_well_typed ?prefix ?maxdepth protocol = let find_all_ill_typed ?prefix ?maxdepth protocol = find_all ?prefix ?maxdepth protocol |> whitelist [["ill_typed"]] + +let find_all_tzt_tests ?(prefix = default_tzt_prefix) ?maxdepth protocol = + find_all ~prefix ?maxdepth protocol diff --git a/tezt/lib_tezos/michelson_script.mli b/tezt/lib_tezos/michelson_script.mli index 26323013921e1ecd0b21f495e8f88aefa8feeedf..53edcb507b2072b68e5f5d4c6d8b8c37548adfc9 100644 --- a/tezt/lib_tezos/michelson_script.mli +++ b/tezt/lib_tezos/michelson_script.mli @@ -50,6 +50,7 @@ type t = { basename : string; name : string; version_range : version_range; + extension : string; depth : int; } @@ -129,6 +130,9 @@ val find_all_well_typed : (** Returns all ill typed scripts for the given protocol. *) val find_all_ill_typed : ?prefix:string -> ?maxdepth:int -> Protocol.t -> t list +(** Returns all TZT tests from the reference test suite. *) +val find_all_tzt_tests : ?prefix:string -> ?maxdepth:int -> Protocol.t -> t list + (** The path to the script relative to [/] (the repo root). If [?no_prefix] is true, the prefix is excluded from the output string. diff --git a/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out b/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out new file mode 100644 index 0000000000000000000000000000000000000000..e6c7c670d7fa0d7172ca0f79bd972b2de35feeee --- /dev/null +++ b/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out @@ -0,0 +1,59 @@ + +./octez-client --protocol ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK --mode mockup --no-base-dir-warnings run unit tests from tzt_reference_test_suite/abs_00.tzt tzt_reference_test_suite/abs_01.tzt tzt_reference_test_suite/abs_02.tzt tzt_reference_test_suite/add_00.tc.tzt tzt_reference_test_suite/add_01.tc.tzt tzt_reference_test_suite/add_int-int_00.tzt tzt_reference_test_suite/add_int-nat_00.tzt tzt_reference_test_suite/add_int-nat_01.tzt tzt_reference_test_suite/add_int-timestamp_00.tzt tzt_reference_test_suite/add_mutez-mutez_00.tzt tzt_reference_test_suite/add_mutez-mutez_01.tzt tzt_reference_test_suite/add_nat-int_00.tzt tzt_reference_test_suite/add_nat-nat_00.tzt tzt_reference_test_suite/add_timestamp-int_00.tzt tzt_reference_test_suite/add_timestamp-int_01.tzt tzt_reference_test_suite/add_timestamp-int_02.tzt tzt_reference_test_suite/add_timestamp-int_03.tzt tzt_reference_test_suite/address_00.tzt tzt_reference_test_suite/address_00.tc.tzt tzt_reference_test_suite/address_01.tzt tzt_reference_test_suite/address_02.tzt tzt_reference_test_suite/amount_00.tzt tzt_reference_test_suite/and_bool-bool_00.tzt tzt_reference_test_suite/and_bool-bool_01.tzt tzt_reference_test_suite/and_bool-bool_02.tzt tzt_reference_test_suite/and_bool-bool_03.tzt tzt_reference_test_suite/and_bytes-bytes_00.tzt tzt_reference_test_suite/and_bytes-bytes_01.tzt tzt_reference_test_suite/and_bytes-bytes_02.tzt tzt_reference_test_suite/and_bytes-bytes_03.tzt tzt_reference_test_suite/and_int-nat_00.tzt tzt_reference_test_suite/and_int-nat_01.tzt tzt_reference_test_suite/and_int-nat_02.tzt tzt_reference_test_suite/and_int-nat_03.tzt tzt_reference_test_suite/and_int-nat_04.tzt tzt_reference_test_suite/and_int-nat_05.tzt tzt_reference_test_suite/and_int-nat_06.tzt tzt_reference_test_suite/and_nat-nat_00.tzt tzt_reference_test_suite/and_nat-nat_01.tzt tzt_reference_test_suite/and_nat-nat_02.tzt tzt_reference_test_suite/apply_00.tzt tzt_reference_test_suite/balance_00.tzt tzt_reference_test_suite/car_00.tzt tzt_reference_test_suite/car_00.tc.tzt tzt_reference_test_suite/car_01.tzt tzt_reference_test_suite/cdr_00.tzt tzt_reference_test_suite/cdr_00.tc.tzt tzt_reference_test_suite/cdr_01.tzt tzt_reference_test_suite/chain_id_00.tzt tzt_reference_test_suite/chain_id_01.tzt tzt_reference_test_suite/checksignature_00.tzt tzt_reference_test_suite/checksignature_00.tc.tzt tzt_reference_test_suite/checksignature_01.tzt tzt_reference_test_suite/compare_00.tc.tzt tzt_reference_test_suite/compare_01.tc.tzt tzt_reference_test_suite/compare_02.tc.tzt tzt_reference_test_suite/compare_bool_00.tzt tzt_reference_test_suite/compare_bool_01.tzt tzt_reference_test_suite/compare_bool_02.tzt tzt_reference_test_suite/compare_bool_03.tzt tzt_reference_test_suite/compare_bytes_00.tzt tzt_reference_test_suite/compare_bytes_01.tzt tzt_reference_test_suite/compare_bytes_02.tzt tzt_reference_test_suite/compare_bytes_03.tzt tzt_reference_test_suite/compare_bytes_04.tzt tzt_reference_test_suite/compare_int_00.tzt tzt_reference_test_suite/compare_int_01.tzt tzt_reference_test_suite/compare_int_02.tzt tzt_reference_test_suite/compare_int_03.tzt tzt_reference_test_suite/compare_int_04.tzt tzt_reference_test_suite/compare_keyhash_00.tzt tzt_reference_test_suite/compare_keyhash_01.tzt tzt_reference_test_suite/compare_keyhash_02.tzt tzt_reference_test_suite/compare_mutez_00.tzt tzt_reference_test_suite/compare_mutez_01.tzt tzt_reference_test_suite/compare_mutez_02.tzt tzt_reference_test_suite/compare_mutez_03.tzt tzt_reference_test_suite/compare_mutez_04.tzt tzt_reference_test_suite/compare_mutez_05.tzt tzt_reference_test_suite/compare_nat_00.tzt tzt_reference_test_suite/compare_nat_01.tzt tzt_reference_test_suite/compare_nat_02.tzt tzt_reference_test_suite/compare_nat_03.tzt tzt_reference_test_suite/compare_nat_04.tzt tzt_reference_test_suite/compare_nat_05.tzt tzt_reference_test_suite/compare_pairintint_00.tzt tzt_reference_test_suite/compare_pairintint_01.tzt tzt_reference_test_suite/compare_pairintint_02.tzt tzt_reference_test_suite/compare_pairintint_03.tzt tzt_reference_test_suite/compare_string_00.tzt tzt_reference_test_suite/compare_string_01.tzt tzt_reference_test_suite/compare_string_02.tzt tzt_reference_test_suite/compare_string_03.tzt tzt_reference_test_suite/compare_string_04.tzt tzt_reference_test_suite/compare_timestamp_00.tzt tzt_reference_test_suite/compare_timestamp_01.tzt tzt_reference_test_suite/compare_timestamp_02.tzt tzt_reference_test_suite/compare_timestamp_03.tzt tzt_reference_test_suite/compare_timestamp_04.tzt tzt_reference_test_suite/compare_timestamp_05.tzt tzt_reference_test_suite/concat_bytes_00.tzt tzt_reference_test_suite/concat_bytes_01.tzt tzt_reference_test_suite/concat_listbytes_00.tzt tzt_reference_test_suite/concat_listbytes_01.tzt tzt_reference_test_suite/concat_listbytes_02.tzt tzt_reference_test_suite/concat_liststring_00.tzt tzt_reference_test_suite/concat_liststring_01.tzt tzt_reference_test_suite/concat_liststring_02.tzt tzt_reference_test_suite/concat_liststring_03.tzt tzt_reference_test_suite/concat_liststring_04.tzt tzt_reference_test_suite/concat_string_00.tzt tzt_reference_test_suite/concat_string_01.tzt tzt_reference_test_suite/concat_string_02.tzt tzt_reference_test_suite/cons_int_00.tzt tzt_reference_test_suite/cons_int_01.tzt tzt_reference_test_suite/cons_int_02.tzt tzt_reference_test_suite/cons_lists_00.tc.tzt tzt_reference_test_suite/cons_string_00.tzt tzt_reference_test_suite/contract_00.tzt tzt_reference_test_suite/contract_01.tzt tzt_reference_test_suite/contract_02.tzt tzt_reference_test_suite/contract_03.tzt tzt_reference_test_suite/contract_04.tzt tzt_reference_test_suite/contract_05.tzt tzt_reference_test_suite/createcontract_00.tzt tzt_reference_test_suite/createcontract_01.tzt tzt_reference_test_suite/dig_00.tzt tzt_reference_test_suite/dig_01.tzt tzt_reference_test_suite/dig_02.tzt tzt_reference_test_suite/dig_03.tzt tzt_reference_test_suite/dig_04.tzt tzt_reference_test_suite/dip_00.tzt tzt_reference_test_suite/dip_00.tc.tzt tzt_reference_test_suite/dip_01.tzt tzt_reference_test_suite/dip_02.tzt tzt_reference_test_suite/dipn_00.tzt tzt_reference_test_suite/dipn_00.tc.tzt tzt_reference_test_suite/dipn_01.tzt tzt_reference_test_suite/dipn_01.tc.tzt tzt_reference_test_suite/dipn_02.tzt tzt_reference_test_suite/dipn_02.tc.tzt tzt_reference_test_suite/dipn_03.tzt tzt_reference_test_suite/drop_00.tzt tzt_reference_test_suite/drop_00.tc.tzt tzt_reference_test_suite/dropn_00.tzt tzt_reference_test_suite/dropn_00.tc.tzt tzt_reference_test_suite/dropn_01.tzt tzt_reference_test_suite/dropn_02.tzt tzt_reference_test_suite/dropn_03.tzt tzt_reference_test_suite/dugn_00.tzt tzt_reference_test_suite/dup_00.tzt tzt_reference_test_suite/dup_00.tc.tzt tzt_reference_test_suite/dupn_00.tzt tzt_reference_test_suite/dupn_00.tc.tzt tzt_reference_test_suite/dupn_01.tzt tzt_reference_test_suite/dupn_01.tc.tzt tzt_reference_test_suite/dupn_02.tzt tzt_reference_test_suite/dupn_03.tzt tzt_reference_test_suite/dupn_04.tzt tzt_reference_test_suite/ediv_int-int_00.tzt tzt_reference_test_suite/ediv_int-int_01.tzt tzt_reference_test_suite/ediv_int-int_02.tzt tzt_reference_test_suite/ediv_int-int_03.tzt tzt_reference_test_suite/ediv_mutez-mutez_00.tzt tzt_reference_test_suite/ediv_mutez-mutez_01.tzt tzt_reference_test_suite/ediv_mutez-mutez_02.tzt tzt_reference_test_suite/ediv_mutez-mutez_03.tzt tzt_reference_test_suite/ediv_mutez-nat_00.tzt tzt_reference_test_suite/ediv_mutez-nat_01.tzt tzt_reference_test_suite/ediv_mutez-nat_02.tzt tzt_reference_test_suite/ediv_mutez-nat_03.tzt tzt_reference_test_suite/ediv_mutez-nat_04.tzt tzt_reference_test_suite/ediv_mutez-nat_05.tzt tzt_reference_test_suite/ediv_mutez-nat_06.tzt tzt_reference_test_suite/emptybigmap_nat-nat_00.tzt tzt_reference_test_suite/emptymap_nat-nat_00.tzt tzt_reference_test_suite/emptymap_string-string_00.tzt tzt_reference_test_suite/emptyset_nat_00.tzt tzt_reference_test_suite/eq_00.tzt tzt_reference_test_suite/eq_01.tzt tzt_reference_test_suite/eq_02.tzt tzt_reference_test_suite/eq_03.tzt tzt_reference_test_suite/eq_04.tzt tzt_reference_test_suite/exec_00.tzt tzt_reference_test_suite/exec_01.tzt tzt_reference_test_suite/exec_02.tzt tzt_reference_test_suite/exec_03.tzt tzt_reference_test_suite/failwith_00.tzt tzt_reference_test_suite/failwith_00.tc.tzt tzt_reference_test_suite/gas_exhaustion.tzt tzt_reference_test_suite/ge_00.tzt tzt_reference_test_suite/ge_01.tzt tzt_reference_test_suite/ge_02.tzt tzt_reference_test_suite/ge_03.tzt tzt_reference_test_suite/ge_04.tzt tzt_reference_test_suite/get_00.tc.tzt tzt_reference_test_suite/get_bigmapstringstring_00.tzt tzt_reference_test_suite/get_bigmapstringstring_01.tzt tzt_reference_test_suite/get_bigmapstringstring_02.tzt tzt_reference_test_suite/get_map_00.tc.tzt tzt_reference_test_suite/get_mapintint_00.tzt tzt_reference_test_suite/get_mapintint_01.tzt tzt_reference_test_suite/get_mapstringstring_00.tzt tzt_reference_test_suite/get_mapstringstring_01.tzt tzt_reference_test_suite/get_mapstringstring_02.tzt tzt_reference_test_suite/gt_00.tzt tzt_reference_test_suite/gt_00.tc.tzt tzt_reference_test_suite/gt_01.tzt tzt_reference_test_suite/gt_02.tzt tzt_reference_test_suite/gt_03.tzt tzt_reference_test_suite/gt_04.tzt tzt_reference_test_suite/if_00.tzt tzt_reference_test_suite/if_00.tc.tzt tzt_reference_test_suite/if_01.tzt tzt_reference_test_suite/if_01.tc.tzt tzt_reference_test_suite/ifcons_00.tc.tzt tzt_reference_test_suite/ifcons_listint_00.tzt tzt_reference_test_suite/ifcons_listint_01.tzt tzt_reference_test_suite/ifcons_listnat_00.tzt tzt_reference_test_suite/ifcons_listnat_01.tzt tzt_reference_test_suite/ifleft_00.tc.tzt tzt_reference_test_suite/ifleft_orintstring_00.tzt tzt_reference_test_suite/ifleft_orstringint_00.tzt tzt_reference_test_suite/ifnone_00.tc.tzt tzt_reference_test_suite/ifnone_optionint_00.tzt tzt_reference_test_suite/ifnone_optionnat_00.tzt tzt_reference_test_suite/implicitaccount_00.tzt tzt_reference_test_suite/int_00.tc.tzt tzt_reference_test_suite/int_nat_00.tzt tzt_reference_test_suite/int_nat_01.tzt tzt_reference_test_suite/isnat_00.tzt tzt_reference_test_suite/isnat_01.tzt tzt_reference_test_suite/iter_00.tc.tzt tzt_reference_test_suite/iter_listint_00.tzt tzt_reference_test_suite/iter_listint_01.tzt tzt_reference_test_suite/iter_listint_02.tzt tzt_reference_test_suite/iter_listint_03.tzt tzt_reference_test_suite/iter_liststring_00.tzt tzt_reference_test_suite/iter_liststring_01.tzt tzt_reference_test_suite/iter_mapintint_00.tzt tzt_reference_test_suite/iter_mapintint_01.tzt tzt_reference_test_suite/iter_mapintint_02.tzt tzt_reference_test_suite/iter_mapintint_03.tzt tzt_reference_test_suite/iter_mapintint_04.tzt tzt_reference_test_suite/iter_mapstringstring_00.tzt tzt_reference_test_suite/iter_setint_00.tzt tzt_reference_test_suite/iter_setint_01.tzt tzt_reference_test_suite/iter_setint_02.tzt tzt_reference_test_suite/iter_setstring_00.tzt tzt_reference_test_suite/iter_setstring_01.tzt tzt_reference_test_suite/iter_setstring_02.tzt tzt_reference_test_suite/le_00.tzt tzt_reference_test_suite/le_01.tzt tzt_reference_test_suite/le_02.tzt tzt_reference_test_suite/le_03.tzt tzt_reference_test_suite/le_04.tzt tzt_reference_test_suite/left_int-nat_00.tzt tzt_reference_test_suite/loop_00.tzt tzt_reference_test_suite/loop_00.tc.tzt tzt_reference_test_suite/loop_01.tzt tzt_reference_test_suite/loop_01.tc.tzt tzt_reference_test_suite/loop_02.tzt tzt_reference_test_suite/loopleft_00.tzt tzt_reference_test_suite/loopleft_01.tzt tzt_reference_test_suite/loopleft_02.tzt tzt_reference_test_suite/loopleft_03.tzt tzt_reference_test_suite/loopleft_04.tzt tzt_reference_test_suite/lsl_00.tzt tzt_reference_test_suite/lsl_01.tzt tzt_reference_test_suite/lsl_02.tzt tzt_reference_test_suite/lsl_03.tzt tzt_reference_test_suite/lsl_04.tzt tzt_reference_test_suite/lsl_05.tzt tzt_reference_test_suite/lsl_06.tzt tzt_reference_test_suite/lsr_00.tzt tzt_reference_test_suite/lsr_01.tzt tzt_reference_test_suite/lsr_02.tzt tzt_reference_test_suite/lsr_03.tzt tzt_reference_test_suite/lsr_04.tzt tzt_reference_test_suite/lsr_05.tzt tzt_reference_test_suite/lt_00.tzt tzt_reference_test_suite/lt_01.tzt tzt_reference_test_suite/lt_02.tzt tzt_reference_test_suite/lt_03.tzt tzt_reference_test_suite/lt_04.tzt tzt_reference_test_suite/macro_pack/assert_00.tzt tzt_reference_test_suite/map_listint_00.tzt tzt_reference_test_suite/map_listint_01.tzt tzt_reference_test_suite/map_listint_02.tzt tzt_reference_test_suite/map_listint_03.tzt tzt_reference_test_suite/map_listint_04.tzt tzt_reference_test_suite/map_listint_05.tzt tzt_reference_test_suite/map_listint_06.tzt tzt_reference_test_suite/map_liststring_00.tzt tzt_reference_test_suite/map_liststring_01.tzt tzt_reference_test_suite/map_liststring_02.tzt tzt_reference_test_suite/map_liststring_04.tzt tzt_reference_test_suite/map_liststring_05.tzt tzt_reference_test_suite/map_liststring_06.tzt tzt_reference_test_suite/map_liststring_07.tzt tzt_reference_test_suite/map_liststring_08.tzt tzt_reference_test_suite/map_mapintint_00.tzt tzt_reference_test_suite/map_mapintint_01.tzt tzt_reference_test_suite/map_mapintstring_00.tzt tzt_reference_test_suite/map_mapintstring_01.tzt tzt_reference_test_suite/map_mapstringnat_00.tzt tzt_reference_test_suite/map_mapstringnat_01.tzt tzt_reference_test_suite/map_mapstringnat_02.tzt tzt_reference_test_suite/mem_bigmapnatnat_00.tzt tzt_reference_test_suite/mem_bigmapnatnat_01.tzt tzt_reference_test_suite/mem_bigmapnatnat_02.tzt tzt_reference_test_suite/mem_bigmapnatnat_03.tzt tzt_reference_test_suite/mem_bigmapnatnat_04.tzt tzt_reference_test_suite/mem_bigmapnatnat_05.tzt tzt_reference_test_suite/mem_bigmapstringnat_00.tzt tzt_reference_test_suite/mem_bigmapstringnat_01.tzt tzt_reference_test_suite/mem_bigmapstringnat_02.tzt tzt_reference_test_suite/mem_bigmapstringnat_03.tzt tzt_reference_test_suite/mem_bigmapstringnat_04.tzt tzt_reference_test_suite/mem_bigmapstringnat_05.tzt tzt_reference_test_suite/mem_mapintint_00.tzt tzt_reference_test_suite/mem_mapnatnat_00.tzt tzt_reference_test_suite/mem_mapnatnat_01.tzt tzt_reference_test_suite/mem_mapnatnat_02.tzt tzt_reference_test_suite/mem_mapnatnat_03.tzt tzt_reference_test_suite/mem_mapnatnat_04.tzt tzt_reference_test_suite/mem_mapnatnat_05.tzt tzt_reference_test_suite/mem_mapstringnat_00.tzt tzt_reference_test_suite/mem_mapstringnat_01.tzt tzt_reference_test_suite/mem_mapstringnat_02.tzt tzt_reference_test_suite/mem_mapstringnat_03.tzt tzt_reference_test_suite/mem_mapstringnat_04.tzt tzt_reference_test_suite/mem_mapstringnat_05.tzt tzt_reference_test_suite/mem_setint_00.tzt tzt_reference_test_suite/mem_setint_01.tzt tzt_reference_test_suite/mem_setstring_00.tzt tzt_reference_test_suite/mem_setstring_01.tzt tzt_reference_test_suite/mem_setstring_02.tzt tzt_reference_test_suite/mul_int-int_00.tzt tzt_reference_test_suite/mul_int-nat_00.tzt tzt_reference_test_suite/mul_mutez-nat_00.tzt tzt_reference_test_suite/mul_mutez-nat_01.tzt tzt_reference_test_suite/mul_nat-int_00.tzt tzt_reference_test_suite/mul_nat-mutez_00.tzt tzt_reference_test_suite/mul_nat-mutez_01.tzt tzt_reference_test_suite/mul_nat-nat_00.tzt tzt_reference_test_suite/neg_int_00.tzt tzt_reference_test_suite/neg_int_01.tzt tzt_reference_test_suite/neg_int_02.tzt tzt_reference_test_suite/neg_nat_00.tzt tzt_reference_test_suite/neg_nat_01.tzt tzt_reference_test_suite/neq_00.tzt tzt_reference_test_suite/neq_01.tzt tzt_reference_test_suite/neq_02.tzt tzt_reference_test_suite/neq_03.tzt tzt_reference_test_suite/neq_04.tzt tzt_reference_test_suite/nil_nat_00.tzt tzt_reference_test_suite/none_int_00.tzt tzt_reference_test_suite/none_pair-nat-string.tzt tzt_reference_test_suite/not_bool_00.tzt tzt_reference_test_suite/not_bool_01.tzt tzt_reference_test_suite/not_bytes_00.tzt tzt_reference_test_suite/not_bytes_01.tzt tzt_reference_test_suite/not_bytes_02.tzt tzt_reference_test_suite/not_int_00.tzt tzt_reference_test_suite/not_nat_00.tzt tzt_reference_test_suite/not_nat_01.tzt tzt_reference_test_suite/not_nat_02.tzt tzt_reference_test_suite/not_nat_03.tzt tzt_reference_test_suite/not_nat_04.tzt tzt_reference_test_suite/not_nat_05.tzt tzt_reference_test_suite/not_nat_06.tzt tzt_reference_test_suite/not_nat_07.tzt tzt_reference_test_suite/now_00.tzt tzt_reference_test_suite/or_bool-bool_00.tzt tzt_reference_test_suite/or_bool-bool_01.tzt tzt_reference_test_suite/or_bool-bool_02.tzt tzt_reference_test_suite/or_bool-bool_03.tzt tzt_reference_test_suite/or_bytes-bytes_00.tzt tzt_reference_test_suite/or_bytes-bytes_01.tzt tzt_reference_test_suite/or_bytes-bytes_02.tzt tzt_reference_test_suite/or_bytes-bytes_03.tzt tzt_reference_test_suite/or_nat-nat_00.tzt tzt_reference_test_suite/or_nat-nat_01.tzt tzt_reference_test_suite/or_nat-nat_02.tzt tzt_reference_test_suite/or_nat-nat_03.tzt tzt_reference_test_suite/or_nat-nat_04.tzt tzt_reference_test_suite/or_nat-nat_05.tzt tzt_reference_test_suite/or_nat-nat_06.tzt tzt_reference_test_suite/pack_address_00.tzt tzt_reference_test_suite/pack_address_01.tzt tzt_reference_test_suite/pack_address_02.tzt tzt_reference_test_suite/pack_address_03.tzt tzt_reference_test_suite/pack_address_04.tzt tzt_reference_test_suite/pack_address_05.tzt tzt_reference_test_suite/pack_bool_00.tzt tzt_reference_test_suite/pack_bool_01.tzt tzt_reference_test_suite/pack_bytes_00.tzt tzt_reference_test_suite/pack_bytes_01.tzt tzt_reference_test_suite/pack_bytes_02.tzt tzt_reference_test_suite/pack_chainid_00.tzt tzt_reference_test_suite/pack_contract_00.tzt tzt_reference_test_suite/pack_key_00.tzt tzt_reference_test_suite/pack_key_01.tzt tzt_reference_test_suite/pack_key_02.tzt tzt_reference_test_suite/pack_key_03.tzt tzt_reference_test_suite/pack_keyhash_01.tzt tzt_reference_test_suite/pack_keyhash_02.tzt tzt_reference_test_suite/pack_keyhash_03.tzt tzt_reference_test_suite/pack_keyhash_04.tzt tzt_reference_test_suite/pack_lambda_comb_pairs.tzt tzt_reference_test_suite/pack_list-bool_00.tzt tzt_reference_test_suite/pack_list-bool_01.tzt tzt_reference_test_suite/pack_list-list-bool.tzt tzt_reference_test_suite/pack_list_large_00.tzt tzt_reference_test_suite/pack_map-bool-unit_00.tzt tzt_reference_test_suite/pack_operation_00.tc.tzt tzt_reference_test_suite/pack_option-unit_00.tzt tzt_reference_test_suite/pack_option-unit_01.tzt tzt_reference_test_suite/pack_or-unit-bool_00.tzt tzt_reference_test_suite/pack_or-unit-bool_01.tzt tzt_reference_test_suite/pack_pair-bool-unit_00.tzt tzt_reference_test_suite/pack_signature_00.tzt tzt_reference_test_suite/pack_signature_01.tzt tzt_reference_test_suite/pack_signature_02.tzt tzt_reference_test_suite/pack_signature_03.tzt tzt_reference_test_suite/pack_string_00.tzt tzt_reference_test_suite/pack_string_01.tzt tzt_reference_test_suite/pack_string_02.tzt tzt_reference_test_suite/pack_string_03.tzt tzt_reference_test_suite/pack_unit_00.tzt tzt_reference_test_suite/packunpack_address_00.tzt tzt_reference_test_suite/packunpack_bool_00.tzt tzt_reference_test_suite/packunpack_bytes_00.tzt tzt_reference_test_suite/packunpack_int_00.tzt tzt_reference_test_suite/packunpack_keyhash_00.tzt tzt_reference_test_suite/packunpack_mutez_00.tzt tzt_reference_test_suite/packunpack_nat_00.tzt tzt_reference_test_suite/packunpack_string_00.tzt tzt_reference_test_suite/packunpack_timestamp_00.tzt tzt_reference_test_suite/pair_00.tc.tzt tzt_reference_test_suite/pair_int-int_00.tzt tzt_reference_test_suite/pair_nat-string_00.tzt tzt_reference_test_suite/pair_pair-nat-string-pair-string-nat_00.tzt tzt_reference_test_suite/push_00.tc.tzt tzt_reference_test_suite/push_int_00.tzt tzt_reference_test_suite/push_string_00.tzt tzt_reference_test_suite/right_nat-int_00.tzt tzt_reference_test_suite/self_00.tzt tzt_reference_test_suite/self_01.tzt tzt_reference_test_suite/self_in_lambda.tc.tzt tzt_reference_test_suite/sender_00.tzt tzt_reference_test_suite/setdelegate_00.tzt tzt_reference_test_suite/setdelegate_00.tc.tzt tzt_reference_test_suite/size_bytes_00.tzt tzt_reference_test_suite/size_listint_00.tzt tzt_reference_test_suite/size_listint_01.tzt tzt_reference_test_suite/size_listint_02.tzt tzt_reference_test_suite/size_listint_03.tzt tzt_reference_test_suite/size_mapintint_00.tzt tzt_reference_test_suite/size_mapstringnat_00.tzt tzt_reference_test_suite/size_mapstringnat_01.tzt tzt_reference_test_suite/size_mapstringnat_02.tzt tzt_reference_test_suite/size_mapstringnat_03.tzt tzt_reference_test_suite/size_setint_00.tzt tzt_reference_test_suite/size_setint_01.tzt tzt_reference_test_suite/size_setint_02.tzt tzt_reference_test_suite/size_setint_03.tzt tzt_reference_test_suite/size_setstring_00.tzt tzt_reference_test_suite/size_string_00.tzt tzt_reference_test_suite/slice_bytes_00.tzt tzt_reference_test_suite/slice_bytes_01.tzt tzt_reference_test_suite/slice_bytes_02.tzt tzt_reference_test_suite/slice_bytes_03.tzt tzt_reference_test_suite/slice_bytes_04.tzt tzt_reference_test_suite/slice_string_00.tzt tzt_reference_test_suite/slice_string_01.tzt tzt_reference_test_suite/slice_string_02.tzt tzt_reference_test_suite/slice_string_03.tzt tzt_reference_test_suite/slice_string_04.tzt tzt_reference_test_suite/slice_string_05.tzt tzt_reference_test_suite/some_00.tc.tzt tzt_reference_test_suite/some_int_00.tzt tzt_reference_test_suite/some_pairintint_00.tzt tzt_reference_test_suite/some_string_00.tzt tzt_reference_test_suite/source_00.tzt tzt_reference_test_suite/sub_int-int_00.tzt tzt_reference_test_suite/sub_int-int_01.tzt tzt_reference_test_suite/sub_mutez-mutez_00.tzt tzt_reference_test_suite/sub_mutez-mutez_01.tzt tzt_reference_test_suite/sub_timestamp-int_00.tzt tzt_reference_test_suite/sub_timestamp-int_01.tzt tzt_reference_test_suite/sub_timestamp-int_02.tzt tzt_reference_test_suite/sub_timestamp-int_03.tzt tzt_reference_test_suite/sub_timestamp-int_04.tzt tzt_reference_test_suite/sub_timestamp-timestamp_00.tzt tzt_reference_test_suite/sub_timestamp-timestamp_01.tzt tzt_reference_test_suite/sub_timestamp-timestamp_02.tzt tzt_reference_test_suite/sub_timestamp-timestamp_03.tzt tzt_reference_test_suite/swap_00.tzt tzt_reference_test_suite/swap_00.tc.tzt tzt_reference_test_suite/swap_01.tc.tzt tzt_reference_test_suite/transfertokens_00.tzt tzt_reference_test_suite/transfertokens_00.tc.tzt tzt_reference_test_suite/transfertokens_01.tzt tzt_reference_test_suite/unit_00.tzt tzt_reference_test_suite/unpair_00.tc.tzt tzt_reference_test_suite/unpair_pairstringstring_00.tzt tzt_reference_test_suite/update_00.tc.tzt tzt_reference_test_suite/update_bigmapstringstring_00.tzt tzt_reference_test_suite/update_bigmapstringstring_01.tzt tzt_reference_test_suite/update_bigmapstringstring_02.tzt tzt_reference_test_suite/update_bigmapstringstring_03.tzt tzt_reference_test_suite/update_bigmapstringstring_04.tzt tzt_reference_test_suite/update_bigmapstringstring_05.tzt tzt_reference_test_suite/update_bigmapstringstring_06.tzt tzt_reference_test_suite/update_bigmapstringstring_07.tzt tzt_reference_test_suite/update_mapintint_00.tzt tzt_reference_test_suite/update_mapintint_01.tzt tzt_reference_test_suite/update_setint_00.tzt tzt_reference_test_suite/update_setint_01.tzt tzt_reference_test_suite/update_setint_02.tzt tzt_reference_test_suite/xor_bool-bool_00.tzt tzt_reference_test_suite/xor_bool-bool_01.tzt tzt_reference_test_suite/xor_bool-bool_02.tzt tzt_reference_test_suite/xor_bool-bool_03.tzt tzt_reference_test_suite/xor_bytes-bytes_00.tzt tzt_reference_test_suite/xor_bytes-bytes_01.tzt tzt_reference_test_suite/xor_bytes-bytes_02.tzt tzt_reference_test_suite/xor_bytes-bytes_03.tzt tzt_reference_test_suite/xor_nat-nat_00.tzt tzt_reference_test_suite/xor_nat-nat_01.tzt tzt_reference_test_suite/xor_nat-nat_02.tzt tzt_reference_test_suite/xor_nat-nat_03.tzt tzt_reference_test_suite/xor_nat-nat_04.tzt tzt_reference_test_suite/xor_nat-nat_05.tzt tzt_reference_test_suite/xor_nat-nat_06.tzt +tzt_reference_test_suite/transfertokens_01.tzt: +Got output: { Stack_elt + operation + 0x011d23c1d3d2f8a4ea5e8784b8f7ecf2ad304c0fe6000000010501a9845b61ac052cdd0428af72a35bf75151dc754800ff00000000020014 } +Expected: { Stack_elt operation (Transfer_tokens 20 5 "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" _) } + +tzt_reference_test_suite/transfertokens_00.tzt: +Got output: { Stack_elt + operation + 0x011d23c1d3d2f8a4ea5e8784b8f7ecf2ad304c0fe60000000105000002298c03ed7d454a101eb7022bc95f7e5f41ac7800 } +Expected: { Stack_elt + operation + (Transfer_tokens Unit 5 "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" _) } + +tzt_reference_test_suite/setdelegate_00.tzt: +Got output: { Stack_elt + operation + 0x011d23c1d3d2f8a4ea5e8784b8f7ecf2ad304c0fe600000003ff002431516be31f3f7bb3c8169f930a024142696af7 } +Expected: { Stack_elt operation (Set_delegate (Some "tz1NwQ6hkenkn6aYYio8VnJvjtb4K1pfeU1Z") _) } + +tzt_reference_test_suite/createcontract_01.tzt: +Got output: { Stack_elt + operation + 0x011d23c1d3d2f8a4ea5e8784b8f7ecf2ad304c0fe6000000020c000000001e02000000190502020000000a0320034f053d036d03420501036c0500036c00000002030b ; + Stack_elt address "KT1Mjjcb6tmSsLm7Cb3DSQszePjfchPM4Uxm" } +Expected: { Stack_elt + operation + (Create_contract + { code { DROP ; UNIT ; NIL operation ; PAIR } ; + storage unit ; + parameter unit } + None + 12 + Unit + _) ; + Stack_elt address _ } + +tzt_reference_test_suite/createcontract_00.tzt: +Got output: { Stack_elt + operation + 0x011d23c1d3d2f8a4ea5e8784b8f7ecf2ad304c0fe6000000020cff002431516be31f3f7bb3c8169f930a024142696af70000001e02000000190502020000000a0320034f053d036d03420501036c0500036c00000002030b ; + Stack_elt address "KT1Mjjcb6tmSsLm7Cb3DSQszePjfchPM4Uxm" } +Expected: { Stack_elt + operation + (Create_contract + { code { DROP ; UNIT ; NIL operation ; PAIR } ; + storage unit ; + parameter unit } + (Some "tz1NwQ6hkenkn6aYYio8VnJvjtb4K1pfeU1Z") + 12 + Unit + _) ; + Stack_elt address _ } + +Test results: Passed:532 Failed:5 Total:537 +Fatal error: + Some tests have failed diff --git a/tezt/tests/main.ml b/tezt/tests/main.ml index 2da7b89e2c9a944bb40f9123d08e7c0d40687aaa..fc6aee463389cec683814aca10acd520817d21d8 100644 --- a/tezt/tests/main.ml +++ b/tezt/tests/main.ml @@ -215,7 +215,8 @@ let register_protocol_tests_that_use_supports_correctly () = Zk_rollup.register ~protocols ; Tx_sc_rollup.register ~protocols ; Dac.register ~protocols ; - Timelock.register ~protocols + Timelock.register ~protocols ; + Tzt_regression.register ~protocols (* Regression tests are not easy to maintain for multiple protocols because one needs to update and maintain all the expected output files. Some of them, such as diff --git a/tezt/tests/tzt_regression.ml b/tezt/tests/tzt_regression.ml new file mode 100644 index 0000000000000000000000000000000000000000..f8836fb2b71b7b54612d9bf4692397da85ca83d4 --- /dev/null +++ b/tezt/tests/tzt_regression.ml @@ -0,0 +1,65 @@ +(*****************************************************************************) +(* *) +(* Open Source License *) +(* Copyright (c) 2023 Nomadic Labs *) +(* *) +(* Permission is hereby granted, free of charge, to any person obtaining a *) +(* copy of this software and associated documentation files (the "Software"),*) +(* to deal in the Software without restriction, including without limitation *) +(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *) +(* and/or sell copies of the Software, and to permit persons to whom the *) +(* Software is furnished to do so, subject to the following conditions: *) +(* *) +(* The above copyright notice and this permission notice shall be included *) +(* in all copies or substantial portions of the Software. *) +(* *) +(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*) +(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *) +(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *) +(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*) +(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *) +(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *) +(* DEALINGS IN THE SOFTWARE. *) +(* *) +(*****************************************************************************) + +(* Testing + ------- + Components: Michelson / TZT + Invocation: dune exec tezt/tests/main.exe -- --file tzt_regression.ml + Subject: Regression testing of the Octez TZT runner on the reference test suite. +*) + +(* Using the lighter hook that only scrubs the clients [--base-dir] *) +let hooks = + Tezos_regression.hooks_custom + ~scrubbed_global_options:["--base-dir"; "-d"] + ~replace_variables:Fun.id + () + +let test_tzt protocols = + Protocol.register_regression_test + ~__FILE__ + ~title:(sf "Run TZT") + ~tags:["client"; "michelson"; "tzt"] + ~supports:(Protocol.From_protocol 019) + (fun protocol -> + let tests = + List.map + Michelson_script.path + (Michelson_script.find_all_tzt_tests protocol) + in + let* client = Client.init_mockup ~protocol () in + let* _ = + Client.spawn_run_tzt_unit_tests + ~tests + ~protocol_hash:(Protocol.hash protocol) + ~hooks + ~no_base_dir_warnings:true + client + |> Process.wait + in + unit) + protocols + +let register ~protocols = test_tzt protocols diff --git a/tzt_reference_test_suite/add_mutez-mutez_01.tzt b/tzt_reference_test_suite/add_mutez-mutez_01.tzt index a4c929f57f67c2a3f4bd784063e106ef201580c9..1020bfe36f7d21d081425b906be37b7bc3184c3d 100644 --- a/tzt_reference_test_suite/add_mutez-mutez_01.tzt +++ b/tzt_reference_test_suite/add_mutez-mutez_01.tzt @@ -1,3 +1,3 @@ code { ADD } ; input { Stack_elt mutez 9223372036854775807 ; Stack_elt mutez 1 } ; -output (MutezOverflow 9223372036854775807 1) +output Overflow diff --git a/tzt_reference_test_suite/gas_exhaustion.tzt b/tzt_reference_test_suite/gas_exhaustion.tzt new file mode 100644 index 0000000000000000000000000000000000000000..af5c7726ae0db4466a0e2c9a3e283313b8c37971 --- /dev/null +++ b/tzt_reference_test_suite/gas_exhaustion.tzt @@ -0,0 +1,5 @@ +# This is an infinite loop, whatever initial gas is given to the +# interpreter to run this code, all gas will be consumed. +input { Stack_elt bool True }; +code { LOOP { PUSH bool True }}; +output Gas_exhaustion diff --git a/tzt_reference_test_suite/lsl_01.tzt b/tzt_reference_test_suite/lsl_01.tzt index 16aece098fec9daba5708b09122ada8e118f3d2b..39d28a2b46d634115b8bdb87fd3dc9650a989c2a 100644 --- a/tzt_reference_test_suite/lsl_01.tzt +++ b/tzt_reference_test_suite/lsl_01.tzt @@ -1,3 +1,3 @@ code { LSL } ; input { Stack_elt nat 1 ; Stack_elt nat 257 } ; -output (GeneralOverflow 1 257) +output Overflow diff --git a/tzt_reference_test_suite/lsr_01.tzt b/tzt_reference_test_suite/lsr_01.tzt index 46e70c10674591779d34094f80323296fd68a531..14e82315674907f2431c0b5ae79c4d6c8985b894 100644 --- a/tzt_reference_test_suite/lsr_01.tzt +++ b/tzt_reference_test_suite/lsr_01.tzt @@ -1,3 +1,3 @@ code { LSR } ; input { Stack_elt nat 32 ; Stack_elt nat 300 } ; -output (GeneralOverflow 32 300) +output Overflow diff --git a/tzt_reference_test_suite/mul_mutez-nat_01.tzt b/tzt_reference_test_suite/mul_mutez-nat_01.tzt index 7e363e2c39e332ab7ccbe15c28ab4a477a148343..76b3bb98fbd45f48f418ddecc752dc0169ada63b 100644 --- a/tzt_reference_test_suite/mul_mutez-nat_01.tzt +++ b/tzt_reference_test_suite/mul_mutez-nat_01.tzt @@ -1,3 +1,3 @@ code { MUL } ; input { Stack_elt mutez 10 ; Stack_elt nat 2000000000000000000000000000000000000000000000000000000000000000000000 } ; -output (MutezOverflow 10 2000000000000000000000000000000000000000000000000000000000000000000000) +output Overflow diff --git a/tzt_reference_test_suite/mul_nat-mutez_01.tzt b/tzt_reference_test_suite/mul_nat-mutez_01.tzt index b3359b28e47af6c104da27e45b93065eeb25dbab..23fc170546471248c9dae7d210418a4f2681b8a0 100644 --- a/tzt_reference_test_suite/mul_nat-mutez_01.tzt +++ b/tzt_reference_test_suite/mul_nat-mutez_01.tzt @@ -1,3 +1,3 @@ code { MUL } ; input { Stack_elt nat 2000000000000000000000000000000000000000000000000000000000000000000000 ; Stack_elt mutez 10 } ; -output (MutezOverflow 2000000000000000000000000000000000000000000000000000000000000000000000 10) +output Overflow diff --git a/tzt_reference_test_suite/self_01.tzt b/tzt_reference_test_suite/self_01.tzt index dba68d289f3035ca4f5d539cb9fae5997a2428c9..87ff759513a4effeddaabd588931abcc19a92362 100644 --- a/tzt_reference_test_suite/self_01.tzt +++ b/tzt_reference_test_suite/self_01.tzt @@ -1,13 +1,16 @@ # SELF inside CREATE_CONTRACT is valid, even if they both are inside a LAMBDA. # SELF should produce a `contract` value with parameter matching the inner contract. code { - LAMBDA (pair (option key_hash) mutez unit) address - { UNPAIR 3; CREATE_CONTRACT - { code { SELF ; CAST (contract key); FAIL } ; - storage unit ; - parameter key } ; - DROP; - } ; + LAMBDA + (pair (option key_hash) mutez unit) + address + { UNPAIR 3; + CREATE_CONTRACT + { code { SELF ; CAST (contract key); FAIL } ; + storage unit ; + parameter key } ; + DROP; + } ; DROP; } ; input { } ; diff --git a/tzt_reference_test_suite/transfertokens_00.tzt b/tzt_reference_test_suite/transfertokens_00.tzt index e65c1fc97d754944e856cb111a403ee38c5f51da..115e049c80a82d1089a94b643d78c6d7d9d8e828 100644 --- a/tzt_reference_test_suite/transfertokens_00.tzt +++ b/tzt_reference_test_suite/transfertokens_00.tzt @@ -1,4 +1,3 @@ code { TRANSFER_TOKENS } ; input { Stack_elt unit Unit ; Stack_elt mutez 5 ; Stack_elt (contract unit) "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" } ; output { Stack_elt operation (Transfer_tokens Unit 5 "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" _) } ; -other_contracts { Contract "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" unit }