From 40b95ed0afd79d5fbd5366249b4df035ff8be539 Mon Sep 17 00:00:00 2001 From: Nikolay Yakimov Date: Thu, 23 Nov 2023 10:57:54 +0300 Subject: [PATCH 1/8] MIR: trait for conversion to Micheline --- contrib/mir/src/ast.rs | 133 +++++++++--------- contrib/mir/src/ast/micheline.rs | 15 ++ contrib/mir/src/interpreter.rs | 2 +- .../mir/src/serializer/integration_tests.rs | 4 +- contrib/mir/src/tzt/expectation.rs | 8 +- 5 files changed, 88 insertions(+), 74 deletions(-) diff --git a/contrib/mir/src/ast.rs b/contrib/mir/src/ast.rs index 1a397c823768..535a79b19335 100644 --- a/contrib/mir/src/ast.rs +++ b/contrib/mir/src/ast.rs @@ -27,6 +27,7 @@ use typed_arena::Arena; use crate::lexer::Prim; pub use byte_repr_trait::{ByteReprError, ByteReprTrait}; +pub use micheline::IntoMicheline; pub use michelson_address::*; pub use michelson_key::Key; pub use michelson_key_hash::KeyHash; @@ -154,76 +155,70 @@ pub enum TypedValue<'a> { Operation(Box>), } -/// Untypes a value using optimized representation in legacy mode. -/// -/// This differs from plain optimized representation in that it always -/// represents tuples as nested binary pairs (right combs). This is, for -/// instance, what `PACK` uses. -pub fn typed_value_to_value_optimized_legacy<'a>( - arena: &'a Arena>, - tv: TypedValue<'a>, -) -> Micheline<'a> { - use Micheline as V; - use TypedValue as TV; - let go = |x| typed_value_to_value_optimized_legacy(arena, x); - match tv { - TV::Int(i) => V::Int(i), - TV::Nat(u) => V::Int(u.try_into().unwrap()), - TV::Mutez(u) => V::Int(u.try_into().unwrap()), - TV::Bool(true) => V::prim0(Prim::True), - TV::Bool(false) => V::prim0(Prim::False), - TV::String(s) => V::String(s), - TV::Unit => V::prim0(Prim::Unit), - // This transformation for pairs deviates from the optimized representation of the - // reference implementation, because reference implementation optimizes the size of combs - // and uses an untyped representation that is the shortest. - TV::Pair(b) => V::prim2(arena, Prim::Pair, go(b.0), go(b.1)), - TV::List(l) => V::Seq(arena.alloc_extend(l.into_iter().map(go))), - TV::Set(s) => V::Seq(arena.alloc_extend(s.into_iter().map(go))), - TV::Map(m) => V::Seq( - arena.alloc_extend( - m.into_iter() - .map(|(key, val)| V::prim2(arena, Prim::Elt, go(key), go(val))), - ), - ), - TV::Option(None) => V::prim0(Prim::None), - TV::Option(Some(x)) => V::prim1(arena, Prim::Some, go(*x)), - TV::Or(or) => match *or { - Or::Left(x) => V::prim1(arena, Prim::Left, go(x)), - Or::Right(x) => V::prim1(arena, Prim::Right, go(x)), - }, - TV::Address(x) => V::Bytes(x.to_bytes_vec()), - TV::ChainId(x) => V::Bytes(x.into()), - TV::Bytes(x) => V::Bytes(x), - TV::Key(k) => V::Bytes(k.to_bytes_vec()), - TV::Signature(s) => V::Bytes(s.to_bytes_vec()), - TV::Lambda(lam) => match lam { - Lambda::Lambda { micheline_code, .. } => micheline_code, - Lambda::LambdaRec { micheline_code, .. } => { - V::prim1(arena, Prim::Lambda_rec, micheline_code) - } - }, - TV::KeyHash(s) => V::Bytes(s.to_bytes_vec()), - TV::Contract(x) => go(TV::Address(x)), - TV::Operation(operation_info) => match operation_info.operation { - Operation::TransferTokens(tt) => Micheline::App( - Prim::Transfer_tokens, - arena.alloc_extend([ - go(tt.param), - go(TV::Address(tt.destination_address)), - go(TV::Mutez(tt.amount)), - ]), - annotations::NO_ANNS, - ), - Operation::SetDelegate(sd) => Micheline::App( - Prim::Set_delegate, - arena.alloc_extend([match sd.0 { - Some(kh) => V::prim1(arena, Prim::Some, go(TV::KeyHash(kh))), - None => V::prim0(Prim::None), - }]), - annotations::NO_ANNS, +impl<'a> IntoMicheline<'a> for TypedValue<'a> { + fn into_micheline_optimized_legacy(self, arena: &'a Arena>) -> Micheline<'a> { + use Micheline as V; + use TypedValue as TV; + let go = |x: Self| x.into_micheline_optimized_legacy(arena); + match self { + TV::Int(i) => V::Int(i), + TV::Nat(u) => V::Int(u.try_into().unwrap()), + TV::Mutez(u) => V::Int(u.try_into().unwrap()), + TV::Bool(true) => V::prim0(Prim::True), + TV::Bool(false) => V::prim0(Prim::False), + TV::String(s) => V::String(s), + TV::Unit => V::prim0(Prim::Unit), + // This transformation for pairs deviates from the optimized representation of the + // reference implementation, because reference implementation optimizes the size of combs + // and uses an untyped representation that is the shortest. + TV::Pair(b) => V::prim2(arena, Prim::Pair, go(b.0), go(b.1)), + TV::List(l) => V::Seq(arena.alloc_extend(l.into_iter().map(go))), + TV::Set(s) => V::Seq(arena.alloc_extend(s.into_iter().map(go))), + TV::Map(m) => V::Seq( + arena.alloc_extend( + m.into_iter() + .map(|(key, val)| V::prim2(arena, Prim::Elt, go(key), go(val))), + ), ), - }, + TV::Option(None) => V::prim0(Prim::None), + TV::Option(Some(x)) => V::prim1(arena, Prim::Some, go(*x)), + TV::Or(or) => match *or { + Or::Left(x) => V::prim1(arena, Prim::Left, go(x)), + Or::Right(x) => V::prim1(arena, Prim::Right, go(x)), + }, + TV::Address(x) => V::Bytes(x.to_bytes_vec()), + TV::ChainId(x) => V::Bytes(x.into()), + TV::Bytes(x) => V::Bytes(x), + TV::Key(k) => V::Bytes(k.to_bytes_vec()), + TV::Signature(s) => V::Bytes(s.to_bytes_vec()), + TV::Lambda(lam) => match lam { + Lambda::Lambda { micheline_code, .. } => micheline_code, + Lambda::LambdaRec { micheline_code, .. } => { + V::prim1(arena, Prim::Lambda_rec, micheline_code) + } + }, + TV::KeyHash(s) => V::Bytes(s.to_bytes_vec()), + TV::Contract(x) => go(TV::Address(x)), + TV::Operation(operation_info) => match operation_info.operation { + Operation::TransferTokens(tt) => Micheline::App( + Prim::Transfer_tokens, + arena.alloc_extend([ + go(tt.param), + go(TV::Address(tt.destination_address)), + go(TV::Mutez(tt.amount)), + ]), + annotations::NO_ANNS, + ), + Operation::SetDelegate(sd) => Micheline::App( + Prim::Set_delegate, + arena.alloc_extend([match sd.0 { + Some(kh) => V::prim1(arena, Prim::Some, go(TV::KeyHash(kh))), + None => V::prim0(Prim::None), + }]), + annotations::NO_ANNS, + ), + }, + } } } diff --git a/contrib/mir/src/ast/micheline.rs b/contrib/mir/src/ast/micheline.rs index da2dd8d06758..427f15670e7c 100644 --- a/contrib/mir/src/ast/micheline.rs +++ b/contrib/mir/src/ast/micheline.rs @@ -97,6 +97,21 @@ impl<'a> From<&str> for Micheline<'a> { } } +pub trait IntoMicheline<'a> { + /// Untypes a value using optimized representation in legacy mode. + /// + /// This differs from plain optimized representation in that it always + /// represents tuples as nested binary pairs (right combs). This is, for + /// instance, what `PACK` uses. + /// + /// However, note that a right-comb `pair` type is represented as a + /// sequence, for consistency with `PACK`. + fn into_micheline_optimized_legacy( + self, + arena: &'a typed_arena::Arena>, + ) -> Micheline<'a>; +} + /// Pattern synonym matching all type primitive applications. Useful for total /// matches. macro_rules! micheline_types { diff --git a/contrib/mir/src/interpreter.rs b/contrib/mir/src/interpreter.rs index 1ba8ac1211b2..49fccc5ed993 100644 --- a/contrib/mir/src/interpreter.rs +++ b/contrib/mir/src/interpreter.rs @@ -599,7 +599,7 @@ fn interpret_one<'a>( let arena = Arena::new(); // In the Tezos implementation they also charge gas for the pass // that strips locations. We don't have it. - let mich = typed_value_to_value_optimized_legacy(&arena, v); + let mich = v.into_micheline_optimized_legacy(&arena); ctx.gas .consume(interpret_cost::micheline_encoding(&mich)?)?; let encoded = mich.encode_for_pack(); diff --git a/contrib/mir/src/serializer/integration_tests.rs b/contrib/mir/src/serializer/integration_tests.rs index 86c57ed51ea0..3aab3bd1c4a4 100644 --- a/contrib/mir/src/serializer/integration_tests.rs +++ b/contrib/mir/src/serializer/integration_tests.rs @@ -14,7 +14,7 @@ mod test_typed_encode { use typed_arena::Arena; - use crate::ast::{self, byte_repr_trait::*, KeyHash}; + use crate::ast::{byte_repr_trait::*, IntoMicheline, KeyHash}; use crate::ast::{Address, TypedValue}; // Expected bytes to be produced with @@ -30,7 +30,7 @@ mod test_typed_encode { .expect("The `expected` argument must start from 0x"); let arena = Arena::new(); - let micheline = ast::typed_value_to_value_optimized_legacy(&arena, v); + let micheline = v.into_micheline_optimized_legacy(&arena); assert_eq!( micheline.encode_for_pack(), hex::decode(hex_bytes).expect("Bad hex string in `expected` argument") diff --git a/contrib/mir/src/tzt/expectation.rs b/contrib/mir/src/tzt/expectation.rs index 67a8367030f0..4dec021f3641 100644 --- a/contrib/mir/src/tzt/expectation.rs +++ b/contrib/mir/src/tzt/expectation.rs @@ -5,6 +5,8 @@ /* */ /******************************************************************************/ +use crate::ast::IntoMicheline; + use super::*; fn check_error_expectation<'a>( @@ -56,8 +58,10 @@ fn unify_interpreter_error( // This means that comb pairs given in different forms (tree / linear) will // be considered distinct. This should be fine in most cases though. let arena = typed_arena::Arena::new(); - typed_value_to_value_optimized_legacy(&arena, exp_typed_val) - == typed_value_to_value_optimized_legacy(&arena, failed_typed_value.clone()) + exp_typed_val.into_micheline_optimized_legacy(&arena) + == failed_typed_value + .clone() + .into_micheline_optimized_legacy(&arena) } Err(_) => false, } -- GitLab From e25289fef5ec70724566c09d520e6455595f7632 Mon Sep 17 00:00:00 2001 From: Nikolay Yakimov Date: Wed, 22 Nov 2023 19:11:27 +0300 Subject: [PATCH 2/8] MIR: type unparsing --- contrib/mir/src/ast.rs | 84 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 83 insertions(+), 1 deletion(-) diff --git a/contrib/mir/src/ast.rs b/contrib/mir/src/ast.rs index 535a79b19335..b087c68efd73 100644 --- a/contrib/mir/src/ast.rs +++ b/contrib/mir/src/ast.rs @@ -24,7 +24,7 @@ use std::collections::{BTreeMap, BTreeSet}; pub use tezos_crypto_rs::hash::ChainId; use typed_arena::Arena; -use crate::lexer::Prim; +use crate::{ast::annotations::NO_ANNS, lexer::Prim}; pub use byte_repr_trait::{ByteReprError, ByteReprTrait}; pub use micheline::IntoMicheline; @@ -130,6 +130,88 @@ impl Type { } } +impl<'a> IntoMicheline<'a> for &'_ Type { + fn into_micheline_optimized_legacy(self, arena: &'a Arena>) -> Micheline<'a> { + use Type::*; + + struct LinearizePairIter<'a>(std::option::Option<&'a Type>); + + impl<'a> std::iter::Iterator for LinearizePairIter<'a> { + type Item = &'a Type; + fn next(&mut self) -> std::option::Option { + match self.0 { + Some(Type::Pair(x)) => { + self.0 = Some(&x.1); + Some(&x.0) + } + ty => { + self.0 = None; + ty + } + } + } + } + + match self { + Nat => Micheline::prim0(Prim::nat), + Int => Micheline::prim0(Prim::int), + Bool => Micheline::prim0(Prim::bool), + Mutez => Micheline::prim0(Prim::mutez), + String => Micheline::prim0(Prim::string), + Unit => Micheline::prim0(Prim::unit), + Operation => Micheline::prim0(Prim::operation), + Address => Micheline::prim0(Prim::address), + ChainId => Micheline::prim0(Prim::chain_id), + Bytes => Micheline::prim0(Prim::bytes), + Key => Micheline::prim0(Prim::key), + Signature => Micheline::prim0(Prim::signature), + KeyHash => Micheline::prim0(Prim::key_hash), + Never => Micheline::prim0(Prim::never), + + Option(x) => Micheline::prim1( + arena, + Prim::option, + x.into_micheline_optimized_legacy(arena), + ), + List(x) => { + Micheline::prim1(arena, Prim::list, x.into_micheline_optimized_legacy(arena)) + } + Set(x) => Micheline::prim1(arena, Prim::set, x.into_micheline_optimized_legacy(arena)), + Contract(x) => Micheline::prim1( + arena, + Prim::contract, + x.into_micheline_optimized_legacy(arena), + ), + + Pair(_) => Micheline::App( + Prim::pair, + arena.alloc_extend( + LinearizePairIter(Some(self)).map(|x| x.into_micheline_optimized_legacy(arena)), + ), + NO_ANNS, + ), + Map(x) => Micheline::prim2( + arena, + Prim::map, + x.0.into_micheline_optimized_legacy(arena), + x.1.into_micheline_optimized_legacy(arena), + ), + Or(x) => Micheline::prim2( + arena, + Prim::or, + x.0.into_micheline_optimized_legacy(arena), + x.1.into_micheline_optimized_legacy(arena), + ), + Lambda(x) => Micheline::prim2( + arena, + Prim::lambda, + x.0.into_micheline_optimized_legacy(arena), + x.1.into_micheline_optimized_legacy(arena), + ), + } + } +} + #[derive(Debug, Clone, Eq, PartialEq)] pub enum TypedValue<'a> { Int(BigInt), -- GitLab From 3cad91fea3ba7a5c7046807b221715aa2ed1cc09 Mon Sep 17 00:00:00 2001 From: Nikolay Yakimov Date: Wed, 22 Nov 2023 19:18:51 +0300 Subject: [PATCH 3/8] MIR: add prim3 helper for Micheline --- contrib/mir/src/ast/micheline.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/contrib/mir/src/ast/micheline.rs b/contrib/mir/src/ast/micheline.rs index 427f15670e7c..db07923a7888 100644 --- a/contrib/mir/src/ast/micheline.rs +++ b/contrib/mir/src/ast/micheline.rs @@ -41,6 +41,16 @@ impl<'a> Micheline<'a> { Micheline::App(prim, arena.alloc_extend([arg1, arg2]), NO_ANNS) } + pub fn prim3( + arena: &'a Arena>, + prim: Prim, + arg1: Micheline<'a>, + arg2: Micheline<'a>, + arg3: Micheline<'a>, + ) -> Self { + Micheline::App(prim, arena.alloc_extend([arg1, arg2, arg3]), NO_ANNS) + } + pub fn seq( arena: &'a Arena>, args: impl IntoIterator>, -- GitLab From f2155fbc29da5deb891eaec1b1b80d0ba56c82ed Mon Sep 17 00:00:00 2001 From: Nikolay Yakimov Date: Mon, 18 Dec 2023 15:14:56 +0300 Subject: [PATCH 4/8] MIR: compare untyped values in tzt runner Lambdas, specifically partially-applied lambdas, have a different internal representation from Micheline, so additional steps when running tzt are necessary. --- contrib/mir/src/stack.rs | 24 ++++++++++++++++ contrib/mir/src/tzt/expectation.rs | 44 +++++++++++++++++++----------- 2 files changed, 52 insertions(+), 16 deletions(-) diff --git a/contrib/mir/src/stack.rs b/contrib/mir/src/stack.rs index eeaa435d4229..c169452469c8 100644 --- a/contrib/mir/src/stack.rs +++ b/contrib/mir/src/stack.rs @@ -219,6 +219,30 @@ impl IndexMut for Stack { } } +pub struct IntoIter(std::iter::Rev>); + +impl Iterator for IntoIter { + type Item = T; + + fn next(&mut self) -> Option { + self.0.next() + } + + fn size_hint(&self) -> (usize, Option) { + self.0.size_hint() + } +} + +impl IntoIterator for Stack { + type IntoIter = IntoIter; + + type Item = T; + + fn into_iter(self) -> Self::IntoIter { + IntoIter(self.0.into_iter().rev()) + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/contrib/mir/src/tzt/expectation.rs b/contrib/mir/src/tzt/expectation.rs index 4dec021f3641..0e50965af396 100644 --- a/contrib/mir/src/tzt/expectation.rs +++ b/contrib/mir/src/tzt/expectation.rs @@ -35,6 +35,27 @@ fn check_error_expectation<'a>( } } +/// Both `TypedValue`s are untyped and the untyped representations are compared to get the result. +/// This is required to avoid the Eq trait of TypedValue. It is relevant primarily for +/// paritaly-applied lambdas, as those are represented quite differently from Micheline internally. +fn compare_typed_values(v1: TypedValue, v2: TypedValue) -> bool { + let arena = typed_arena::Arena::new(); + v1.into_micheline_optimized_legacy(&arena) == v2.into_micheline_optimized_legacy(&arena) +} + +/// Compare two typed stacks by comparing types and values. Values are compared using +/// `compare_typed_values`. +fn compare_typed_stacks( + t1: &FailingTypeStack, + s1: IStack, + t2: &FailingTypeStack, + s2: IStack, +) -> bool { + t1 == t2 + && s1.len() == s2.len() + && std::iter::zip(s1, s2).all(|(v1, v2)| compare_typed_values(v1, v2)) +} + fn unify_interpreter_error( ctx: &mut Ctx, exp: &InterpreterErrorExpectation, @@ -47,21 +68,7 @@ fn unify_interpreter_error( // typed of the failed value we get from the interpreter. match typecheck_value(value, ctx, typ) { Ok(exp_typed_val) => { - // Then both `Typedvalue`s are untyped and compared to get the result. Here - // untyping is done before comparing so that we are not using the Eq trait of - // TypedValue. It is thought to be a bit unsafe to use it generally outside the - // context of the interpreter, though here we have full type information for - // both values being compared, so it is probably safe to compare typed - // representation as well. - - // For now we compare values untyped to optimized form with a `PACK` flavor. - // This means that comb pairs given in different forms (tree / linear) will - // be considered distinct. This should be fine in most cases though. - let arena = typed_arena::Arena::new(); - exp_typed_val.into_micheline_optimized_legacy(&arena) - == failed_typed_value - .clone() - .into_micheline_optimized_legacy(&arena) + compare_typed_values(exp_typed_val, failed_typed_value.clone()) } Err(_) => false, } @@ -88,7 +95,12 @@ pub fn check_expectation<'a>( let expected_stack = TopIsFirst::from(exp_stk_values).0; // If the run was success, and the expectation is also of success check the expected // stack. Stack types and values should match. - if res_type_stack == expected_type_stack && result_stack == expected_stack { + if compare_typed_stacks( + &res_type_stack, + result_stack.clone(), + &expected_type_stack, + expected_stack.clone(), + ) { Ok(()) } else { Err(StackMismatch( -- GitLab From 902d3d3b1cb4bbe626d1824aaf9f25fd63d9d9f2 Mon Sep 17 00:00:00 2001 From: Nikolay Yakimov Date: Wed, 22 Nov 2023 19:27:20 +0300 Subject: [PATCH 5/8] MIR: APPLY instruction --- contrib/mir/src/ast.rs | 14 +- contrib/mir/src/ast/michelson_lambda.rs | 213 +++++++++++++++++++++++- contrib/mir/src/gas.rs | 4 + contrib/mir/src/interpreter.rs | 201 +++++++++++++++++++--- contrib/mir/src/typechecker.rs | 53 ++++-- 5 files changed, 440 insertions(+), 45 deletions(-) diff --git a/contrib/mir/src/ast.rs b/contrib/mir/src/ast.rs index b087c68efd73..9d39607c74f0 100644 --- a/contrib/mir/src/ast.rs +++ b/contrib/mir/src/ast.rs @@ -31,7 +31,7 @@ pub use micheline::IntoMicheline; pub use michelson_address::*; pub use michelson_key::Key; pub use michelson_key_hash::KeyHash; -pub use michelson_lambda::Lambda; +pub use michelson_lambda::{Closure, Lambda}; pub use michelson_list::MichelsonList; pub use michelson_signature::Signature; pub use or::Or; @@ -232,7 +232,7 @@ pub enum TypedValue<'a> { Bytes(Vec), Key(Key), Signature(Signature), - Lambda(Lambda<'a>), + Lambda(Closure<'a>), KeyHash(KeyHash), Operation(Box>), } @@ -273,12 +273,7 @@ impl<'a> IntoMicheline<'a> for TypedValue<'a> { TV::Bytes(x) => V::Bytes(x), TV::Key(k) => V::Bytes(k.to_bytes_vec()), TV::Signature(s) => V::Bytes(s.to_bytes_vec()), - TV::Lambda(lam) => match lam { - Lambda::Lambda { micheline_code, .. } => micheline_code, - Lambda::LambdaRec { micheline_code, .. } => { - V::prim1(arena, Prim::Lambda_rec, micheline_code) - } - }, + TV::Lambda(lam) => lam.into_micheline_optimized_legacy(arena), TV::KeyHash(s) => V::Bytes(s.to_bytes_vec()), TV::Contract(x) => go(TV::Address(x)), TV::Operation(operation_info) => match operation_info.operation { @@ -392,6 +387,9 @@ pub enum Instruction<'a> { Lambda(Lambda<'a>), Exec, HashKey, + Apply { + arg_ty: Type, + }, } #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/contrib/mir/src/ast/michelson_lambda.rs b/contrib/mir/src/ast/michelson_lambda.rs index be3c201eed8e..237a6b0ab6b5 100644 --- a/contrib/mir/src/ast/michelson_lambda.rs +++ b/contrib/mir/src/ast/michelson_lambda.rs @@ -7,7 +7,9 @@ use std::rc::Rc; -use super::{Instruction, Micheline}; +use crate::lexer::Prim; + +use super::{annotations::NO_ANNS, Instruction, IntoMicheline, Micheline, Type, TypedValue}; #[derive(Debug, Clone, Eq, PartialEq)] pub enum Lambda<'a> { @@ -16,6 +18,10 @@ pub enum Lambda<'a> { code: Rc<[Instruction<'a>]>, // see Note: Rc in lambdas }, LambdaRec { + /// Lambda argument type + in_ty: Type, + /// Lambda result type + out_ty: Type, micheline_code: Micheline<'a>, code: Rc<[Instruction<'a>]>, // see Note: Rc in lambdas }, @@ -31,3 +37,208 @@ For non-recursive Lambda the same approach is used to make `LAMBDA` instruction independent of the length of the code (there's a Lambda::clone call in the implementation) */ + +#[derive(Debug, Clone, Eq, PartialEq)] +pub enum Closure<'a> { + Lambda(Lambda<'a>), + Apply { + /// Captured argument type + arg_ty: Type, + /// Captured argument value + arg_val: Box>, + /// Inner closure + closure: Box>, + }, +} + +impl<'a> IntoMicheline<'a> for Closure<'a> { + fn into_micheline_optimized_legacy( + self, + arena: &'a typed_arena::Arena>, + ) -> Micheline<'a> { + match self { + Closure::Lambda(Lambda::Lambda { micheline_code, .. }) => micheline_code, + Closure::Lambda(Lambda::LambdaRec { micheline_code, .. }) => { + Micheline::prim1(arena, Prim::Lambda_rec, micheline_code) + } + Closure::Apply { + arg_ty, + arg_val, + closure, + } => match *closure { + Closure::Lambda(Lambda::LambdaRec { + in_ty, + out_ty, + micheline_code, + .. + }) => Micheline::seq( + arena, + [ + Micheline::prim2( + arena, + Prim::PUSH, + arg_ty.into_micheline_optimized_legacy(arena), + arg_val.into_micheline_optimized_legacy(arena), + ), + Micheline::prim0(Prim::PAIR), + Micheline::prim3( + arena, + Prim::LAMBDA_REC, + in_ty.into_micheline_optimized_legacy(arena), + out_ty.into_micheline_optimized_legacy(arena), + micheline_code, + ), + Micheline::App(Prim::SWAP, &[], NO_ANNS), + Micheline::App(Prim::EXEC, &[], NO_ANNS), + ], + ), + Closure::Apply { .. } | Closure::Lambda(Lambda::Lambda { .. }) => Micheline::seq( + arena, + [ + Micheline::prim2( + arena, + Prim::PUSH, + arg_ty.into_micheline_optimized_legacy(arena), + arg_val.into_micheline_optimized_legacy(arena), + ), + Micheline::App(Prim::PAIR, &[], NO_ANNS), + closure.into_micheline_optimized_legacy(arena), + ], + ), + }, + } + } +} + +#[cfg(test)] +mod tests { + use typed_arena::Arena; + + use crate::{ + ast::{ + micheline::{ + test_helpers::{app, seq}, + IntoMicheline, + }, + TypedValue, + }, + context::Ctx, + irrefutable_match::irrefutable_match, + parser::Parser, + stk, + }; + + #[test] + fn apply_micheline() { + let parser = Parser::new(); + let code = parser.parse("{ LAMBDA (pair int nat unit) unit { DROP; UNIT }; PUSH int 1; APPLY; PUSH nat 2; APPLY }").unwrap(); + let code = code + .typecheck_instruction(&mut Ctx::default(), None, &[]) + .unwrap(); + let mut stack = stk![]; + code.interpret(&mut Ctx::default(), &mut stack).unwrap(); + let closure = irrefutable_match!(stack.pop().unwrap(); TypedValue::Lambda); + let arena = Arena::new(); + assert_eq!( + closure.into_micheline_optimized_legacy(&arena), + // checked against octez-client + // { PUSH nat 2 ; PAIR ; { PUSH int 1 ; PAIR ; { DROP ; UNIT } } } + seq! { + app!(PUSH[app!(nat), 2]); + app!(PAIR); + seq!{ + app!(PUSH[app!(int), 1]); + app!(PAIR); + seq! { + app!(DROP); + app!(UNIT) + } + } + } + ) + } + + #[test] + fn apply_micheline_rec() { + let parser = Parser::new(); + let code = parser.parse("{ LAMBDA_REC (pair int nat unit) unit { DROP 2; UNIT }; PUSH int 1; APPLY; PUSH nat 2; APPLY }").unwrap(); + let code = code + .typecheck_instruction(&mut Ctx::default(), None, &[]) + .unwrap(); + let mut stack = stk![]; + code.interpret(&mut Ctx::default(), &mut stack).unwrap(); + let closure = irrefutable_match!(stack.pop().unwrap(); TypedValue::Lambda); + let arena = Arena::new(); + assert_eq!( + closure.into_micheline_optimized_legacy(&arena), + // checked against octez-client + // { PUSH nat 2 ; + // PAIR ; + // { PUSH int 1 ; + // PAIR ; + // LAMBDA_REC (pair int nat unit) unit { DROP 2 ; UNIT } ; + // SWAP ; + // EXEC } } + seq! { + app!(PUSH[app!(nat), 2]); + app!(PAIR); + seq!{ + app!(PUSH[app!(int), 1]); + app!(PAIR); + app!(LAMBDA_REC[app!(pair[app!(int), app!(nat), app!(unit)]), app!(unit), seq!{ + app!(DROP[2]); app!(UNIT) + }]); + app!(SWAP); + app!(EXEC) + } + } + ) + } + + #[test] + fn apply_micheline_rec_pair_linearization() { + // PACK always encodes pair values as right-combs, and always encodes + // pair types as a flat sequence. Test we're doing the same. + let parser = Parser::new(); + let code = parser + .parse( + r#" + { + LAMBDA (pair (pair nat nat nat) unit) unit {CDR;}; + PUSH + (pair nat (pair nat nat)) # The pair type is given as a tree + (Pair 1 1 1); # The pair value is given as a flat sequence + APPLY; + } + "#, + ) + .unwrap(); + let code = code + .typecheck_instruction(&mut Ctx::default(), None, &[]) + .unwrap(); + let mut stack = stk![]; + code.interpret(&mut Ctx::default(), &mut stack).unwrap(); + let closure = irrefutable_match!(stack.pop().unwrap(); TypedValue::Lambda); + let arena = Arena::new(); + assert_eq!( + closure.into_micheline_optimized_legacy(&arena), + // checked against octez-client's PACK behaviour. + // the partially-applied lambda above packs into + // 0x020000002507430965000000060362036203620000000007070001070700010001034202000000020317 + // which, converted to Micheline, yields: + // { PUSH (pair nat nat nat) # pair is now a flat sequence + // (Pair 1 (Pair 1 1)) ; # Pair is now an explicit comb + // PAIR ; + // { CDR } + // } + seq! { + app!(PUSH[ + app!(pair[app!(nat), app!(nat), app!(nat)]), + app!(Pair[1, app!(Pair[1, 1])]) + ]); + app!(PAIR); + seq!{ app!(CDR) } + } + ) + } +} diff --git a/contrib/mir/src/gas.rs b/contrib/mir/src/gas.rs index df5f9f65b8f3..83c64c46f715 100644 --- a/contrib/mir/src/gas.rs +++ b/contrib/mir/src/gas.rs @@ -246,6 +246,10 @@ pub mod interpret_cost { pub const LAMBDA: u32 = 10; pub const EXEC: u32 = 10; pub const HASH_KEY: u32 = 605; + // slight deviation from the protocol: in the protocol, APPLY costs differer + // depending on whether a lambda is recursive; here this distinction doesn't + // make a lot of sense. + pub const APPLY: u32 = 140; pub const INTERPRET_RET: u32 = 15; // corresponds to KNil in the Tezos protocol pub const LOOP_ENTER: u32 = 10; // corresponds to KLoop_in in the Tezos protocol diff --git a/contrib/mir/src/interpreter.rs b/contrib/mir/src/interpreter.rs index 49fccc5ed993..74d6f82461e4 100644 --- a/contrib/mir/src/interpreter.rs +++ b/contrib/mir/src/interpreter.rs @@ -699,28 +699,54 @@ fn interpret_one<'a>( } I::Lambda(lam) => { ctx.gas.consume(interpret_cost::LAMBDA)?; - stack.push(V::Lambda(lam.clone())); + stack.push(V::Lambda(Closure::Lambda(lam.clone()))); } I::Exec => { ctx.gas.consume(interpret_cost::EXEC)?; - let arg = pop!(); - let lam = pop!(V::Lambda); - let mut res_stk = match &lam { - Lambda::LambdaRec { code, .. } => { - // NB: this `clone` is constant-time as `code` is Rc - // See Note: Rc in lambdas - let code = Rc::clone(code); - let mut stk = stk![V::Lambda(lam), arg]; - interpret(&code, ctx, &mut stk)?; - stk - } - Lambda::Lambda { code, .. } => { - let mut stk = stk![arg]; - interpret(code, ctx, &mut stk)?; - stk + let mut arg = pop!(); + let mut closure = pop!(V::Lambda); + loop { + match closure { + Closure::Lambda(ref lam) => { + let mut res_stk = match &lam { + Lambda::LambdaRec { code, .. } => { + // NB: this `clone` is constant-time as `code` is Rc + // See Note: Rc in lambdas + let code = Rc::clone(code); + let mut stk = stk![V::Lambda(closure), arg]; + interpret(&code, ctx, &mut stk)?; + stk + } + Lambda::Lambda { code, .. } => { + let mut stk = stk![arg]; + interpret(code, ctx, &mut stk)?; + stk + } + }; + stack.push(res_stk.pop().unwrap_or_else(|| unreachable_state())); + break; + } + Closure::Apply { + arg_val, + closure: inner, + .. + } => { + ctx.gas.consume(interpret_cost::PAIR)?; // reasonable estimation + arg = V::new_pair(*arg_val, arg); + closure = *inner; + } } - }; - stack.push(res_stk.pop().unwrap_or_else(|| unreachable_state())); + } + } + I::Apply { arg_ty } => { + let arg_val = pop!(); + let closure = pop!(V::Lambda); + ctx.gas.consume(interpret_cost::APPLY)?; + stack.push(V::Lambda(Closure::Apply { + arg_ty: arg_ty.clone(), + arg_val: Box::new(arg_val), + closure: Box::new(closure), + })) } I::HashKey => { ctx.gas.consume(interpret_cost::HASH_KEY)?; @@ -2460,10 +2486,10 @@ mod interpreter_tests { #[test] fn exec() { let mut stack = stk![ - TypedValue::Lambda(Lambda::Lambda { + TypedValue::Lambda(Closure::Lambda(Lambda::Lambda { micheline_code: Micheline::Seq(&[]), // ignored by the interpreter code: vec![Unpair, Add(overloads::Add::IntNat)].into(), - }), + })), TypedValue::new_pair(TypedValue::int(1), TypedValue::nat(5)) ]; assert_eq!( @@ -2475,7 +2501,9 @@ mod interpreter_tests { #[test] fn exec_rec_1() { - let lam = Lambda::LambdaRec { + let lam = Closure::Lambda(Lambda::LambdaRec { + in_ty: Type::new_pair(Type::Bool, Type::Nat), + out_ty: Type::Nat, micheline_code: Micheline::Seq(&[]), code: vec![ Unpair, @@ -2491,7 +2519,7 @@ mod interpreter_tests { ), ] .into(), - }; + }); let mut stack = stk![ TypedValue::Lambda(lam.clone()), TypedValue::new_pair(TypedValue::Bool(true), TypedValue::nat(5)) @@ -2505,7 +2533,9 @@ mod interpreter_tests { #[test] fn exec_rec_2() { - let lam = Lambda::LambdaRec { + let lam = Closure::Lambda(Lambda::LambdaRec { + in_ty: Type::new_pair(Type::Bool, Type::Nat), + out_ty: Type::Nat, micheline_code: Micheline::Seq(&[]), code: vec![ Unpair, @@ -2521,7 +2551,7 @@ mod interpreter_tests { ), ] .into(), - }; + }); let mut stack = stk![ TypedValue::Lambda(lam.clone()), TypedValue::new_pair(TypedValue::Bool(false), TypedValue::nat(5)) @@ -2556,4 +2586,127 @@ mod interpreter_tests { Ctx::default().gas.milligas() - interpret_cost::HASH_KEY ); } + + #[test] + fn apply_exec() { + let lam = Closure::Lambda(Lambda::Lambda { + micheline_code: Micheline::Seq(&[]), + code: vec![Unpair, Add(overloads::Add::IntNat)].into(), + }); + let mut stack = stk![TypedValue::Lambda(lam.clone()), TypedValue::int(1)]; + assert_eq!( + interpret_one( + &Apply { arg_ty: Type::Int }, + &mut Ctx::default(), + &mut stack + ), + Ok(()) + ); + assert_eq!( + stack, + stk![TypedValue::Lambda(Closure::Apply { + arg_ty: Type::Int, + arg_val: Box::new(TypedValue::int(1)), + closure: Box::new(lam), + })] + ); + stack.push(TypedValue::nat(5)); + assert_eq!( + interpret_one(&Exec, &mut Ctx::default(), &mut stack), + Ok(()) + ); + assert_eq!(stack, stk![TypedValue::int(6)]); + } + + #[test] + fn apply_exec_rec_1() { + let lam = Closure::Lambda(Lambda::LambdaRec { + in_ty: Type::new_pair(Type::Bool, Type::Nat), + out_ty: Type::Nat, + micheline_code: Micheline::Seq(&[]), + code: vec![ + Unpair, + If( + vec![ + Dup(None), + Add(overloads::Add::NatNat), + Push(TypedValue::Bool(false)), + Pair, + Exec, + ], + vec![Dip(None, vec![Drop(None)])], + ), + ] + .into(), + }); + let mut stack = stk![TypedValue::Lambda(lam.clone()), TypedValue::Bool(true)]; + assert_eq!( + interpret_one( + &Apply { arg_ty: Type::Bool }, + &mut Ctx::default(), + &mut stack + ), + Ok(()) + ); + assert_eq!( + stack, + stk![TypedValue::Lambda(Closure::Apply { + arg_ty: Type::Bool, + arg_val: Box::new(TypedValue::Bool(true)), + closure: Box::new(lam), + })] + ); + stack.push(TypedValue::nat(5)); + assert_eq!( + interpret_one(&Exec, &mut Ctx::default(), &mut stack), + Ok(()) + ); + assert_eq!(stack, stk![TypedValue::nat(10)]); + } + + #[test] + fn apply_exec_rec_2() { + let lam = Closure::Lambda(Lambda::LambdaRec { + in_ty: Type::new_pair(Type::Bool, Type::Nat), + out_ty: Type::Nat, + micheline_code: Micheline::Seq(&[]), + code: vec![ + Unpair, + If( + vec![ + Dup(None), + Add(overloads::Add::NatNat), + Push(TypedValue::Bool(false)), + Pair, + Exec, + ], + vec![Dip(None, vec![Drop(None)])], + ), + ] + .into(), + }); + let mut stack = stk![TypedValue::Lambda(lam.clone()), TypedValue::Bool(false)]; + assert_eq!( + interpret_one( + &Apply { arg_ty: Type::Bool }, + &mut Ctx::default(), + &mut stack + ), + Ok(()) + ); + assert_eq!( + stack, + stk![TypedValue::Lambda(Closure::Apply { + arg_ty: Type::Bool, + arg_val: Box::new(TypedValue::Bool(false)), + closure: Box::new(lam), + })] + ); + stack.push(TypedValue::nat(5)); + assert_eq!( + interpret_one(&Exec, &mut Ctx::default(), &mut stack), + Ok(()) + ); + assert_eq!(stack, stk![TypedValue::nat(5)]); + } } diff --git a/contrib/mir/src/typechecker.rs b/contrib/mir/src/typechecker.rs index 2a6964ea58ab..fe7f32c6aaf1 100644 --- a/contrib/mir/src/typechecker.rs +++ b/contrib/mir/src/typechecker.rs @@ -1212,6 +1212,27 @@ pub(crate) fn typecheck_instruction<'a>( (App(HASH_KEY, [], _), []) => no_overload!(HASH_KEY, len 1), (App(HASH_KEY, expect_args!(0), _), _) => unexpected_micheline!(), + (App(APPLY, [], _), [.., T::Lambda(_), _]) => { + let ty = pop!(); + let (in_ty, out_ty) = *pop!(T::Lambda); + let (p1, p2) = match in_ty { + T::Pair(p) => *p, + t => { + return Err(TcError::NoMatchingOverload { + instr: APPLY, + stack: stack.clone(), + reason: Option::Some(NMOR::ExpectedPair(t)), + }) + } + }; + ensure_ty_eq(ctx, &p1, &ty)?; + stack.push(T::new_lambda(p2, out_ty)); + I::Apply { arg_ty: ty } + } + (App(APPLY, [], _), [.., _, _]) => no_overload!(APPLY), + (App(APPLY, [], _), [] | [_]) => no_overload!(APPLY, len 2), + (App(APPLY, expect_args!(0), _), _) => unexpected_micheline!(), + (App(other, ..), _) => todo!("Unhandled instruction {other}"), (Seq(nested), _) => I::Seq(typecheck(nested, ctx, self_entrypoints, opt_stack)?), @@ -1396,13 +1417,13 @@ pub(crate) fn typecheck_value<'a>( raw @ (V::Seq(instrs) | V::App(Prim::Lambda_rec, [V::Seq(instrs)], _)), ) => { let (in_ty, out_ty) = tys.as_ref(); - TV::Lambda(typecheck_lambda( + TV::Lambda(Closure::Lambda(typecheck_lambda( instrs, ctx, in_ty.clone(), out_ty.clone(), matches!(raw, V::App(Prim::Lambda_rec, ..)), - )?) + )?)) } (t, v) => return Err(TcError::InvalidValueForType(format!("{v:?}"), t.clone())), }) @@ -1417,17 +1438,19 @@ fn typecheck_lambda<'a>( ) -> Result, TcError> { let stk = &mut if recursive { let self_ty = Type::new_lambda(in_ty.clone(), out_ty.clone()); - tc_stk![self_ty, in_ty] + tc_stk![self_ty, in_ty.clone()] } else { - tc_stk![in_ty] + tc_stk![in_ty.clone()] }; let code = Rc::from(typecheck(instrs, ctx, None, stk)?); - unify_stacks(ctx, stk, tc_stk![out_ty])?; + unify_stacks(ctx, stk, tc_stk![out_ty.clone()])?; let micheline_code = Micheline::Seq(instrs); Ok(if recursive { Lambda::LambdaRec { micheline_code, code, + in_ty, + out_ty, } } else { Lambda::Lambda { @@ -4400,10 +4423,10 @@ mod typecheck_tests { parse("PUSH (lambda unit unit) { DROP ; UNIT }") .unwrap() .typecheck_instruction(&mut Ctx::default(), None, &[]), - Ok(Push(TypedValue::Lambda(Lambda::Lambda { + Ok(Push(TypedValue::Lambda(Closure::Lambda(Lambda::Lambda { micheline_code: seq! { app!(DROP); app!(UNIT) }, code: vec![Drop(None), Unit].into() - }))) + })))) ); assert_eq!( parse("LAMBDA unit unit { DROP ; UNIT }") @@ -4502,10 +4525,14 @@ mod typecheck_tests { parse("PUSH (lambda unit unit) (Lambda_rec { SWAP ; DROP })") .unwrap() .typecheck_instruction(&mut Ctx::default(), None, &[]), - Ok(Push(TypedValue::Lambda(Lambda::LambdaRec { - micheline_code: seq! { app!(SWAP) ; app!(DROP) }, - code: vec![Swap, Drop(None)].into() - }))) + Ok(Push(TypedValue::Lambda(Closure::Lambda( + Lambda::LambdaRec { + micheline_code: seq! { app!(SWAP) ; app!(DROP) }, + code: vec![Swap, Drop(None)].into(), + in_ty: Type::Unit, + out_ty: Type::Unit + } + )))) ); assert_eq!( parse("LAMBDA_REC unit unit { SWAP ; DROP }") @@ -4513,7 +4540,9 @@ mod typecheck_tests { .typecheck_instruction(&mut Ctx::default(), None, &[]), Ok(Lambda(Lambda::LambdaRec { micheline_code: seq! { app!(SWAP) ; app!(DROP) }, - code: vec![Swap, Drop(None)].into() + code: vec![Swap, Drop(None)].into(), + in_ty: Type::Unit, + out_ty: Type::Unit, })) ); } -- GitLab From 65cea10c798c5162ae3dd7f6e0ac3a8617715ec9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Cauderlier?= Date: Fri, 15 Dec 2023 22:23:46 +0100 Subject: [PATCH 6/8] TZT/tests: APPLY on recursive lambdas --- tzt_reference_test_suite/apply_00.tzt | 13 ++++++++++--- tzt_reference_test_suite/apply_01.tzt | 18 ++++++++++++++++++ tzt_reference_test_suite/apply_02.tzt | 23 +++++++++++++++++++++++ tzt_reference_test_suite/coverage.md | 2 ++ 4 files changed, 53 insertions(+), 3 deletions(-) create mode 100644 tzt_reference_test_suite/apply_01.tzt create mode 100644 tzt_reference_test_suite/apply_02.tzt diff --git a/tzt_reference_test_suite/apply_00.tzt b/tzt_reference_test_suite/apply_00.tzt index c3100bd309e2..53c67f6552f1 100644 --- a/tzt_reference_test_suite/apply_00.tzt +++ b/tzt_reference_test_suite/apply_00.tzt @@ -1,3 +1,10 @@ -code { APPLY } ; -input { Stack_elt string "Hi" ; Stack_elt (lambda (pair string int) nat) { DROP ; PUSH nat 1 } } ; -output { Stack_elt (lambda int nat) { PUSH string "Hi" ; PAIR ; { DROP ; PUSH nat 1 } } } +code APPLY; +input + { + Stack_elt string "Hi" ; + Stack_elt (lambda (pair string int) nat) { DROP ; PUSH nat 1 } ; + } ; +output + { + Stack_elt (lambda int nat) { PUSH string "Hi" ; PAIR ; { DROP ; PUSH nat 1 } } + } diff --git a/tzt_reference_test_suite/apply_01.tzt b/tzt_reference_test_suite/apply_01.tzt new file mode 100644 index 000000000000..2573284b80b8 --- /dev/null +++ b/tzt_reference_test_suite/apply_01.tzt @@ -0,0 +1,18 @@ +code APPLY ; +input + { + Stack_elt string "Hi" ; + Stack_elt (lambda (pair string int) nat) (Lambda_rec { DROP 2 ; PUSH nat 1 }) ; + } ; +output + { + Stack_elt + (lambda int nat) + { + PUSH string "Hi"; + PAIR; + LAMBDA_REC (pair string int) nat { DROP 2 ; PUSH nat 1 }; + SWAP; + EXEC + } + } diff --git a/tzt_reference_test_suite/apply_02.tzt b/tzt_reference_test_suite/apply_02.tzt new file mode 100644 index 000000000000..d867a580713d --- /dev/null +++ b/tzt_reference_test_suite/apply_02.tzt @@ -0,0 +1,23 @@ +code { APPLY; SWAP; APPLY } ; +input + { + Stack_elt string "Hi" ; + Stack_elt (lambda (pair string bool int) nat) (Lambda_rec { DROP 2 ; PUSH nat 1 }) ; + Stack_elt bool True ; + } ; +output + { + Stack_elt + (lambda int nat) + { + PUSH bool True; + PAIR; + { + PUSH string "Hi"; + PAIR; + LAMBDA_REC (pair string bool int) nat { DROP 2 ; PUSH nat 1 }; + SWAP; + EXEC + } + } ; + } diff --git a/tzt_reference_test_suite/coverage.md b/tzt_reference_test_suite/coverage.md index 180cc16ab79f..1f167740f97c 100644 --- a/tzt_reference_test_suite/coverage.md +++ b/tzt_reference_test_suite/coverage.md @@ -8,6 +8,8 @@ Nairobi. ### `APPLY` - [apply_00.tzt](apply_00.tzt) +- [apply_01.tzt](apply_01.tzt) +- [apply_02.tzt](apply_02.tzt) Does not check the behavior that the values that are not both pushable and storable cannot be captured. -- GitLab From d10e1dbbd4073afed276daaf5d457216209f9da3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Cauderlier?= Date: Mon, 18 Dec 2023 14:11:04 +0100 Subject: [PATCH 7/8] Tezt/TZT: regenerate regression trace This commit was generated by the following command: dune exec tezt/tests/main.exe -- --file tzt_regression.ml --reset-regressions --- tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out b/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out index 80d098321509..c3bd4ab4f826 100644 --- a/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out +++ b/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out @@ -1,5 +1,5 @@ -./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_bytes-bytes_04.tzt tzt_reference_test_suite/and_bytes-bytes_05.tzt tzt_reference_test_suite/and_bytes-bytes_06.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_bytes-bytes_04.tzt tzt_reference_test_suite/or_bytes-bytes_05.tzt tzt_reference_test_suite/or_bytes-bytes_06.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_bytes-bytes_04.tzt tzt_reference_test_suite/xor_bytes-bytes_05.tzt tzt_reference_test_suite/xor_bytes-bytes_06.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 +./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_bytes-bytes_04.tzt tzt_reference_test_suite/and_bytes-bytes_05.tzt tzt_reference_test_suite/and_bytes-bytes_06.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/apply_01.tzt tzt_reference_test_suite/apply_02.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_bytes-bytes_04.tzt tzt_reference_test_suite/or_bytes-bytes_05.tzt tzt_reference_test_suite/or_bytes-bytes_06.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_bytes-bytes_04.tzt tzt_reference_test_suite/xor_bytes-bytes_05.tzt tzt_reference_test_suite/xor_bytes-bytes_06.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 @@ -54,6 +54,6 @@ Expected: { Stack_elt _) ; Stack_elt address _ } -Test results: Passed:541 Failed:5 Total:546 +Test results: Passed:543 Failed:5 Total:548 Fatal error: Some tests have failed -- GitLab From 8c3cb2ff0e814707f3efb3924577574c129acfa1 Mon Sep 17 00:00:00 2001 From: Nikolay Yakimov Date: Mon, 18 Dec 2023 17:30:52 +0300 Subject: [PATCH 8/8] MIR: fix some clippy lints --- contrib/mir/src/interpreter.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/contrib/mir/src/interpreter.rs b/contrib/mir/src/interpreter.rs index 74d6f82461e4..4736c6e9de8d 100644 --- a/contrib/mir/src/interpreter.rs +++ b/contrib/mir/src/interpreter.rs @@ -2127,7 +2127,7 @@ mod interpreter_tests { ]; assert_eq!( interpret( - &vec![Concat(overloads::Concat::TwoStrings)], + &[Concat(overloads::Concat::TwoStrings)], &mut Ctx::default(), &mut stack ), @@ -2144,7 +2144,7 @@ mod interpreter_tests { ]; assert_eq!( interpret( - &vec![Concat(overloads::Concat::TwoBytes)], + &[Concat(overloads::Concat::TwoBytes)], &mut Ctx::default(), &mut stack ), @@ -2165,7 +2165,7 @@ mod interpreter_tests { )]; assert_eq!( interpret( - &vec![Concat(overloads::Concat::ListOfStrings)], + &[Concat(overloads::Concat::ListOfStrings)], &mut Ctx::default(), &mut stack ), @@ -2181,7 +2181,7 @@ mod interpreter_tests { ),]; assert_eq!( interpret( - &vec![Concat(overloads::Concat::ListOfStrings)], + &[Concat(overloads::Concat::ListOfStrings)], &mut Ctx::default(), &mut stack ), @@ -2195,7 +2195,7 @@ mod interpreter_tests { let mut stack = stk![TypedValue::List(vec![].into()),]; assert_eq!( interpret( - &vec![Concat(overloads::Concat::ListOfStrings)], + &[Concat(overloads::Concat::ListOfStrings)], &mut Ctx::default(), &mut stack ), @@ -2216,7 +2216,7 @@ mod interpreter_tests { )]; assert_eq!( interpret( - &vec![Concat(overloads::Concat::ListOfBytes)], + &[Concat(overloads::Concat::ListOfBytes)], &mut Ctx::default(), &mut stack ), @@ -2230,7 +2230,7 @@ mod interpreter_tests { let mut stack = stk![TypedValue::List(vec![].into())]; assert_eq!( interpret( - &vec![Concat(overloads::Concat::ListOfBytes)], + &[Concat(overloads::Concat::ListOfBytes)], &mut Ctx::default(), &mut stack ), -- GitLab