From abd10103c7227b10f3dc1d5724fe7df011e26c60 Mon Sep 17 00:00:00 2001 From: pufferfish101007 <50246616+pufferfish101007@users.noreply.github.com> Date: Sat, 8 Aug 2026 11:31:49 +0100 Subject: [PATCH 1/9] restyle instructions_test! macro to make it more readable --- src/instructions/control/if_else.rs | 6 +- src/instructions/data/addtolist.rs | 54 +++++------ src/instructions/data/deletealloflist.rs | 8 +- src/instructions/data/deleteoflist.rs | 32 +++---- src/instructions/data/insertatlist.rs | 32 +++---- src/instructions/data/itemoflist.rs | 64 ++++++------- src/instructions/data/lengthoflist.rs | 16 ++-- src/instructions/data/listcontents.rs | 80 ++++++++--------- src/instructions/data/replaceitemoflist.rs | 64 ++++++------- src/instructions/data/setvariableto.rs | 64 ++++++------- src/instructions/data/teevariable.rs | 72 +++++++-------- src/instructions/data/variable.rs | 64 ++++++------- src/instructions/data/visvariable.rs | 8 +- src/instructions/hq/boolean.rs | 12 ++- src/instructions/hq/box.rs | 6 +- src/instructions/hq/cast.rs | 24 ++++- src/instructions/hq/color_rgb.rs | 6 +- src/instructions/hq/drop.rs | 5 +- src/instructions/hq/dup.rs | 5 +- src/instructions/hq/float.rs | 6 +- src/instructions/hq/integer.rs | 6 +- src/instructions/hq/swap.rs | 5 +- src/instructions/hq/text.rs | 6 +- src/instructions/hq/yield.rs | 21 +++-- src/instructions/looks/backdropnumber.rs | 5 +- src/instructions/looks/costumename.rs | 5 +- src/instructions/looks/costumenumber.rs | 5 +- src/instructions/looks/say.rs | 12 ++- src/instructions/looks/setsizeto.rs | 5 +- src/instructions/looks/setvisible.rs | 5 +- src/instructions/looks/size.rs | 5 +- src/instructions/looks/switchbackdropto.rs | 5 +- src/instructions/looks/switchcostumeto.rs | 5 +- src/instructions/looks/think.rs | 12 ++- src/instructions/motion/direction.rs | 5 +- src/instructions/motion/gotoxy.rs | 5 +- src/instructions/motion/pointindirection.rs | 5 +- src/instructions/motion/setx.rs | 5 +- src/instructions/motion/sety.rs | 5 +- src/instructions/motion/xposition.rs | 5 +- src/instructions/motion/yposition.rs | 5 +- src/instructions/operator/abs.rs | 5 +- src/instructions/operator/acos.rs | 5 +- src/instructions/operator/add.rs | 5 +- src/instructions/operator/and.rs | 5 +- src/instructions/operator/asin.rs | 5 +- src/instructions/operator/atan.rs | 5 +- src/instructions/operator/ceiling.rs | 5 +- src/instructions/operator/contains.rs | 5 +- src/instructions/operator/cos.rs | 5 +- src/instructions/operator/divide.rs | 5 +- src/instructions/operator/equals.rs | 5 +- src/instructions/operator/exp.rs | 5 +- src/instructions/operator/floor.rs | 5 +- src/instructions/operator/gt.rs | 5 +- src/instructions/operator/join.rs | 5 +- src/instructions/operator/length.rs | 5 +- src/instructions/operator/letter_of.rs | 5 +- src/instructions/operator/ln.rs | 5 +- src/instructions/operator/log.rs | 5 +- src/instructions/operator/lt.rs | 5 +- src/instructions/operator/modulo.rs | 5 +- src/instructions/operator/multiply.rs | 5 +- src/instructions/operator/not.rs | 5 +- src/instructions/operator/or.rs | 5 +- src/instructions/operator/pow10.rs | 5 +- src/instructions/operator/random.rs | 5 +- src/instructions/operator/round.rs | 5 +- src/instructions/operator/sin.rs | 5 +- src/instructions/operator/sqrt.rs | 5 +- src/instructions/operator/subtract.rs | 5 +- src/instructions/operator/tan.rs | 5 +- src/instructions/pen/changecolorparamby.rs | 5 +- src/instructions/pen/clear.rs | 5 +- src/instructions/pen/pendown.rs | 5 +- src/instructions/pen/penup.rs | 5 +- src/instructions/pen/setpencolorparamto.rs | 5 +- src/instructions/pen/setpencolortocolor.rs | 5 +- src/instructions/pen/setpensizeto.rs | 5 +- src/instructions/sensing/answer.rs | 5 +- src/instructions/sensing/askandwait.rs | 8 +- src/instructions/sensing/dayssince2000.rs | 5 +- src/instructions/sensing/keypressed.rs | 5 +- src/instructions/sensing/mousedown.rs | 5 +- src/instructions/sensing/mousex.rs | 5 +- src/instructions/sensing/mousey.rs | 5 +- src/instructions/sensing/reset_timer.rs | 5 +- src/instructions/sensing/timer.rs | 5 +- src/instructions/tests.rs | 99 ++++++++++++--------- 89 files changed, 690 insertions(+), 412 deletions(-) diff --git a/src/instructions/control/if_else.rs b/src/instructions/control/if_else.rs index 8d8b21f0..4ad399e4 100644 --- a/src/instructions/control/if_else.rs +++ b/src/instructions/control/if_else.rs @@ -85,4 +85,8 @@ pub fn const_fold( } } -// crate::instructions_test! {none; hq__if; @ super::Fields(None)} +// crate::instructions_test! ( +// mod none for hq__if { +// fields = super::Fields(None); +// } +// ); diff --git a/src/instructions/data/addtolist.rs b/src/instructions/data/addtolist.rs index d985011e..9056d2eb 100644 --- a/src/instructions/data/addtolist.rs +++ b/src/instructions/data/addtolist.rs @@ -78,25 +78,26 @@ pub const fn const_fold( } crate::instructions_test!( - int; - data_addtolist; - t @ super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Int); - list - }, - }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + + mod int for data_addtolist(t) { + fields = super::Fields { + list: { + let list = crate::ir::RcList::new( + vec![], + &flags() + ).unwrap(); + *list.length_mutable().borrow_mut() = true; + list.add_type(IrType::Int); + list + }, + }; + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; + } + ); crate::instructions_test!( - float; - data_addtolist; - t @ super::Fields { +mod float for data_addtolist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -106,12 +107,12 @@ crate::instructions_test!( list.add_type(IrType::Float); list }, - } + }; +} ); crate::instructions_test!( - string; - data_addtolist; - t @ super::Fields { +mod string for data_addtolist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![crate::sb3::VarVal::String("hi".into())], @@ -121,12 +122,12 @@ crate::instructions_test!( list.add_type(IrType::String); list }, - } + }; +} ); crate::instructions_test!( - any; - data_addtolist; - t @ super::Fields { +mod any for data_addtolist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -136,5 +137,6 @@ crate::instructions_test!( list.add_type(IrType::Any); list }, - } + }; +} ); diff --git a/src/instructions/data/deletealloflist.rs b/src/instructions/data/deletealloflist.rs index 0d252f89..3a552e66 100644 --- a/src/instructions/data/deletealloflist.rs +++ b/src/instructions/data/deletealloflist.rs @@ -49,9 +49,8 @@ pub const fn const_fold( } crate::instructions_test!( - test; - data_deletealloflist; - @ super::Fields { +mod test for data_deletealloflist { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![crate::sb3::VarVal::Float(3.0)], @@ -61,5 +60,6 @@ crate::instructions_test!( list.add_type(IrType::Any); list }, - } + }; +} ); diff --git a/src/instructions/data/deleteoflist.rs b/src/instructions/data/deleteoflist.rs index df0be839..c0fd3361 100644 --- a/src/instructions/data/deleteoflist.rs +++ b/src/instructions/data/deleteoflist.rs @@ -84,9 +84,8 @@ pub const fn const_fold( } crate::instructions_test!( - int_mut; - data_deleteoflist; - t @ super::Fields { +mod int_mut for data_deleteoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -97,12 +96,12 @@ crate::instructions_test!( list }, }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - float_mut; - data_deleteoflist; - t @ super::Fields { +mod float_mut for data_deleteoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -112,12 +111,12 @@ crate::instructions_test!( list.add_type(IrType::Float); list }, - } + }; +} ); crate::instructions_test!( - string_mut; - data_deleteoflist; - t @ super::Fields { +mod string_mut for data_deleteoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![crate::sb3::VarVal::String("hi".into())], @@ -127,12 +126,12 @@ crate::instructions_test!( list.add_type(IrType::String); list }, - } + }; +} ); crate::instructions_test!( - any_mut; - data_deleteoflist; - t @ super::Fields { +mod any_mut for data_deleteoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -142,5 +141,6 @@ crate::instructions_test!( list.add_type(IrType::Any); list }, - } + }; +} ); diff --git a/src/instructions/data/insertatlist.rs b/src/instructions/data/insertatlist.rs index b4fb7c8c..a429d2d6 100644 --- a/src/instructions/data/insertatlist.rs +++ b/src/instructions/data/insertatlist.rs @@ -114,9 +114,8 @@ pub const fn const_fold( } crate::instructions_test!( - int_mut; - data_insertatlist; - t1, t2 @ super::Fields { +mod int_mut for data_insertatlist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -127,12 +126,12 @@ crate::instructions_test!( list }, }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - float_mut; - data_insertatlist; - t1, t2 @ super::Fields { +mod float_mut for data_insertatlist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -142,12 +141,12 @@ crate::instructions_test!( list.add_type(IrType::Float); list }, - } + }; +} ); crate::instructions_test!( - string_mut; - data_insertatlist; - t1, t2 @ super::Fields { +mod string_mut for data_insertatlist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![crate::sb3::VarVal::String("hi".into())], @@ -157,12 +156,12 @@ crate::instructions_test!( list.add_type(IrType::String); list }, - } + }; +} ); crate::instructions_test!( - any_mut; - data_insertatlist; - t1, t2 @ super::Fields { +mod any_mut for data_insertatlist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -172,5 +171,6 @@ crate::instructions_test!( list.add_type(IrType::Any); list }, - } + }; +} ); diff --git a/src/instructions/data/itemoflist.rs b/src/instructions/data/itemoflist.rs index c2863bc0..5d0e3735 100644 --- a/src/instructions/data/itemoflist.rs +++ b/src/instructions/data/itemoflist.rs @@ -112,9 +112,8 @@ pub const fn const_fold( } crate::instructions_test!( - int_mut; - data_itemoflist; - t @ super::Fields { +mod int_mut for data_itemoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -125,12 +124,12 @@ crate::instructions_test!( list }, }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - float_mut; - data_itemoflist; - t @ super::Fields { +mod float_mut for data_itemoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -140,12 +139,12 @@ crate::instructions_test!( list.add_type(IrType::Float); list }, - } + }; +} ); crate::instructions_test!( - string_mut; - data_itemoflist; - t @ super::Fields { +mod string_mut for data_itemoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![crate::sb3::VarVal::String("hi".into())], @@ -155,12 +154,12 @@ crate::instructions_test!( list.add_type(IrType::String); list }, - } + }; +} ); crate::instructions_test!( - any_mut; - data_itemoflist; - t @ super::Fields { +mod any_mut for data_itemoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -170,13 +169,13 @@ crate::instructions_test!( list.add_type(IrType::Any); list }, - } + }; +} ); crate::instructions_test!( - int_static; - data_itemoflist; - t @ super::Fields { +mod int_static for data_itemoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -186,13 +185,13 @@ crate::instructions_test!( list } }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - float_static; - data_itemoflist; - t @ super::Fields { +mod float_static for data_itemoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -201,13 +200,13 @@ crate::instructions_test!( list.add_type(IrType::Float); list } - } + }; +} ); crate::instructions_test!( - string_static; - data_itemoflist; - t @ super::Fields { +mod string_static for data_itemoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -216,13 +215,13 @@ crate::instructions_test!( list.add_type(IrType::String); list } - } + }; +} ); crate::instructions_test!( - any_static; - data_itemoflist; - t @ super::Fields { +mod any_static for data_itemoflist(t) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -231,5 +230,6 @@ crate::instructions_test!( list.add_type(IrType::Any); list } - } + }; +} ); diff --git a/src/instructions/data/lengthoflist.rs b/src/instructions/data/lengthoflist.rs index 403483bd..4e9ad045 100644 --- a/src/instructions/data/lengthoflist.rs +++ b/src/instructions/data/lengthoflist.rs @@ -63,9 +63,8 @@ pub const fn const_fold( } crate::instructions_test!( - _mut; - data_lengthoflist; - @ super::Fields { +mod _mut for data_lengthoflist { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![crate::sb3::VarVal::Float(3.0)], @@ -75,13 +74,13 @@ crate::instructions_test!( list.add_type(IrType::Any); list }, - } + }; +} ); crate::instructions_test!( - _static; - data_lengthoflist; - @ super::Fields { +mod _static for data_lengthoflist { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -90,5 +89,6 @@ crate::instructions_test!( list.add_type(IrType::Any); list } - } + }; +} ); diff --git a/src/instructions/data/listcontents.rs b/src/instructions/data/listcontents.rs index 802645c3..2da382fc 100644 --- a/src/instructions/data/listcontents.rs +++ b/src/instructions/data/listcontents.rs @@ -283,9 +283,8 @@ pub const fn const_fold( } crate::instructions_test!( - int_mut; - data_listcontents; - @ super::Fields { +mod int_mut for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -296,12 +295,12 @@ crate::instructions_test!( list }, }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - bool_mut; - data_listcontents; - @ super::Fields { +mod bool_mut for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -312,12 +311,12 @@ crate::instructions_test!( list }, }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - float_mut; - data_listcontents; - @ super::Fields { +mod float_mut for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -327,12 +326,12 @@ crate::instructions_test!( list.add_type(IrType::Float); list }, - } + }; +} ); crate::instructions_test!( - string_mut; - data_listcontents; - @ super::Fields { +mod string_mut for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![crate::sb3::VarVal::String("hi".into())], @@ -342,12 +341,12 @@ crate::instructions_test!( list.add_type(IrType::String); list }, - } + }; +} ); crate::instructions_test!( - any_mut; - data_listcontents; - @ super::Fields { +mod any_mut for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -357,13 +356,13 @@ crate::instructions_test!( list.add_type(IrType::Any); list }, - } + }; +} ); crate::instructions_test!( - int_static; - data_listcontents; - @ super::Fields { +mod int_static for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -373,13 +372,13 @@ crate::instructions_test!( list } }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - bool_static; - data_listcontents; - @ super::Fields { +mod bool_static for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -389,13 +388,13 @@ crate::instructions_test!( list } }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - float_static; - data_listcontents; - @ super::Fields { +mod float_static for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -404,13 +403,13 @@ crate::instructions_test!( list.add_type(IrType::Float); list } - } + }; +} ); crate::instructions_test!( - string_static; - data_listcontents; - @ super::Fields { +mod string_static for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -419,13 +418,13 @@ crate::instructions_test!( list.add_type(IrType::String); list } - } + }; +} ); crate::instructions_test!( - any_static; - data_listcontents; - @ super::Fields { +mod any_static for data_listcontents { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -434,5 +433,6 @@ crate::instructions_test!( list.add_type(IrType::Any); list } - } + }; +} ); diff --git a/src/instructions/data/replaceitemoflist.rs b/src/instructions/data/replaceitemoflist.rs index 2b43546e..f549fee0 100644 --- a/src/instructions/data/replaceitemoflist.rs +++ b/src/instructions/data/replaceitemoflist.rs @@ -95,9 +95,8 @@ pub const fn const_fold( } crate::instructions_test!( - int_mut; - data_replaceitemoflist; - t1, t2 @ super::Fields { +mod int_mut for data_replaceitemoflist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -108,12 +107,12 @@ crate::instructions_test!( list }, }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - float_mut; - data_replaceitemoflist; - t1, t2 @ super::Fields { +mod float_mut for data_replaceitemoflist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -123,12 +122,12 @@ crate::instructions_test!( list.add_type(IrType::Float); list }, - } + }; +} ); crate::instructions_test!( - string_mut; - data_replaceitemoflist; - t1, t2 @ super::Fields { +mod string_mut for data_replaceitemoflist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![crate::sb3::VarVal::String("hi".into())], @@ -138,12 +137,12 @@ crate::instructions_test!( list.add_type(IrType::String); list }, - } + }; +} ); crate::instructions_test!( - any_mut; - data_replaceitemoflist; - t1, t2 @ super::Fields { +mod any_mut for data_replaceitemoflist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -153,13 +152,13 @@ crate::instructions_test!( list.add_type(IrType::Any); list }, - } + }; +} ); crate::instructions_test!( - int_static; - data_replaceitemoflist; - t1, t2 @ super::Fields { +mod int_static for data_replaceitemoflist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -169,13 +168,13 @@ crate::instructions_test!( list } }; - { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags } + flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +} ); crate::instructions_test!( - float_static; - data_replaceitemoflist; - t1, t2 @ super::Fields { +mod float_static for data_replaceitemoflist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -184,13 +183,13 @@ crate::instructions_test!( list.add_type(IrType::Float); list } - } + }; +} ); crate::instructions_test!( - string_static; - data_replaceitemoflist; - t1, t2 @ super::Fields { +mod string_static for data_replaceitemoflist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -199,13 +198,13 @@ crate::instructions_test!( list.add_type(IrType::String); list } - } + }; +} ); crate::instructions_test!( - any_static; - data_replaceitemoflist; - t1, t2 @ super::Fields { +mod any_static for data_replaceitemoflist(t1, t2) { + fields = super::Fields { list: { let list = crate::ir::RcList::new( vec![], @@ -214,5 +213,6 @@ crate::instructions_test!( list.add_type(IrType::Any); list } - } + }; +} ); diff --git a/src/instructions/data/setvariableto.rs b/src/instructions/data/setvariableto.rs index 35b32ad0..dc655374 100644 --- a/src/instructions/data/setvariableto.rs +++ b/src/instructions/data/setvariableto.rs @@ -137,9 +137,8 @@ pub fn const_fold( } crate::instructions_test!( - any_global; - data_setvariableto; - t @ super::Fields { +mod any_global for data_setvariableto(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Any, @@ -148,13 +147,13 @@ crate::instructions_test!( &flags() ).unwrap()), local_write: RefCell::new(false), first_write: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - float_global; - data_setvariableto; - t @ super::Fields { +mod float_global for data_setvariableto(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Float, @@ -163,13 +162,13 @@ crate::instructions_test!( &flags() ).unwrap()), local_write: RefCell::new(false), first_write: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - string_global; - data_setvariableto; - t @ super::Fields { +mod string_global for data_setvariableto(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::String, @@ -178,13 +177,13 @@ crate::instructions_test!( &flags() ).unwrap()), local_write: RefCell::new(false), first_write: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - int_global; - data_setvariableto; - t @ super::Fields { +mod int_global for data_setvariableto(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Int, @@ -193,13 +192,13 @@ crate::instructions_test!( &flags() ).unwrap()), local_write: RefCell::new(false), first_write: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - any_local; - data_setvariableto; - t @ super::Fields { +mod any_local for data_setvariableto(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Any, @@ -208,13 +207,13 @@ crate::instructions_test!( &flags() ).unwrap()), local_write: RefCell::new(true), first_write: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - float_local; - data_setvariableto; - t @ super::Fields { +mod float_local for data_setvariableto(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Float, @@ -223,13 +222,13 @@ crate::instructions_test!( &flags() ).unwrap()), local_write: RefCell::new(true), first_write: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - string_local; - data_setvariableto; - t @ super::Fields { +mod string_local for data_setvariableto(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::String, @@ -238,13 +237,13 @@ crate::instructions_test!( &flags() ).unwrap()), local_write: RefCell::new(true), first_write: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - int_local; - data_setvariableto; - t @ super::Fields { +mod int_local for data_setvariableto(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Int, @@ -253,5 +252,6 @@ crate::instructions_test!( &flags() ).unwrap()), local_write: RefCell::new(true), first_write: RefCell::new(false) - } + }; +} ); diff --git a/src/instructions/data/teevariable.rs b/src/instructions/data/teevariable.rs index 40d6418d..19f8357f 100644 --- a/src/instructions/data/teevariable.rs +++ b/src/instructions/data/teevariable.rs @@ -136,10 +136,8 @@ pub fn const_fold( } crate::instructions_test!( - any_global; - data_teevariable; - t - @ super::Fields { +mod any_global for data_teevariable(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Any, @@ -149,14 +147,13 @@ crate::instructions_test!( ).unwrap()) , local_read_write: RefCell::new(false), - } + }; +} ); crate::instructions_test!( - float_global; - data_teevariable; - t - @ super::Fields { +mod float_global for data_teevariable(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Float, @@ -166,14 +163,13 @@ crate::instructions_test!( ).unwrap()) , local_read_write: RefCell::new(false), - } + }; +} ); crate::instructions_test!( - string_global; - data_teevariable; - t - @ super::Fields { +mod string_global for data_teevariable(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::String, @@ -183,14 +179,13 @@ crate::instructions_test!( ).unwrap()) , local_read_write: RefCell::new(false), - } + }; +} ); crate::instructions_test!( - int_global; - data_teevariable; - t - @ super::Fields { +mod int_global for data_teevariable(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Int, @@ -200,14 +195,13 @@ crate::instructions_test!( ).unwrap()) , local_read_write: RefCell::new(false), - } + }; +} ); crate::instructions_test!( - any_local; - data_teevariable; - t - @ super::Fields { +mod any_local for data_teevariable(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Any, @@ -217,14 +211,13 @@ crate::instructions_test!( ).unwrap() ), local_read_write: RefCell::new(true), - } + }; +} ); crate::instructions_test!( - float_local; - data_teevariable; - t - @ super::Fields { +mod float_local for data_teevariable(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Float, @@ -234,14 +227,13 @@ crate::instructions_test!( ).unwrap() ), local_read_write: RefCell::new(true), - } + }; +} ); crate::instructions_test!( - string_local; - data_teevariable; - t - @ super::Fields { +mod string_local for data_teevariable(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::String, @@ -250,14 +242,13 @@ crate::instructions_test!( &flags() ).unwrap()), local_read_write: RefCell::new(true), - } + }; +} ); crate::instructions_test!( - int_local; - data_teevariable; - t - @ super::Fields { +mod int_local for data_teevariable(t) { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Int, @@ -266,5 +257,6 @@ crate::instructions_test!( &flags() ).unwrap()), local_read_write: RefCell::new(true), - } + }; +} ); diff --git a/src/instructions/data/variable.rs b/src/instructions/data/variable.rs index 1c622dac..b3e17263 100644 --- a/src/instructions/data/variable.rs +++ b/src/instructions/data/variable.rs @@ -77,9 +77,8 @@ pub fn const_fold( } crate::instructions_test!( - any_global; - data_variable; - @ super::Fields { +mod any_global for data_variable { + fields = super::Fields { var: RefCell::new ( crate::ir::RcVar::new( @@ -91,13 +90,13 @@ crate::instructions_test!( ) , local_read: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - float_global; - data_variable; - @ super::Fields { +mod float_global for data_variable { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Float, @@ -107,13 +106,13 @@ crate::instructions_test!( ).unwrap() ), local_read: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - string_global; - data_variable; - @ super::Fields { +mod string_global for data_variable { + fields = super::Fields { var: RefCell::new ( crate::ir::RcVar::new( @@ -125,13 +124,13 @@ crate::instructions_test!( ) , local_read: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - int_global; - data_variable; - @ super::Fields { +mod int_global for data_variable { + fields = super::Fields { var: RefCell::new ( crate::ir::RcVar::new( @@ -143,13 +142,13 @@ crate::instructions_test!( ) , local_read: RefCell::new(false) - } + }; +} ); crate::instructions_test!( - any_local; - data_variable; - @ super::Fields { +mod any_local for data_variable { + fields = super::Fields { var: RefCell::new ( crate::ir::RcVar::new( @@ -161,13 +160,13 @@ crate::instructions_test!( ) , local_read: RefCell::new(true) - } + }; +} ); crate::instructions_test!( - float_local; - data_variable; - @ super::Fields { +mod float_local for data_variable { + fields = super::Fields { var: RefCell::new ( crate::ir::RcVar::new( @@ -179,13 +178,13 @@ crate::instructions_test!( ) , local_read: RefCell::new(true) - } + }; +} ); crate::instructions_test!( - string_local; - data_variable; - @ super::Fields { +mod string_local for data_variable { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::String, @@ -196,13 +195,13 @@ crate::instructions_test!( ), local_read: RefCell::new(true) - } + }; +} ); crate::instructions_test!( - int_local; - data_variable; - @ super::Fields { +mod int_local for data_variable { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Int, @@ -212,5 +211,6 @@ crate::instructions_test!( ).unwrap() ), local_read: RefCell::new(true) - } + }; +} ); diff --git a/src/instructions/data/visvariable.rs b/src/instructions/data/visvariable.rs index 012ce495..bd83c7dd 100644 --- a/src/instructions/data/visvariable.rs +++ b/src/instructions/data/visvariable.rs @@ -70,9 +70,8 @@ pub const fn const_fold( } crate::instructions_test!( - test; - data_visvariable; - @ super::Fields { +mod test for data_visvariable { + fields = super::Fields { var: RefCell::new( crate::ir::RcVar::new( IrType::Any, @@ -85,5 +84,6 @@ crate::instructions_test!( ).unwrap()) , visible: true - } + }; +} ); diff --git a/src/instructions/hq/boolean.rs b/src/instructions/hq/boolean.rs index 2a1dd1f6..ae13b134 100644 --- a/src/instructions/hq/boolean.rs +++ b/src/instructions/hq/boolean.rs @@ -52,5 +52,13 @@ pub fn const_fold( )]))) } -crate::instructions_test! {tests_false; hq_boolean; @ super::Fields(false)} -crate::instructions_test! {tests_true; hq_boolean; @ super::Fields(true)} +crate::instructions_test! ( +mod tests_false for hq_boolean { + fields = super::Fields(false); +} +); +crate::instructions_test! ( +mod tests_true for hq_boolean { + fields = super::Fields(true); +} +); diff --git a/src/instructions/hq/box.rs b/src/instructions/hq/box.rs index 23def6c3..8cde63fc 100644 --- a/src/instructions/hq/box.rs +++ b/src/instructions/hq/box.rs @@ -53,4 +53,8 @@ pub fn const_fold( }) } -crate::instructions_test! {tests; hq_box; t @ super::Fields { output_ty: IrType::Any }} +crate::instructions_test! ( +mod tests for hq_box(t) { + fields = super::Fields { output_ty: IrType::Any }; +} +); diff --git a/src/instructions/hq/cast.rs b/src/instructions/hq/cast.rs index af04f297..7188a1cc 100644 --- a/src/instructions/hq/cast.rs +++ b/src/instructions/hq/cast.rs @@ -346,7 +346,23 @@ pub fn const_fold( }) } -crate::instructions_test! {float; hq_cast; t @ super::Fields(IrType::Float)} -crate::instructions_test! {string; hq_cast; t @ super::Fields(IrType::String)} -crate::instructions_test! {int; hq_cast; t @ super::Fields(IrType::Int)} -crate::instructions_test! {boolean; hq_cast; t @ super::Fields(IrType::Boolean)} +crate::instructions_test! ( +mod float for hq_cast(t) { + fields = super::Fields(IrType::Float); +} +); +crate::instructions_test! ( +mod string for hq_cast(t) { + fields = super::Fields(IrType::String); +} +); +crate::instructions_test! ( +mod int for hq_cast(t) { + fields = super::Fields(IrType::Int); +} +); +crate::instructions_test! ( +mod boolean for hq_cast(t) { + fields = super::Fields(IrType::Boolean); +} +); diff --git a/src/instructions/hq/color_rgb.rs b/src/instructions/hq/color_rgb.rs index e8e1b3d3..6be6915f 100644 --- a/src/instructions/hq/color_rgb.rs +++ b/src/instructions/hq/color_rgb.rs @@ -54,4 +54,8 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; hq_color_rgb; @ super::Fields { r: 134, g: 56, b: 109 }} +crate::instructions_test! ( +mod tests for hq_color_rgb { + fields = super::Fields { r: 134, g: 56, b: 109 }; +} +); diff --git a/src/instructions/hq/drop.rs b/src/instructions/hq/drop.rs index 17feaa94..3917b146 100644 --- a/src/instructions/hq/drop.rs +++ b/src/instructions/hq/drop.rs @@ -18,4 +18,7 @@ pub fn const_fold(_inputs: &[ConstFoldItem], _state: &mut ConstFoldState) -> HQR Ok(ConstFold::Folded(Rc::from([]))) } -crate::instructions_test! {tests; hq_drop; t} +crate::instructions_test! ( +mod tests for hq_drop(t) { +} +); diff --git a/src/instructions/hq/dup.rs b/src/instructions/hq/dup.rs index f5bbed5a..e9508bdc 100644 --- a/src/instructions/hq/dup.rs +++ b/src/instructions/hq/dup.rs @@ -24,4 +24,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; hq_dup; t} +crate::instructions_test! ( +mod tests for hq_dup(t) { +} +); diff --git a/src/instructions/hq/float.rs b/src/instructions/hq/float.rs index 48a93e0e..7998bccc 100644 --- a/src/instructions/hq/float.rs +++ b/src/instructions/hq/float.rs @@ -58,4 +58,8 @@ pub fn const_fold( )]))) } -crate::instructions_test! {tests; hq_float; @ super::Fields(0.0)} +crate::instructions_test! ( +mod tests for hq_float { + fields = super::Fields(0.0); +} +); diff --git a/src/instructions/hq/integer.rs b/src/instructions/hq/integer.rs index efe0639f..8bf34296 100644 --- a/src/instructions/hq/integer.rs +++ b/src/instructions/hq/integer.rs @@ -53,4 +53,8 @@ pub fn const_fold( )]))) } -crate::instructions_test! {tests; hq_integer; @ super::Fields(0)} +crate::instructions_test! ( +mod tests for hq_integer { + fields = super::Fields(0); +} +); diff --git a/src/instructions/hq/swap.rs b/src/instructions/hq/swap.rs index 97854c83..1d4ed52a 100644 --- a/src/instructions/hq/swap.rs +++ b/src/instructions/hq/swap.rs @@ -32,4 +32,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; hq_swap; t1, t2} +crate::instructions_test! ( +mod tests for hq_swap(t1,t2) { +} +); diff --git a/src/instructions/hq/text.rs b/src/instructions/hq/text.rs index 48d2f5c2..83919939 100644 --- a/src/instructions/hq/text.rs +++ b/src/instructions/hq/text.rs @@ -60,4 +60,8 @@ pub fn const_fold( )]))) } -crate::instructions_test! {tests; hq_text; @ super::Fields("hello, world!".into())} +crate::instructions_test! ( +mod tests for hq_text { + fields = super::Fields("hello, world!".into()); +} +); diff --git a/src/instructions/hq/yield.rs b/src/instructions/hq/yield.rs index 790c4e8b..49426ac3 100644 --- a/src/instructions/hq/yield.rs +++ b/src/instructions/hq/yield.rs @@ -193,14 +193,21 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {none; hq_yield; @ super::Fields { mode: super::YieldMode::None }} +crate::instructions_test! ( +mod none for hq_yield { + fields = super::Fields { mode: super::YieldMode::None }; +} +); -crate::instructions_test! {ret; hq_yield; @ super::Fields { mode: super::YieldMode::Return }} +crate::instructions_test! ( +mod ret for hq_yield { + fields = super::Fields { mode: super::YieldMode::Return }; +} +); -// crate::instructions_test! { -// schedule; -// hq_yield; -// @ super::Fields { +// crate::instructions_test! ( +// mod schedule for hq_yield { +// fields = super::Fields { // mode: super::YieldMode::Schedule( // crate::rc::Rc::downgrade(&crate::ir::Step::new_empty( // &crate::rc::Rc::downgrade(&Rc::new(crate::ir::IrProject::new(BTreeMap::default(), BTreeMap::default(), Box::from([])))), @@ -219,4 +226,6 @@ crate::instructions_test! {ret; hq_yield; @ super::Fields { mode: super::YieldMo // ).unwrap()) // ) // } +//; // } +// ); diff --git a/src/instructions/looks/backdropnumber.rs b/src/instructions/looks/backdropnumber.rs index fb677d80..b2a1e4fc 100644 --- a/src/instructions/looks/backdropnumber.rs +++ b/src/instructions/looks/backdropnumber.rs @@ -33,4 +33,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; looks_backdropnumber; ; } +crate::instructions_test! ( +mod tests for looks_backdropnumber { +} +); diff --git a/src/instructions/looks/costumename.rs b/src/instructions/looks/costumename.rs index 266be5d5..5dd35977 100644 --- a/src/instructions/looks/costumename.rs +++ b/src/instructions/looks/costumename.rs @@ -64,4 +64,7 @@ pub const fn const_fold( Ok(NotFoldable) } -// crate::instructions_test! {tests; looks_costumename; ; } +// crate::instructions_test! ( +// mod tests for looks_costumename { +// } +// ); diff --git a/src/instructions/looks/costumenumber.rs b/src/instructions/looks/costumenumber.rs index b4f75e00..0b2b8615 100644 --- a/src/instructions/looks/costumenumber.rs +++ b/src/instructions/looks/costumenumber.rs @@ -39,4 +39,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; looks_costumenumber; ; } +crate::instructions_test! ( +mod tests for looks_costumenumber { +} +); diff --git a/src/instructions/looks/say.rs b/src/instructions/looks/say.rs index 43d8ba9f..c78575a2 100644 --- a/src/instructions/looks/say.rs +++ b/src/instructions/looks/say.rs @@ -96,5 +96,13 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests_debug; looks_say; t @ super::Fields { debug: true, target_idx: 0 }} -crate::instructions_test! {tests_non_debug; looks_say; t @ super::Fields { debug: false, target_idx: 0, }} +crate::instructions_test! ( +mod tests_debug for looks_say(t) { + fields = super::Fields { debug: true, target_idx: 0 }; +} +); +crate::instructions_test! ( +mod tests_non_debug for looks_say(t) { + fields = super::Fields { debug: false, target_idx: 0, }; +} +); diff --git a/src/instructions/looks/setsizeto.rs b/src/instructions/looks/setsizeto.rs index 56bf24e5..ce38be37 100644 --- a/src/instructions/looks/setsizeto.rs +++ b/src/instructions/looks/setsizeto.rs @@ -55,4 +55,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; looks_setsizeto; t ; } +crate::instructions_test! ( +mod tests for looks_setsizeto(t) { +} +); diff --git a/src/instructions/looks/setvisible.rs b/src/instructions/looks/setvisible.rs index 23689dd5..90d612f9 100644 --- a/src/instructions/looks/setvisible.rs +++ b/src/instructions/looks/setvisible.rs @@ -52,4 +52,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; looks_setvisible; t ; } +crate::instructions_test! ( +mod tests for looks_setvisible(t) { +} +); diff --git a/src/instructions/looks/size.rs b/src/instructions/looks/size.rs index 92baba17..f0409d57 100644 --- a/src/instructions/looks/size.rs +++ b/src/instructions/looks/size.rs @@ -37,4 +37,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; looks_size; ; } +crate::instructions_test! ( +mod tests for looks_size { +} +); diff --git a/src/instructions/looks/switchbackdropto.rs b/src/instructions/looks/switchbackdropto.rs index 84ab68eb..2b4723f0 100644 --- a/src/instructions/looks/switchbackdropto.rs +++ b/src/instructions/looks/switchbackdropto.rs @@ -64,4 +64,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; looks_switchbackdropto; t ; } +crate::instructions_test! ( +mod tests for looks_switchbackdropto(t) { +} +); diff --git a/src/instructions/looks/switchcostumeto.rs b/src/instructions/looks/switchcostumeto.rs index 3795d50c..7628a270 100644 --- a/src/instructions/looks/switchcostumeto.rs +++ b/src/instructions/looks/switchcostumeto.rs @@ -76,4 +76,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; looks_switchcostumeto; t ; } +crate::instructions_test! ( +mod tests for looks_switchcostumeto(t) { +} +); diff --git a/src/instructions/looks/think.rs b/src/instructions/looks/think.rs index d4eb8726..51029b1c 100644 --- a/src/instructions/looks/think.rs +++ b/src/instructions/looks/think.rs @@ -96,5 +96,13 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests_debug; looks_think; t @ super::Fields { debug: true, target_idx: 0 }} -crate::instructions_test! {tests_non_debug; looks_think; t @ super::Fields { debug: false, target_idx: 0, }} +crate::instructions_test! ( +mod tests_debug for looks_think(t) { + fields = super::Fields { debug: true, target_idx: 0 }; +} +); +crate::instructions_test! ( +mod tests_non_debug for looks_think(t) { + fields = super::Fields { debug: false, target_idx: 0, }; +} +); diff --git a/src/instructions/motion/direction.rs b/src/instructions/motion/direction.rs index a6102437..6fcbc468 100644 --- a/src/instructions/motion/direction.rs +++ b/src/instructions/motion/direction.rs @@ -38,4 +38,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; motion_direction; } +crate::instructions_test! ( +mod tests for motion_direction { +} +); diff --git a/src/instructions/motion/gotoxy.rs b/src/instructions/motion/gotoxy.rs index 937b4718..ebb10da7 100644 --- a/src/instructions/motion/gotoxy.rs +++ b/src/instructions/motion/gotoxy.rs @@ -161,4 +161,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; motion_gotoxy; t1, t2 ; } +crate::instructions_test! ( +mod tests for motion_gotoxy(t1,t2) { +} +); diff --git a/src/instructions/motion/pointindirection.rs b/src/instructions/motion/pointindirection.rs index e21ce3c8..509a77f4 100644 --- a/src/instructions/motion/pointindirection.rs +++ b/src/instructions/motion/pointindirection.rs @@ -56,4 +56,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; motion_pointindirection; t } +crate::instructions_test! ( +mod tests for motion_pointindirection(t) { +} +); diff --git a/src/instructions/motion/setx.rs b/src/instructions/motion/setx.rs index d9995fc7..f7fc83b6 100644 --- a/src/instructions/motion/setx.rs +++ b/src/instructions/motion/setx.rs @@ -170,4 +170,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; motion_setx; t ; } +crate::instructions_test! ( +mod tests for motion_setx(t) { +} +); diff --git a/src/instructions/motion/sety.rs b/src/instructions/motion/sety.rs index aa4eeed6..cf29d265 100644 --- a/src/instructions/motion/sety.rs +++ b/src/instructions/motion/sety.rs @@ -170,4 +170,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; motion_setx; t ; } +crate::instructions_test! ( +mod tests for motion_setx(t) { +} +); diff --git a/src/instructions/motion/xposition.rs b/src/instructions/motion/xposition.rs index fc260381..c73528b6 100644 --- a/src/instructions/motion/xposition.rs +++ b/src/instructions/motion/xposition.rs @@ -38,4 +38,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; motion_xposition; } +crate::instructions_test! ( +mod tests for motion_xposition { +} +); diff --git a/src/instructions/motion/yposition.rs b/src/instructions/motion/yposition.rs index 5d77a6e4..94e69d37 100644 --- a/src/instructions/motion/yposition.rs +++ b/src/instructions/motion/yposition.rs @@ -38,4 +38,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; motion_yposition; } +crate::instructions_test! ( +mod tests for motion_yposition { +} +); diff --git a/src/instructions/operator/abs.rs b/src/instructions/operator/abs.rs index c95a98e8..1992ba40 100644 --- a/src/instructions/operator/abs.rs +++ b/src/instructions/operator/abs.rs @@ -74,4 +74,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_abs; t } +crate::instructions_test! ( +mod tests for operator_abs(t) { +} +); diff --git a/src/instructions/operator/acos.rs b/src/instructions/operator/acos.rs index d86015ef..588e02c6 100644 --- a/src/instructions/operator/acos.rs +++ b/src/instructions/operator/acos.rs @@ -34,4 +34,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_acos; t } +crate::instructions_test! ( +mod tests for operator_acos(t) { +} +); diff --git a/src/instructions/operator/add.rs b/src/instructions/operator/add.rs index 32e2a35c..6966f483 100644 --- a/src/instructions/operator/add.rs +++ b/src/instructions/operator/add.rs @@ -86,4 +86,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_add; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_add(t1,t2) { +} +); diff --git a/src/instructions/operator/and.rs b/src/instructions/operator/and.rs index 64a5bdd7..41e3a88a 100644 --- a/src/instructions/operator/and.rs +++ b/src/instructions/operator/and.rs @@ -21,4 +21,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_and; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_and(t1,t2) { +} +); diff --git a/src/instructions/operator/asin.rs b/src/instructions/operator/asin.rs index 3f5fd9ef..f427cb01 100644 --- a/src/instructions/operator/asin.rs +++ b/src/instructions/operator/asin.rs @@ -34,4 +34,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_asin; t } +crate::instructions_test! ( +mod tests for operator_asin(t) { +} +); diff --git a/src/instructions/operator/atan.rs b/src/instructions/operator/atan.rs index 83b3b3cb..4cf9ca79 100644 --- a/src/instructions/operator/atan.rs +++ b/src/instructions/operator/atan.rs @@ -34,4 +34,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_atan; t } +crate::instructions_test! ( +mod tests for operator_atan(t) { +} +); diff --git a/src/instructions/operator/ceiling.rs b/src/instructions/operator/ceiling.rs index 9a6193c4..47f75bef 100644 --- a/src/instructions/operator/ceiling.rs +++ b/src/instructions/operator/ceiling.rs @@ -61,4 +61,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_ceiling; t } +crate::instructions_test! ( +mod tests for operator_ceiling(t) { +} +); diff --git a/src/instructions/operator/contains.rs b/src/instructions/operator/contains.rs index ce351ea3..64fc0d50 100644 --- a/src/instructions/operator/contains.rs +++ b/src/instructions/operator/contains.rs @@ -29,4 +29,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_contains; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_contains(t1,t2) { +} +); diff --git a/src/instructions/operator/cos.rs b/src/instructions/operator/cos.rs index e597c175..107ad6b7 100644 --- a/src/instructions/operator/cos.rs +++ b/src/instructions/operator/cos.rs @@ -41,4 +41,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_cos; t } +crate::instructions_test! ( +mod tests for operator_cos(t) { +} +); diff --git a/src/instructions/operator/divide.rs b/src/instructions/operator/divide.rs index 3c1d73bf..e49c71ad 100644 --- a/src/instructions/operator/divide.rs +++ b/src/instructions/operator/divide.rs @@ -50,4 +50,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_divide; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_divide(t1,t2) { +} +); diff --git a/src/instructions/operator/equals.rs b/src/instructions/operator/equals.rs index a72e59f3..d813e39c 100644 --- a/src/instructions/operator/equals.rs +++ b/src/instructions/operator/equals.rs @@ -400,4 +400,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_equals; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_equals(t1,t2) { +} +); diff --git a/src/instructions/operator/exp.rs b/src/instructions/operator/exp.rs index 6b97ce37..c43bd4a2 100644 --- a/src/instructions/operator/exp.rs +++ b/src/instructions/operator/exp.rs @@ -38,4 +38,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_exp; t } +crate::instructions_test! ( +mod tests for operator_exp(t) { +} +); diff --git a/src/instructions/operator/floor.rs b/src/instructions/operator/floor.rs index 627f54de..0634d195 100644 --- a/src/instructions/operator/floor.rs +++ b/src/instructions/operator/floor.rs @@ -61,4 +61,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_floor; t } +crate::instructions_test! ( +mod tests for operator_floor(t) { +} +); diff --git a/src/instructions/operator/gt.rs b/src/instructions/operator/gt.rs index 3efa060c..1b53825e 100644 --- a/src/instructions/operator/gt.rs +++ b/src/instructions/operator/gt.rs @@ -326,4 +326,7 @@ pub fn const_fold(inputs: &[ConstFoldItem], _state: &mut ConstFoldState) -> HQRe ) } -crate::instructions_test! {tests; operator_lt; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_lt(t1,t2) { +} +); diff --git a/src/instructions/operator/join.rs b/src/instructions/operator/join.rs index b18fbafc..41fe537d 100644 --- a/src/instructions/operator/join.rs +++ b/src/instructions/operator/join.rs @@ -34,4 +34,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_join; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_join(t1,t2) { +} +); diff --git a/src/instructions/operator/length.rs b/src/instructions/operator/length.rs index 8e2b5587..e92ff8bf 100644 --- a/src/instructions/operator/length.rs +++ b/src/instructions/operator/length.rs @@ -26,4 +26,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_length; t ;} +crate::instructions_test! ( +mod tests for operator_length(t) { +} +); diff --git a/src/instructions/operator/letter_of.rs b/src/instructions/operator/letter_of.rs index 75f68257..a9bb51c4 100644 --- a/src/instructions/operator/letter_of.rs +++ b/src/instructions/operator/letter_of.rs @@ -47,4 +47,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_letter_of; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_letter_of(t1,t2) { +} +); diff --git a/src/instructions/operator/ln.rs b/src/instructions/operator/ln.rs index e1767e46..d7350e77 100644 --- a/src/instructions/operator/ln.rs +++ b/src/instructions/operator/ln.rs @@ -42,4 +42,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_ln; t } +crate::instructions_test! ( +mod tests for operator_ln(t) { +} +); diff --git a/src/instructions/operator/log.rs b/src/instructions/operator/log.rs index 6bd87020..84922854 100644 --- a/src/instructions/operator/log.rs +++ b/src/instructions/operator/log.rs @@ -40,4 +40,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_log; t } +crate::instructions_test! ( +mod tests for operator_log(t) { +} +); diff --git a/src/instructions/operator/lt.rs b/src/instructions/operator/lt.rs index 2ee40276..61cf1e26 100644 --- a/src/instructions/operator/lt.rs +++ b/src/instructions/operator/lt.rs @@ -287,4 +287,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_lt; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_lt(t1,t2) { +} +); diff --git a/src/instructions/operator/modulo.rs b/src/instructions/operator/modulo.rs index 1d1fcf8d..cfe4afdb 100644 --- a/src/instructions/operator/modulo.rs +++ b/src/instructions/operator/modulo.rs @@ -187,4 +187,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_modulo; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_modulo(t1,t2) { +} +); diff --git a/src/instructions/operator/multiply.rs b/src/instructions/operator/multiply.rs index 4f200c68..c9d66d87 100644 --- a/src/instructions/operator/multiply.rs +++ b/src/instructions/operator/multiply.rs @@ -90,4 +90,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_multiply; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_multiply(t1,t2) { +} +); diff --git a/src/instructions/operator/not.rs b/src/instructions/operator/not.rs index 5db046b4..e71cf464 100644 --- a/src/instructions/operator/not.rs +++ b/src/instructions/operator/not.rs @@ -21,4 +21,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_not; t ;} +crate::instructions_test! ( +mod tests for operator_not(t) { +} +); diff --git a/src/instructions/operator/or.rs b/src/instructions/operator/or.rs index 46d68965..5c450a9f 100644 --- a/src/instructions/operator/or.rs +++ b/src/instructions/operator/or.rs @@ -21,4 +21,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_or; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_or(t1,t2) { +} +); diff --git a/src/instructions/operator/pow10.rs b/src/instructions/operator/pow10.rs index fa63ec59..1af6fced 100644 --- a/src/instructions/operator/pow10.rs +++ b/src/instructions/operator/pow10.rs @@ -38,4 +38,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_pow10; t } +crate::instructions_test! ( +mod tests for operator_pow10(t) { +} +); diff --git a/src/instructions/operator/random.rs b/src/instructions/operator/random.rs index cf7e984f..7e3854e1 100644 --- a/src/instructions/operator/random.rs +++ b/src/instructions/operator/random.rs @@ -193,4 +193,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_random; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_random(t1,t2) { +} +); diff --git a/src/instructions/operator/round.rs b/src/instructions/operator/round.rs index 5f2c297a..de576a2e 100644 --- a/src/instructions/operator/round.rs +++ b/src/instructions/operator/round.rs @@ -38,4 +38,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_round; t } +crate::instructions_test! ( +mod tests for operator_round(t) { +} +); diff --git a/src/instructions/operator/sin.rs b/src/instructions/operator/sin.rs index 6690f514..5f7190b3 100644 --- a/src/instructions/operator/sin.rs +++ b/src/instructions/operator/sin.rs @@ -41,4 +41,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_sin; t } +crate::instructions_test! ( +mod tests for operator_sin(t) { +} +); diff --git a/src/instructions/operator/sqrt.rs b/src/instructions/operator/sqrt.rs index 55fe0820..603b4f3f 100644 --- a/src/instructions/operator/sqrt.rs +++ b/src/instructions/operator/sqrt.rs @@ -32,4 +32,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_sqrt; t } +crate::instructions_test! ( +mod tests for operator_sqrt(t) { +} +); diff --git a/src/instructions/operator/subtract.rs b/src/instructions/operator/subtract.rs index ae139110..39124536 100644 --- a/src/instructions/operator/subtract.rs +++ b/src/instructions/operator/subtract.rs @@ -88,4 +88,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_subtract; t1, t2 ;} +crate::instructions_test! ( +mod tests for operator_subtract(t1,t2) { +} +); diff --git a/src/instructions/operator/tan.rs b/src/instructions/operator/tan.rs index e2eca02f..44adbd4d 100644 --- a/src/instructions/operator/tan.rs +++ b/src/instructions/operator/tan.rs @@ -38,4 +38,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; operator_tan; t } +crate::instructions_test! ( +mod tests for operator_tan(t) { +} +); diff --git a/src/instructions/pen/changecolorparamby.rs b/src/instructions/pen/changecolorparamby.rs index ad890996..084cbfed 100644 --- a/src/instructions/pen/changecolorparamby.rs +++ b/src/instructions/pen/changecolorparamby.rs @@ -147,4 +147,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests_colour; pen_changecolorparamby; t1, t2 } +crate::instructions_test! ( +mod tests_colour for pen_changecolorparamby(t1,t2) { +} +); diff --git a/src/instructions/pen/clear.rs b/src/instructions/pen/clear.rs index 9ca24e01..757af79f 100644 --- a/src/instructions/pen/clear.rs +++ b/src/instructions/pen/clear.rs @@ -25,4 +25,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; pen_clear; ; } +crate::instructions_test! ( +mod tests for pen_clear { +} +); diff --git a/src/instructions/pen/pendown.rs b/src/instructions/pen/pendown.rs index c5b1ad20..0589fc18 100644 --- a/src/instructions/pen/pendown.rs +++ b/src/instructions/pen/pendown.rs @@ -95,4 +95,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; pen_pendown; ; } +crate::instructions_test! ( +mod tests for pen_pendown { +} +); diff --git a/src/instructions/pen/penup.rs b/src/instructions/pen/penup.rs index 30e4b88c..1a0fb04a 100644 --- a/src/instructions/pen/penup.rs +++ b/src/instructions/pen/penup.rs @@ -37,4 +37,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; pen_penup; ; } +crate::instructions_test! ( +mod tests for pen_penup { +} +); diff --git a/src/instructions/pen/setpencolorparamto.rs b/src/instructions/pen/setpencolorparamto.rs index 38b09457..3e99e425 100644 --- a/src/instructions/pen/setpencolorparamto.rs +++ b/src/instructions/pen/setpencolorparamto.rs @@ -119,4 +119,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests_colour; pen_setpencolorparamto; t1, t2 } +crate::instructions_test! ( +mod tests_colour for pen_setpencolorparamto(t1,t2) { +} +); diff --git a/src/instructions/pen/setpencolortocolor.rs b/src/instructions/pen/setpencolortocolor.rs index 7dd9f7ec..709e456c 100644 --- a/src/instructions/pen/setpencolortocolor.rs +++ b/src/instructions/pen/setpencolortocolor.rs @@ -122,4 +122,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; pen_setpencolortocolor; t ; } +crate::instructions_test! ( +mod tests for pen_setpencolortocolor(t) { +} +); diff --git a/src/instructions/pen/setpensizeto.rs b/src/instructions/pen/setpensizeto.rs index c1d553b0..b5ee0ef0 100644 --- a/src/instructions/pen/setpensizeto.rs +++ b/src/instructions/pen/setpensizeto.rs @@ -44,4 +44,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; pen_setpensizeto; t ; } +crate::instructions_test! ( +mod tests for pen_setpensizeto(t) { +} +); diff --git a/src/instructions/sensing/answer.rs b/src/instructions/sensing/answer.rs index e8827639..b70b1ab1 100644 --- a/src/instructions/sensing/answer.rs +++ b/src/instructions/sensing/answer.rs @@ -36,4 +36,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; sensing_answer; ;} +crate::instructions_test! ( +mod tests for sensing_answer { +} +); diff --git a/src/instructions/sensing/askandwait.rs b/src/instructions/sensing/askandwait.rs index 7547a44f..f30c100f 100644 --- a/src/instructions/sensing/askandwait.rs +++ b/src/instructions/sensing/askandwait.rs @@ -93,7 +93,11 @@ pub const fn const_fold( Ok(NotFoldable) } -// crate::instructions_test! { tests; sensing_askandwait; t @ super::Fields { +// crate::instructions_test! ( +// mod tests for sensing_askandwait { +// fields = super::Fields { // poll_step: super::StepIndex(0), // next_step: super::StepIndex(0), -// }} +// }; +// } +// ); diff --git a/src/instructions/sensing/dayssince2000.rs b/src/instructions/sensing/dayssince2000.rs index 3cfdace0..0a29df20 100644 --- a/src/instructions/sensing/dayssince2000.rs +++ b/src/instructions/sensing/dayssince2000.rs @@ -26,4 +26,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; sensing_dayssince2000; ;} +crate::instructions_test! ( +mod tests for sensing_dayssince2000 { +} +); diff --git a/src/instructions/sensing/keypressed.rs b/src/instructions/sensing/keypressed.rs index b0fb0bc9..513ca25c 100644 --- a/src/instructions/sensing/keypressed.rs +++ b/src/instructions/sensing/keypressed.rs @@ -25,4 +25,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; sensing_keypressed; t ;} +crate::instructions_test! ( +mod tests for sensing_keypressed(t) { +} +); diff --git a/src/instructions/sensing/mousedown.rs b/src/instructions/sensing/mousedown.rs index f6c46e82..24f7035b 100644 --- a/src/instructions/sensing/mousedown.rs +++ b/src/instructions/sensing/mousedown.rs @@ -35,4 +35,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; sensing_mousedown; ;} +crate::instructions_test! ( +mod tests for sensing_mousedown { +} +); diff --git a/src/instructions/sensing/mousex.rs b/src/instructions/sensing/mousex.rs index 3b738091..1b0cb466 100644 --- a/src/instructions/sensing/mousex.rs +++ b/src/instructions/sensing/mousex.rs @@ -35,4 +35,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; sensing_mousex; ;} +crate::instructions_test! ( +mod tests for sensing_mousex { +} +); diff --git a/src/instructions/sensing/mousey.rs b/src/instructions/sensing/mousey.rs index 9272fbdc..64887bb3 100644 --- a/src/instructions/sensing/mousey.rs +++ b/src/instructions/sensing/mousey.rs @@ -35,4 +35,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; sensing_mousey; ;} +crate::instructions_test! ( +mod tests for sensing_mousey { +} +); diff --git a/src/instructions/sensing/reset_timer.rs b/src/instructions/sensing/reset_timer.rs index d280533e..8f3c2f6a 100644 --- a/src/instructions/sensing/reset_timer.rs +++ b/src/instructions/sensing/reset_timer.rs @@ -36,4 +36,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; sensing_reset_timer; ;} +crate::instructions_test! ( +mod tests for sensing_reset_timer { +} +); diff --git a/src/instructions/sensing/timer.rs b/src/instructions/sensing/timer.rs index ff42f6e9..977ab3fc 100644 --- a/src/instructions/sensing/timer.rs +++ b/src/instructions/sensing/timer.rs @@ -35,4 +35,7 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! {tests; sensing_timer; ;} +crate::instructions_test! ( +mod tests for sensing_timer { +} +); diff --git a/src/instructions/tests.rs b/src/instructions/tests.rs index 2c93e17f..d111d49b 100644 --- a/src/instructions/tests.rs +++ b/src/instructions/tests.rs @@ -1,52 +1,60 @@ /// Generates unit tests for instructions files. /// -/// Takes a module name, followed by a semicolon, -/// collowed by the full name of the opcode (in the form of `_`), followed by an optional -/// comma-separated list of arbitrary identifiers corresponding to the number of inputs the block -/// takes, optionally followed by a semicolon and an expression for a sensible default for any fields, -/// optionally followed by a semicolon and a `WasmFlags` configuration (defaults to `Default::default()`). -/// If multiple field values or flags configurations need to be tested, the macro can be repeated with -/// different module names. +/// For a block `peppa_pig` which takes 0 inputs, +/// ```ignore +/// instructions_test!(mod test for peppa_pig {}); +/// ``` /// /// Example: /// For a block `foo_bar`, which takes 2 inputs, with Fields(bool), /// ```ignore -/// instructions_test!(test; foo_bar; t1, t2 @ super::Fields(true)); -/// instructions_test!(test; foo_bar; t1, t2 @ super::Fields(false)); +/// instructions_test!(mod test_true for foo_bar(t1, t2) { +/// fields = super::Fields(true); +/// }); +/// instructions_test!(mod test_false for foo_bar(t1, t2) { +/// fields = super::Fields(false); +/// }); /// ``` #[macro_export] macro_rules! instructions_test { - {$module:ident; $opcode:ident; $($type_arg:ident $(,)?)* $(@$fields:expr)? $(;)?} => { - $crate::instructions_test!{$module; $opcode; $($type_arg,)* $(@$fields)? ; WasmFlags::new(unit_test_wasm_features())} - }; - {$module:ident; $opcode:ident; $($type_arg:ident $(,)?)* $(@ $fields:expr)? ; $flags:expr} => { + { + mod $module:ident for $opcode:ident$(($($type_arg:ident $(,)?)*))? { + $(fields = $fields:expr;)? + $(flags = $flags:expr;)? + $(setup = $setup:expr;)? + } + } => { #[cfg(test)] mod $module { - fn flags() -> $crate::wasm::WasmFlags { - $flags - } + #![expect(clippy::allow_attributes, reason = "might not always trigger")] use super::{wasm, output_type, acceptable_inputs}; use $crate::prelude::*; use $crate::ir::{IrType, ReturnType}; use wasm_encoder::ValType; use $crate::wasm::{StepFunc, Registries, WasmProject, WasmFlags, StepTarget, ExternalEnvironment}; - #[expect(clippy::allow_attributes, reason = "might not always trigger")] #[allow(unused, reason = "it might not be unused")] use $crate::wasm::flags::{Switch, unit_test_wasm_features}; - #[expect(clippy::allow_attributes, reason = "might not always trigger")] + fn flags() -> $crate::wasm::WasmFlags { + #[allow(unused_mut, reason = "may not be unused")] + #[allow(unused_assignments, reason = "may not be unused")] + let mut flags = WasmFlags::new(unit_test_wasm_features()); + $(flags = $flags;)? + flags + } + #[allow(unused_macros, reason = "it is not unused")] macro_rules! ident_as_irtype { ( $_:ident ) => { IrType }; } - fn types_iter(base_only: bool) -> impl Iterator { + fn types_iter(base_only: bool) -> impl Iterator { // we need to collect this iterator into a Vec because it doesn't implement clone for some reason, // which makes itertools angry - $(let $type_arg = IrType::flags().map(|(_, ty)| *ty).collect::>();)* - itertools::iproduct!($($type_arg,)*).filter(move |($($type_arg,)*)| { - let types: &[&IrType] = &[$($type_arg,)*]; + $($(let $type_arg = IrType::flags().map(|(_, ty)| *ty).collect::>();)*)? + itertools::iproduct!($($($type_arg,)*)?).filter(move |($($($type_arg,)*)?)| { + let types: &[&IrType] = &[$($($type_arg,)*)?]; for (i, input) in (*types).into_iter().enumerate() { // non-base types should be handled and unboxed by a wrapper function // contained in src/instructions/input_switcher.rs @@ -65,15 +73,19 @@ macro_rules! instructions_test { #[test] fn output_type_fails_when_wasm_fails() { - for ($($type_arg,)*) in types_iter(true) { - let output_type_result = output_type(Rc::from([$($type_arg,)*]), $(&$fields)?); + for ($($($type_arg,)*)?) in types_iter(true) { + #[allow(unused_mut, reason = "may not be unused")] + #[allow(unused, reason = "might not be unused")] + let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser); + $($setup(&mut proj, flags());)? + let output_type_result = output_type(Rc::from([$($($type_arg,)*)?]), $(&$fields)?); let registries = Rc::new(Registries::default()); let step_func = StepFunc::new(Rc::clone(®istries), flags(), StepTarget::Sprite(0), 0, Rc::new(vec![])); - let wasm_result = wasm(&step_func, Rc::from([$($type_arg,)*]), $(&$fields)?); + let wasm_result = wasm(&step_func, Rc::from([$($($type_arg,)*)?]), $(&$fields)?); match (output_type_result.clone(), wasm_result.clone()) { - (Err(..), Ok(..)) | (Ok(..), Err(..)) => panic!("output_type result doesn't match wasm result for type(s) {:?}:\noutput_type: {:?},\nwasm: {:?}", ($($type_arg,)*), output_type_result, wasm_result), + (Err(..), Ok(..)) | (Ok(..), Err(..)) => panic!("output_type result doesn't match wasm result for type(s) {:?}:\noutput_type: {:?},\nwasm: {:?}", ($($($type_arg,)*)?), output_type_result, wasm_result), (Err(HQError { err_type: e1, .. }), Err(HQError { err_type: e2, .. })) if e1 != e2 => { - panic!("output_type result doesn't match wasm result for type(s) {:?}:\noutput_type: {:?},\nwasm: {:?}", ($($type_arg,)*), output_type_result, wasm_result); + panic!("output_type result doesn't match wasm result for type(s) {:?}:\noutput_type: {:?},\nwasm: {:?}", ($($($type_arg,)*)?), output_type_result, wasm_result); } _ => (), } @@ -82,23 +94,24 @@ macro_rules! instructions_test { #[test] fn wasm_output_type_matches_expected_output_type() -> HQResult<()> { - for ($($type_arg,)*) in types_iter(true) { - - let Ok(output_type) = output_type(Rc::from([$($type_arg,)*]), $(&$fields)?) else { + for ($($($type_arg,)*)?) in types_iter(true) { + #[allow(unused_mut, reason = "may not be unused")] + let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser); + $($setup(&mut proj, flags());)? + let Ok(output_type) = output_type(Rc::from([$($($type_arg,)*)?]), $(&$fields)?) else { println!("skipping failed output_type"); continue; }; - let proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser); let registries = proj.registries(); - let types: &[IrType] = &[$($type_arg,)*]; - let params = [ValType::I32, $crate::wasm::registries::TypeRegistry::STRUCT_REF].into_iter().chain([$($type_arg,)*].into_iter().map(WasmProject::ir_type_to_wasm)).collect::>(); + let types: &[IrType] = &[$($($type_arg,)*)?]; + let params = [ValType::I32, $crate::wasm::registries::TypeRegistry::STRUCT_REF].into_iter().chain([$($($type_arg,)*)?].into_iter().map(WasmProject::ir_type_to_wasm)).collect::>(); let result = match output_type { ReturnType::Singleton(output) => vec![WasmProject::ir_type_to_wasm(output)], ReturnType::MultiValue(outputs) => outputs.iter().copied().map(WasmProject::ir_type_to_wasm).collect(), ReturnType::None => vec![], }; let step_func = StepFunc::new_with_types(params.into(), result.into(), Rc::clone(®istries), flags(), StepTarget::Sprite(0), 0, Rc::new(vec![])); - let Ok(wasm) = wasm(&step_func, Rc::from([$($type_arg,)*]), $(&$fields)?) else { + let Ok(wasm) = wasm(&step_func, Rc::from([$($($type_arg,)*)?]), $(&$fields)?) else { println!("skipping failed wasm"); continue; }; @@ -115,29 +128,31 @@ macro_rules! instructions_test { println!("{}", wasmprinter::print_bytes(wasm_bytes.clone()).unwrap()); - wasmparser::validate(&wasm_bytes).map_err(|err| make_hq_bug!("invalid wasm module with types {:?}. Original error message: {}", ($($type_arg,)*), err.message()))?; + wasmparser::validate(&wasm_bytes).map_err(|err| make_hq_bug!("invalid wasm module with types {:?}. Original error message: {}", ($($($type_arg,)*)?), err.message()))?; } Ok(()) } #[test] fn wasm_output_type_matches_wrapped_expected_output_type() -> HQResult<()> { - for ($($type_arg,)*) in types_iter(false) { + for ($($($type_arg,)*)?) in types_iter(false) { + #[allow(unused_mut, reason = "may not be unused")] + let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser); + $($setup(&mut proj, flags());)? let Ok(output_type) = $crate::instructions::boxed_output_type( |inputs| output_type(inputs, $(&$fields)?), - Rc::from([$($type_arg,)*]), + Rc::from([$($($type_arg,)*)?]), ) else { println!("skipping failed output_type"); continue; }; println!("{output_type:?}"); - let proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser); let registries = proj.registries(); - let types: &[IrType] = &[$($type_arg,)*]; + let types: &[IrType] = &[$($($type_arg,)*)?]; let params = [ValType::I32, $crate::wasm::registries::TypeRegistry::STRUCT_REF] .into_iter() .chain( - [$($type_arg,)*] + [$($($type_arg,)*)?] .into_iter() .map(WasmProject::ir_type_to_wasm) ) @@ -163,7 +178,7 @@ macro_rules! instructions_test { .collect::>(); let wasm = $crate::instructions::wrap_instructions( &step_func, - Rc::from([$($type_arg,)*]), + Rc::from([$($($type_arg,)*)?]), &test_opcodes, )?; // println!("{wasm:?}"); @@ -191,7 +206,7 @@ macro_rules! instructions_test { wasmparser::validate(&wasm_bytes).map_err(|err| make_hq_bug!( "invalid wasm module with types {:?}. Original error message: {}", - ($($type_arg,)*), + ($($($type_arg,)*)?), err.message() ) )?; From 4378bfa51c5240dfe5e064e4f69938c3a3c3a4d3 Mon Sep 17 00:00:00 2001 From: pufferfish101007 <50246616+pufferfish101007@users.noreply.github.com> Date: Sat, 8 Aug 2026 19:23:43 +0100 Subject: [PATCH 2/9] remove unnecessary `collect` --- src/wasm/func.rs | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/wasm/func.rs b/src/wasm/func.rs index a9b9349c..44cfc4f2 100644 --- a/src/wasm/func.rs +++ b/src/wasm/func.rs @@ -463,15 +463,11 @@ impl StepFunc { let target_index = step.try_borrow()?.context().target().index(); let step_func = if let Some(ref proc_context) = step.try_borrow()?.context().proc_context { let params = if step.try_borrow()?.context().warp { - let arg_types = (*proc_context.arg_vars) + (*proc_context.arg_vars) .borrow() .iter() .map(|var| WasmProject::ir_type_to_wasm(*var.possible_types())) - .collect::>(); - arg_types - .iter() - .chain(&[ValType::I32, TypeRegistry::STRUCT_REF]) - .copied() + .chain([ValType::I32, TypeRegistry::STRUCT_REF]) .collect() } else { Box::from([ValType::I32, TypeRegistry::STRUCT_REF]) From 6c20622a285a1ce25798ce2359b2b72bbec40ac0 Mon Sep 17 00:00:00 2001 From: pufferfish101007 <50246616+pufferfish101007@users.noreply.github.com> Date: Sat, 8 Aug 2026 19:38:39 +0100 Subject: [PATCH 3/9] add tests for procedures_call_(non)warp --- src/instructions/procedures/call_nonwarp.rs | 83 +++++++++++++++ src/instructions/procedures/call_warp.rs | 111 ++++++++++++++++++++ src/ir/proc.rs | 53 ++++++++-- 3 files changed, 240 insertions(+), 7 deletions(-) diff --git a/src/instructions/procedures/call_nonwarp.rs b/src/instructions/procedures/call_nonwarp.rs index 869f805d..4d553a39 100644 --- a/src/instructions/procedures/call_nonwarp.rs +++ b/src/instructions/procedures/call_nonwarp.rs @@ -1,6 +1,7 @@ use wasm_encoder::{FieldType, HeapType, Instruction as WInstruction, StorageType}; use super::super::prelude::*; +use crate::instructions_test; use crate::ir::{Proc, StepIndex}; use crate::wasm::registries::functions::static_functions::SpawnThreadInStack; use crate::wasm::{StepFunc, WasmProject}; @@ -133,3 +134,85 @@ pub const fn const_fold( ) -> HQResult { Ok(NotFoldable) } + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(2); + assert!(serde_json::from_str::(format!("{fields}").as_str()).is_ok()); + } + + pub fn test_project_setup(wasm_proj: &WasmProject, flags: crate::wasm::WasmFlags) { + let proc_step_func = StepFunc::new_with_types( + Box::from([ + ValType::I32, + crate::wasm::registries::TypeRegistry::STRUCT_REF, + ]), + vec![].into(), + Rc::clone(&wasm_proj.registries()), + flags, + crate::wasm::StepTarget::Sprite(0), + 0, + Rc::new(vec![]), + ); + wasm_proj.steps().borrow_mut().push(proc_step_func); + } + + pub fn make_fields(num_inputs: usize) -> super::Fields { + super::Fields { + proc: { + use crate::ir::{PartialStep, StepIndex, Target}; + + let target = Rc::new(Target::new( + false, + BTreeMap::default(), + BTreeMap::default(), + Weak::new(), + RefCell::new(BTreeMap::default()), + 0, + Box::new([]), + )); + let proc = Rc::new(super::Proc::new( + format!("foo {}", core::iter::repeat_n("%s", num_inputs).join(" ")).into(), + RefCell::new(None), + RefCell::new(None), + None, + false, + Box::new([]), + Box::new([]), + Rc::clone(&target), + false, + )); + let specific_proc = proc.new_specific_proc(); + *specific_proc.first_step_mut() = PartialStep::Finished(StepIndex(0)); + *proc.nonwarped_specific_proc_mut() = Some(specific_proc); + proc + }, + next_step: super::StepIndex(0), + } + } +} + +instructions_test!( + mod test_nullary for procedures_call_nonwarp { + fields = super::test::make_fields(0); + setup = super::test::test_project_setup; + } +); + +instructions_test!( + mod test_unary for procedures_call_nonwarp(t) { + fields = super::test::make_fields(1); + setup = super::test::test_project_setup; + } +); + +instructions_test!( + mod test_ternary for procedures_call_nonwarp(t1, t2, t3) { + fields = super::test::make_fields(3); + setup = super::test::test_project_setup; + } +); diff --git a/src/instructions/procedures/call_warp.rs b/src/instructions/procedures/call_warp.rs index ae6e2a3b..40025399 100644 --- a/src/instructions/procedures/call_warp.rs +++ b/src/instructions/procedures/call_warp.rs @@ -1,6 +1,7 @@ use wasm_encoder::Instruction as WInstruction; use super::super::prelude::*; +use crate::instructions_test; use crate::ir::Proc; use crate::wasm::{StepFunc, WasmProject}; @@ -105,3 +106,113 @@ pub const fn const_fold( ) -> HQResult { Ok(NotFoldable) } + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(&[IrType::Any]); + assert!(serde_json::from_str::(format!("{fields}").as_str()).is_ok()); + } + + pub fn test_project_setup( + wasm_proj: &WasmProject, + flags: crate::wasm::WasmFlags, + inputs: &[IrType], + ) { + let proc_step_func = StepFunc::new_with_types( + inputs + .iter() + .map(|ty| WasmProject::ir_type_to_wasm(*ty)) + .chain([ + ValType::I32, + crate::wasm::registries::TypeRegistry::STRUCT_REF, + ]) + .collect(), + vec![].into(), + Rc::clone(&wasm_proj.registries()), + flags, + crate::wasm::StepTarget::Sprite(0), + 0, + Rc::new(vec![]), + ); + wasm_proj.steps().borrow_mut().push(proc_step_func); + } + + pub fn make_fields(inputs: &[IrType]) -> super::Fields { + super::Fields { + proc: { + use crate::ir::{PartialStep, StepIndex, Target}; + + let target = Rc::new(Target::new( + false, + BTreeMap::default(), + BTreeMap::default(), + Weak::new(), + RefCell::new(BTreeMap::default()), + 0, + Box::new([]), + )); + let proc = Rc::new(super::Proc::new( + format!("foo {}", core::iter::repeat_n("%s", inputs.len()).join(" ")).into(), + RefCell::new(None), + RefCell::new(None), + None, + false, + Box::new([]), + Box::new([]), + Rc::clone(&target), + false, + )); + let specific_proc = proc.new_specific_proc(); + *specific_proc.first_step_mut() = PartialStep::Finished(StepIndex(0)); + *proc.warped_specific_proc_mut() = Some(specific_proc); + proc + }, + } + } +} + +instructions_test!( + mod test_nullary for procedures_call_warp { + fields = super::test::make_fields(&[]); + setup = |proj, flags| super::test::test_project_setup(proj, flags, &[]); + } +); + +instructions_test!( + mod test_unary_string for procedures_call_warp(t) { + fields = super::test::make_fields(&[IrType::String]); + setup = |proj, flags| super::test::test_project_setup(proj, flags, &[IrType::String]); + } +); + +instructions_test!( + mod test_unary_int for procedures_call_warp(t) { + fields = super::test::make_fields(&[IrType::Int]); + setup = |proj, flags| super::test::test_project_setup(proj, flags, &[IrType::Int]); + } +); + +instructions_test!( + mod test_unary_float for procedures_call_warp(t) { + fields = super::test::make_fields(&[IrType::Float]); + setup = |proj, flags| super::test::test_project_setup(proj, flags, &[IrType::Float]); + } +); + +instructions_test!( + mod test_unary_bool for procedures_call_warp(t) { + fields = super::test::make_fields(&[IrType::Boolean]); + setup = |proj, flags| super::test::test_project_setup(proj, flags, &[IrType::Boolean]); + } +); + +instructions_test!( + mod test_unary_any for procedures_call_warp(t) { + fields = super::test::make_fields(&[IrType::Any]); + setup = |proj, flags| super::test::test_project_setup(proj, flags, &[IrType::Any]); + } +); diff --git a/src/ir/proc.rs b/src/ir/proc.rs index 85f3bdba..f1207ad7 100644 --- a/src/ir/proc.rs +++ b/src/ir/proc.rs @@ -34,6 +34,11 @@ impl SpecificProc { Ok(self.first_step.try_borrow()?) } + #[cfg(test)] + pub fn first_step_mut(&self) -> RefMut<'_, PartialStep> { + self.first_step.borrow_mut() + } + #[must_use] pub fn arg_vars(&self) -> Rc>> { Rc::clone(&self.arg_vars) @@ -74,10 +79,20 @@ impl Proc { self.warped_specific_proc.borrow() } + #[cfg(test)] + pub fn warped_specific_proc_mut(&self) -> RefMut<'_, Option> { + self.warped_specific_proc.borrow_mut() + } + pub fn nonwarped_specific_proc(&self) -> Ref<'_, Option> { self.nonwarped_specific_proc.borrow() } + #[cfg(test)] + pub fn nonwarped_specific_proc_mut(&self) -> RefMut<'_, Option> { + self.nonwarped_specific_proc.borrow_mut() + } + pub fn proccode(&self) -> &str { &self.proccode } @@ -247,20 +262,44 @@ impl Proc { }; let arg_ids = Self::string_vec_mutation(mutations, "argumentids")?; let arg_names = Self::string_vec_mutation(mutations, "argumentnames")?; - Ok(Rc::new(Self { - proccode: proccode.as_str().into(), - warped_specific_proc: RefCell::new(None), - nonwarped_specific_proc: RefCell::new(None), + Ok(Rc::new(Self::new( + proccode.as_str().into(), + RefCell::new(None), + RefCell::new(None), + first_step_id, + debug, + arg_ids, + arg_names, + target, + warp, + ))) + } + + pub const fn new( + proccode: Box, + warped_specific_proc: RefCell>, + nonwarped_specific_proc: RefCell>, + first_step_id: Option>, + debug: bool, + arg_ids: Box<[Box]>, + arg_names: Box<[Box]>, + target: Rc, + always_warped: bool, + ) -> Self { + Self { + warped_specific_proc, + nonwarped_specific_proc, first_step_id, + proccode, debug, arg_ids, arg_names, target, - always_warped: warp, - })) + always_warped, + } } - fn new_specific_proc(&self) -> SpecificProc { + pub fn new_specific_proc(&self) -> SpecificProc { SpecificProc { first_step: RefCell::new(PartialStep::None), arg_vars: arg_vars_from_proccode(&self.proccode), From 5e12b17354ccda7de088aa577113030b80594da2 Mon Sep 17 00:00:00 2001 From: pufferfish101007 <50246616+pufferfish101007@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:51:19 +0100 Subject: [PATCH 4/9] update rust nightly version --- rust-toolchain.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust-toolchain.toml b/rust-toolchain.toml index 71798b6e..a4540fe6 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,3 +1,3 @@ [toolchain] -channel = "nightly-2026-06-21" +channel = "nightly-2026-08-07" targets = [ "wasm32-unknown-unknown" ] \ No newline at end of file From e753ad94065da0e072b5ade1120fde131271e8f3 Mon Sep 17 00:00:00 2001 From: pufferfish101007 <50246616+pufferfish101007@users.noreply.github.com> Date: Sat, 8 Aug 2026 20:52:46 +0100 Subject: [PATCH 5/9] lint --- src/instructions/procedures/argument.rs | 1 - src/wasm/project.rs | 1 - 2 files changed, 2 deletions(-) diff --git a/src/instructions/procedures/argument.rs b/src/instructions/procedures/argument.rs index 3b4dd5d7..f52ef4b3 100644 --- a/src/instructions/procedures/argument.rs +++ b/src/instructions/procedures/argument.rs @@ -37,7 +37,6 @@ pub fn wasm( arg_vars, }: &Fields, ) -> HQResult> { - #[expect(clippy::redundant_else, reason = "false positive")] if *in_warped { hq_assert!( WasmProject::ir_type_to_wasm(*arg_var.possible_types()) diff --git a/src/wasm/project.rs b/src/wasm/project.rs index dddedf72..a01477e5 100644 --- a/src/wasm/project.rs +++ b/src/wasm/project.rs @@ -525,7 +525,6 @@ impl WasmProject { .events .keys() .filter_map(|e| { - #[expect(clippy::redundant_else, reason = "false positive")] if let Event::SpriteClicked(index) = e { Some( i32::try_from(*index) From ea2152d8690b9eb03b3c84a331e76f0a54513f7e Mon Sep 17 00:00:00 2001 From: pufferfish101007 <50246616+pufferfish101007@users.noreply.github.com> Date: Sun, 9 Aug 2026 20:12:42 +0100 Subject: [PATCH 6/9] more instructions tests + testing for field `Display` JSON-validity [part 1] --- .../control/get_thread_timeout.rs | 2 + src/instructions/control/if_else.rs | 30 ++- src/instructions/control/loop.rs | 102 +++++++++ src/instructions/control/stop_all.rs | 6 +- src/instructions/control/wait.rs | 43 ++++ src/instructions/data/addtolist.rs | 85 +++----- src/instructions/data/deletealloflist.rs | 42 ++-- src/instructions/data/deleteoflist.rs | 89 +++----- src/instructions/data/insertatlist.rs | 89 +++----- src/instructions/data/lengthoflist.rs | 51 ++--- src/instructions/data/listcontents.rs | 206 +++++++----------- src/instructions/data/replaceitemoflist.rs | 153 +++++-------- src/instructions/data/setvariableto.rs | 148 +++++-------- src/instructions/data/teevariable.rs | 153 +++++-------- src/instructions/data/variable.rs | 183 ++++++---------- src/instructions/data/visvariable.rs | 49 +++-- src/instructions/event/broadcast.rs | 26 ++- src/instructions/event/broadcast_and_wait.rs | 43 ++++ src/instructions/hq/boolean.rs | 24 +- src/instructions/hq/box.rs | 19 +- src/instructions/hq/cast.rs | 38 +++- src/instructions/hq/color_rgb.rs | 17 +- src/instructions/hq/drop.rs | 3 +- src/instructions/hq/dup.rs | 3 +- src/instructions/hq/float.rs | 17 +- src/instructions/hq/integer.rs | 17 +- src/instructions/hq/swap.rs | 3 +- src/instructions/hq/text.rs | 17 +- src/instructions/hq/yield.rs | 91 +++++--- src/instructions/procedures/call_nonwarp.rs | 16 +- src/instructions/procedures/call_warp.rs | 16 +- src/instructions/tests.rs | 64 +++++- 32 files changed, 977 insertions(+), 868 deletions(-) diff --git a/src/instructions/control/get_thread_timeout.rs b/src/instructions/control/get_thread_timeout.rs index 1f8a426f..c95a4eed 100644 --- a/src/instructions/control/get_thread_timeout.rs +++ b/src/instructions/control/get_thread_timeout.rs @@ -1,3 +1,5 @@ +//! This block must be called from within a thread spawned by `control_wait`, or it will trap. + use wasm_encoder::{FieldType, HeapType, StorageType}; use super::super::prelude::*; diff --git a/src/instructions/control/if_else.rs b/src/instructions/control/if_else.rs index 4ad399e4..e2f78c36 100644 --- a/src/instructions/control/if_else.rs +++ b/src/instructions/control/if_else.rs @@ -85,8 +85,28 @@ pub fn const_fold( } } -// crate::instructions_test! ( -// mod none for hq__if { -// fields = super::Fields(None); -// } -// ); +#[cfg(test)] +mod test { + use super::*; + use super::super::super::tests::*; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields() -> Fields { + let target = make_target(); + Fields { + branch_if: make_step(&target), + branch_else: make_step(&target), + } + } +} + +crate::instructions_test! ( +mod test2 for control_if_else(t) { + fields = super::test::make_fields(); +} +); diff --git a/src/instructions/control/loop.rs b/src/instructions/control/loop.rs index a169317e..807e4f5e 100644 --- a/src/instructions/control/loop.rs +++ b/src/instructions/control/loop.rs @@ -20,6 +20,9 @@ impl fmt::Display for Fields { if let Some(ref step) = self.first_condition { write!(f, r#""first_condition": {},"#, RefCell::borrow(step))?; } + if let Some(ref step) = self.pre_body { + write!(f, r#""pre_body": {},"#, RefCell::borrow(step))?; + } write!( f, r#" @@ -92,3 +95,102 @@ pub const fn const_fold( ) -> HQResult { Ok(NotFoldable) } + +#[cfg(test)] +mod test { + use super::super::super::tests::*; + use super::*; + use crate::ir::StepContext; + + #[test] + fn fields_display_is_valid_json() { + for ((fc, pb), fi) in [true, false] + .into_iter() + .cartesian_product([true, false]) + .cartesian_product([true, false]) + { + let fields = make_fields(fc, pb, fi); + assert_valid_json(format!("{fields}")); + } + } + + fn make_condition_step(context: &StepContext) -> Rc> { + Rc::new(RefCell::new(Step::new( + None, + context.clone(), + vec![crate::instructions::IrOpcode::hq_boolean( + crate::instructions::HqBooleanFields(true), + )], + Weak::new(), + false, + ))) + } + + pub fn make_fields(first_condition: bool, pre_body: bool, flip_if: bool) -> Fields { + let target = make_target(); + let context = make_context(&target); + Fields { + first_condition: if first_condition { + None + } else { + Some(make_condition_step(&context)) + }, + condition: make_condition_step(&context), + pre_body: if pre_body { + None + } else { + Some(make_step(&target)) + }, + body: make_step(&target), + flip_if, + } + } +} + +crate::instructions_test! ( +mod test_fc_pb_fi for control_loop { + fields = super::test::make_fields(true, true, true); +} +); + +crate::instructions_test! ( +mod test_fc_pb for control_loop { + fields = super::test::make_fields(true, true, false); +} +); + +crate::instructions_test! ( +mod test_fc_fi for control_loop { + fields = super::test::make_fields(true, false, true); +} +); + +crate::instructions_test! ( +mod test_fc for control_loop { + fields = super::test::make_fields(true, false, false); +} +); + +crate::instructions_test! ( +mod test_pb_fi for control_loop { + fields = super::test::make_fields(false, true, true); +} +); + +crate::instructions_test! ( +mod test_pb for control_loop { + fields = super::test::make_fields(false, true, false); +} +); + +crate::instructions_test! ( +mod test_fi for control_loop { + fields = super::test::make_fields(false, false, true); +} +); + +crate::instructions_test! ( +mod test_defaults for control_loop { + fields = super::test::make_fields(false, false, false); +} +); diff --git a/src/instructions/control/stop_all.rs b/src/instructions/control/stop_all.rs index 46a605a6..f60994d7 100644 --- a/src/instructions/control/stop_all.rs +++ b/src/instructions/control/stop_all.rs @@ -1,7 +1,7 @@ use wasm_encoder::{ConstExpr, HeapType}; use super::super::prelude::*; -use crate::wasm::{GlobalExportable, GlobalMutable, ThreadsTable}; +use crate::{instructions_test, wasm::{GlobalExportable, GlobalMutable, ThreadsTable}}; pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult> { let threads_count = func.registries().globals().register( @@ -43,3 +43,7 @@ pub const fn const_fold( ) -> HQResult { Ok(NotFoldable) } + +instructions_test!( + mod test for control_stop_all {} +); \ No newline at end of file diff --git a/src/instructions/control/wait.rs b/src/instructions/control/wait.rs index ee8031c9..8e749f9f 100644 --- a/src/instructions/control/wait.rs +++ b/src/instructions/control/wait.rs @@ -1,6 +1,7 @@ use wasm_encoder::{AbstractHeapType, ConstExpr, FieldType, HeapType, StorageType}; use super::super::prelude::*; +use crate::instructions_test; use crate::ir::StepIndex; use crate::wasm::registries::functions::static_functions::SpawnThreadInStack; use crate::wasm::{GlobalExportable, GlobalMutable, StepFunc}; @@ -104,3 +105,45 @@ pub const fn const_fold( ) -> HQResult { Ok(NotFoldable) } + +#[cfg(test)] +mod test { + use super::super::super::tests::*; + use super::*; + use crate::wasm::registries::TypeRegistry; + use crate::wasm::{StepTarget, WasmFlags, WasmProject}; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields() -> Fields { + Fields { + poll_step: StepIndex(0), + next_step: StepIndex(1), + } + } + + pub fn setup_project(wasm_proj: &WasmProject, flags: WasmFlags) { + let step_func = StepFunc::new_with_types( + Box::from([ValType::I32, TypeRegistry::STRUCT_REF]), + Box::from([]), + wasm_proj.registries(), + flags, + StepTarget::Sprite(0), + 0, + Rc::new(vec![]), + ); + wasm_proj.steps().borrow_mut().push(step_func); + } +} + +instructions_test!( + mod test2 for control_wait(t) { + fields = super::test::make_fields(); + setup = super::test::setup_project; + } +); + diff --git a/src/instructions/data/addtolist.rs b/src/instructions/data/addtolist.rs index 9056d2eb..d9f95fb1 100644 --- a/src/instructions/data/addtolist.rs +++ b/src/instructions/data/addtolist.rs @@ -77,66 +77,47 @@ pub const fn const_fold( Ok(NotFoldable) } +#[cfg(test)] +mod test { + pub use super::super::listcontents::test_utils::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(true, IrType::Any, flags_with_integers()); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(mutable: bool, ty: IrType, flags: WasmFlags) -> Fields { + Fields { + list: make_list(mutable, ty, flags), + } + } +} + crate::instructions_test!( - mod int for data_addtolist(t) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Int); - list - }, - }; - flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; + mod test_int for data_addtolist(t) { + fields = super::test::make_fields(true, IrType::Int, flags()); + flags = super::test::flags_with_integers(); } ); crate::instructions_test!( -mod float for data_addtolist(t) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Float); - list - }, - }; -} + mod test_float for data_addtolist(t) { + fields = super::test::make_fields(true, IrType::Float, flags()); + } ); + crate::instructions_test!( -mod string for data_addtolist(t) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![crate::sb3::VarVal::String("hi".into())], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::String); - list - }, - }; -} + mod test_string for data_addtolist(t) { + fields = super::test::make_fields(true, IrType::String, flags()); + } ); crate::instructions_test!( -mod any for data_addtolist(t) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Any); - list - }, - }; -} + mod test_any for data_addtolist(t) { + fields = super::test::make_fields(true, IrType::String, flags()); + } ); diff --git a/src/instructions/data/deletealloflist.rs b/src/instructions/data/deletealloflist.rs index 3a552e66..6913a3b2 100644 --- a/src/instructions/data/deletealloflist.rs +++ b/src/instructions/data/deletealloflist.rs @@ -48,18 +48,34 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test!( -mod test for data_deletealloflist { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![crate::sb3::VarVal::Float(3.0)], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Any); - list - }, - }; +#[cfg(test)] +mod test { + pub use super::super::listcontents::test_utils::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(flags_with_integers()); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(flags: WasmFlags) -> Fields { + Fields { + list: { + let list = + crate::ir::RcList::new(vec![crate::sb3::VarVal::Float(3.0)], &flags).unwrap(); + *list.length_mutable().borrow_mut() = true; + list.add_type(IrType::Any); + list + }, + } + } } + +crate::instructions_test!( + mod test2 for data_deletealloflist { + fields = super::test::make_fields(flags()); + } ); diff --git a/src/instructions/data/deleteoflist.rs b/src/instructions/data/deleteoflist.rs index c0fd3361..7a3a338d 100644 --- a/src/instructions/data/deleteoflist.rs +++ b/src/instructions/data/deleteoflist.rs @@ -83,64 +83,47 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test!( -mod int_mut for data_deleteoflist(t) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Int); - list - }, - }; - flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +#[cfg(test)] +mod test { + pub use super::super::listcontents::test_utils::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(IrType::Any, flags_with_integers()); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(ty: IrType, flags: WasmFlags) -> Fields { + Fields { + list: make_list(true, ty, flags), + } + } } + +crate::instructions_test!( + mod test_int for data_deleteoflist(t) { + fields = super::test::make_fields(IrType::Int, flags()); + flags = super::test::flags_with_integers(); + } ); + crate::instructions_test!( -mod float_mut for data_deleteoflist(t) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Float); - list - }, - }; -} + mod test_float for data_deleteoflist(t) { + fields = super::test::make_fields(IrType::Float, flags()); + } ); + crate::instructions_test!( -mod string_mut for data_deleteoflist(t) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![crate::sb3::VarVal::String("hi".into())], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::String); - list - }, - }; -} + mod test_string for data_deleteoflist(t) { + fields = super::test::make_fields(IrType::String, flags()); + } ); + crate::instructions_test!( -mod any_mut for data_deleteoflist(t) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Any); - list - }, - }; -} + mod test_any for data_deleteoflist(t) { + fields = super::test::make_fields(IrType::Any, flags()); + } ); diff --git a/src/instructions/data/insertatlist.rs b/src/instructions/data/insertatlist.rs index a429d2d6..9413670f 100644 --- a/src/instructions/data/insertatlist.rs +++ b/src/instructions/data/insertatlist.rs @@ -113,64 +113,47 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test!( -mod int_mut for data_insertatlist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Int); - list - }, - }; - flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +#[cfg(test)] +mod test { + pub use super::super::listcontents::test_utils::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(IrType::Any, flags_with_integers()); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(ty: IrType, flags: WasmFlags) -> Fields { + Fields { + list: make_list(true, ty, flags), + } + } } + +crate::instructions_test!( + mod test_int for data_insertatlist(t1, t2) { + fields = super::test::make_fields(IrType::Int, flags()); + flags = super::test::flags_with_integers(); + } ); + crate::instructions_test!( -mod float_mut for data_insertatlist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Float); - list - }, - }; -} + mod test_float for data_insertatlist(t1, t2) { + fields = super::test::make_fields(IrType::Float, flags()); + } ); + crate::instructions_test!( -mod string_mut for data_insertatlist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![crate::sb3::VarVal::String("hi".into())], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::String); - list - }, - }; -} + mod test_string for data_insertatlist(t1, t2) { + fields = super::test::make_fields(IrType::String, flags()); + } ); + crate::instructions_test!( -mod any_mut for data_insertatlist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Any); - list - }, - }; -} + mod any_mut for data_insertatlist(t1, t2) { + fields = super::test::make_fields(IrType::Any, flags()); + } ); diff --git a/src/instructions/data/lengthoflist.rs b/src/instructions/data/lengthoflist.rs index 4e9ad045..53ff4688 100644 --- a/src/instructions/data/lengthoflist.rs +++ b/src/instructions/data/lengthoflist.rs @@ -62,33 +62,34 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test!( -mod _mut for data_lengthoflist { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![crate::sb3::VarVal::Float(3.0)], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Any); - list - }, - }; +#[cfg(test)] +mod test { + pub use super::super::listcontents::test_utils::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(true, flags_with_integers()); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(mutable: bool, flags: WasmFlags) -> Fields { + Fields { + list: make_list(mutable, IrType::Any, flags), + } + } } + +crate::instructions_test!( + mod test_mut for data_lengthoflist { + fields = super::test::make_fields(true, flags()); + } ); crate::instructions_test!( -mod _static for data_lengthoflist { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::Any); - list - } - }; -} + mod test_static for data_lengthoflist { + fields = super::test::make_fields(false, flags()); + } ); diff --git a/src/instructions/data/listcontents.rs b/src/instructions/data/listcontents.rs index 2da382fc..b039e4a8 100644 --- a/src/instructions/data/listcontents.rs +++ b/src/instructions/data/listcontents.rs @@ -282,157 +282,105 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test!( -mod int_mut for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Int); - list - }, - }; - flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +#[cfg(test)] +pub mod test_utils { + use super::*; + use crate::wasm::{WasmFlags, flags::{Switch, unit_test_wasm_features}}; + + pub fn make_list(mutable: bool, ty: IrType, flags: WasmFlags) -> RcList { + let list = crate::ir::RcList::new(vec![], &flags).unwrap(); + *list.length_mutable().borrow_mut() = mutable; + list.add_type(ty); + list + } + + pub fn flags_with_integers() -> WasmFlags { + let mut flags = WasmFlags::new(unit_test_wasm_features()); + flags.integers = Switch::On; + flags + } +} + +#[cfg(test)] +mod test { + use super::*; + pub use test_utils::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(true, IrType::Any, super::test::flags_with_integers()); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(mutable: bool, ty: IrType, flags: WasmFlags) -> Fields { + Fields { + list: make_list(mutable, ty, flags), + } + } } + +crate::instructions_test!( + mod test_int_mut for data_listcontents { + fields = super::test::make_fields(true, IrType::Int, flags()); + flags = super::test::flags_with_integers(); + } ); + crate::instructions_test!( -mod bool_mut for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Boolean); - list - }, - }; - flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; -} + mod test_bool_mut for data_listcontents { + fields = super::test::make_fields(true, IrType::Boolean, flags()); + flags = super::test::flags_with_integers(); + } ); + crate::instructions_test!( -mod float_mut for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Float); - list - }, - }; -} + mod test_float_mut for data_listcontents { + fields = super::test::make_fields(true, IrType::Float, flags()); + } ); + crate::instructions_test!( -mod string_mut for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![crate::sb3::VarVal::String("hi".into())], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::String); - list - }, - }; -} + mod test_string_mut for data_listcontents { + fields = super::test::make_fields(true, IrType::String, flags()); + } ); + crate::instructions_test!( -mod any_mut for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Any); - list - }, - }; -} + mod test_any_mut for data_listcontents { + fields = super::test::make_fields(true, IrType::Any, flags()); + } ); crate::instructions_test!( -mod int_static for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::Int); - list - } - }; - flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; -} + mod test_int_static for data_listcontents { + fields = super::test::make_fields(false, IrType::Int, flags()); + flags = super::test::flags_with_integers(); + } ); crate::instructions_test!( -mod bool_static for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::Boolean); - list - } - }; - flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; -} + mod test_bool_static for data_listcontents { + fields = super::test::make_fields(false, IrType::Boolean, flags()); + flags = super::test::flags_with_integers(); + } ); crate::instructions_test!( -mod float_static for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::Float); - list - } - }; -} + mod test_float_static for data_listcontents { + fields = super::test::make_fields(false, IrType::Float, flags()); + } ); crate::instructions_test!( -mod string_static for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::String); - list - } - }; -} + mod test_string_static for data_listcontents { + fields = super::test::make_fields(false, IrType::String, flags()); + } ); crate::instructions_test!( -mod any_static for data_listcontents { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::Any); - list - } - }; -} + mod test_any_static for data_listcontents { + fields = super::test::make_fields(false, IrType::Any, flags()); + } ); diff --git a/src/instructions/data/replaceitemoflist.rs b/src/instructions/data/replaceitemoflist.rs index f549fee0..649613a4 100644 --- a/src/instructions/data/replaceitemoflist.rs +++ b/src/instructions/data/replaceitemoflist.rs @@ -94,125 +94,72 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test!( -mod int_mut for data_replaceitemoflist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Int); - list - }, - }; - flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; +#[cfg(test)] +mod test { + pub use super::super::listcontents::test_utils::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(true, IrType::Any, flags_with_integers()); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(mutable: bool, ty: IrType, flags: WasmFlags) -> Fields { + Fields { + list: make_list(mutable, ty, flags), + } + } } -); + crate::instructions_test!( -mod float_mut for data_replaceitemoflist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Float); - list - }, - }; -} + mod test_int_mut for data_replaceitemoflist(t1, t2) { + fields = super::test::make_fields(true, IrType::Int, flags()); + flags = super::test::flags_with_integers(); + } ); + crate::instructions_test!( -mod string_mut for data_replaceitemoflist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![crate::sb3::VarVal::String("hi".into())], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::String); - list - }, - }; -} + mod test_float_mut for data_replaceitemoflist(t1, t2) { + fields = super::test::make_fields(true, IrType::Float, flags()); + } ); + crate::instructions_test!( -mod any_mut for data_replaceitemoflist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - *list.length_mutable().borrow_mut() = true; - list.add_type(IrType::Any); - list - }, - }; -} + mod test_string_mut for data_replaceitemoflist(t1, t2) { + fields = super::test::make_fields(true, IrType::String, flags()); + } ); crate::instructions_test!( -mod int_static for data_replaceitemoflist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::Int); - list - } - }; - flags = { let mut flags = WasmFlags::new(unit_test_wasm_features()); flags.integers = Switch::On; flags }; -} + mod test_any_mut for data_replaceitemoflist(t1, t2) { + fields = super::test::make_fields(true, IrType::Any, flags()); + } ); crate::instructions_test!( -mod float_static for data_replaceitemoflist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::Float); - list - } - }; -} + mod test_int_static for data_replaceitemoflist(t1, t2) { + fields = super::test::make_fields(false, IrType::Int, flags()); + flags = super::test::flags_with_integers(); + } ); crate::instructions_test!( -mod string_static for data_replaceitemoflist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::String); - list - } - }; -} + mod test_float_static for data_replaceitemoflist(t1, t2) { + fields = super::test::make_fields(false, IrType::Float, flags()); + } ); crate::instructions_test!( -mod any_static for data_replaceitemoflist(t1, t2) { - fields = super::Fields { - list: { - let list = crate::ir::RcList::new( - vec![], - &flags() - ).unwrap(); - list.add_type(IrType::Any); - list - } - }; -} + mod test_string_static for data_replaceitemoflist(t1, t2) { + fields = super::test::make_fields(false, IrType::String, flags()); + } ); + +crate::instructions_test!( + mod test_any_static for data_replaceitemoflist(t1, t2) { + fields = super::test::make_fields(false, IrType::Any, flags()); + } +); \ No newline at end of file diff --git a/src/instructions/data/setvariableto.rs b/src/instructions/data/setvariableto.rs index dc655374..10a4fa3d 100644 --- a/src/instructions/data/setvariableto.rs +++ b/src/instructions/data/setvariableto.rs @@ -136,122 +136,78 @@ pub fn const_fold( Ok(NotFoldable) } -crate::instructions_test!( -mod any_global for data_setvariableto(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Any, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap()), - local_write: RefCell::new(false), first_write: RefCell::new(false) - }; +#[cfg(test)] +mod test { + use super::super::variable::test_util::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + use crate::wasm::flags::unit_test_wasm_features; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields( + IrType::Any, + crate::sb3::VarVal::Float(0.0), + true, + WasmFlags::new(unit_test_wasm_features()), + ); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(ty: IrType, initial: VarVal, local_write: bool, flags: WasmFlags) -> Fields { + Fields { + var: make_var(ty, initial, None, flags), + local_write: RefCell::new(local_write), + first_write: RefCell::new(false), + } + } } + +crate::instructions_test!( + mod test_any_global for data_setvariableto(t) { + fields = super::test::make_fields(IrType::Any, crate::sb3::VarVal::Float(0.0), false, flags()); + } ); crate::instructions_test!( -mod float_global for data_setvariableto(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Float, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap()), - local_write: RefCell::new(false), first_write: RefCell::new(false) - }; -} + mod test_float_global for data_setvariableto(t) { + fields = super::test::make_fields(IrType::Float, crate::sb3::VarVal::Float(0.0), false, flags()); + } ); crate::instructions_test!( -mod string_global for data_setvariableto(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::String, - &crate::sb3::VarVal::String("".into()), - None, - &flags() - ).unwrap()), - local_write: RefCell::new(false), first_write: RefCell::new(false) - }; -} + mod test_string_global for data_setvariableto(t) { + fields = super::test::make_fields(IrType::String, crate::sb3::VarVal::String("".into()), false, flags()); + } ); crate::instructions_test!( -mod int_global for data_setvariableto(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Int, - &crate::sb3::VarVal::Int(1), - None, - &flags() - ).unwrap()), - local_write: RefCell::new(false), first_write: RefCell::new(false) - }; -} + mod test_int_global for data_setvariableto(t) { + fields = super::test::make_fields(IrType::Int, crate::sb3::VarVal::Int(0), false, flags()); + } ); crate::instructions_test!( -mod any_local for data_setvariableto(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Any, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap()), - local_write: RefCell::new(true), first_write: RefCell::new(false) - }; -} + mod test_any_local for data_setvariableto(t) { + fields = super::test::make_fields(IrType::Any, crate::sb3::VarVal::Float(0.0), true, flags()); + } ); crate::instructions_test!( -mod float_local for data_setvariableto(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Float, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap()), - local_write: RefCell::new(true), first_write: RefCell::new(false) - }; -} + mod test_float_local for data_setvariableto(t) { + fields = super::test::make_fields(IrType::Float, crate::sb3::VarVal::Float(0.0), true, flags()); + } ); crate::instructions_test!( -mod string_local for data_setvariableto(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::String, - &crate::sb3::VarVal::String("".into()), - None, - &flags() - ).unwrap()), - local_write: RefCell::new(true), first_write: RefCell::new(false) - }; -} + mod test_string_local for data_setvariableto(t) { + fields = super::test::make_fields(IrType::String, crate::sb3::VarVal::String("".into()), true, flags()); + } ); crate::instructions_test!( -mod int_local for data_setvariableto(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Int, - &crate::sb3::VarVal::Int(1), - None, - &flags() - ).unwrap()), - local_write: RefCell::new(true), first_write: RefCell::new(false) - }; -} + mod test_int_local for data_setvariableto(t) { + fields = super::test::make_fields(IrType::Int, crate::sb3::VarVal::Int(0), true, flags()); + } ); diff --git a/src/instructions/data/teevariable.rs b/src/instructions/data/teevariable.rs index 19f8357f..b969cc45 100644 --- a/src/instructions/data/teevariable.rs +++ b/src/instructions/data/teevariable.rs @@ -135,128 +135,77 @@ pub fn const_fold( Ok(NotFoldable) } -crate::instructions_test!( -mod any_global for data_teevariable(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Any, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap()) - , - local_read_write: RefCell::new(false), - }; +#[cfg(test)] +mod test { + use super::super::variable::test_util::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + use crate::wasm::flags::unit_test_wasm_features; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields( + IrType::Any, + crate::sb3::VarVal::Float(0.0), + true, + WasmFlags::new(unit_test_wasm_features()), + ); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(ty: IrType, initial: VarVal, local_read_write: bool, flags: WasmFlags) -> Fields { + Fields { + var: make_var(ty, initial, None, flags), + local_read_write: RefCell::new(local_read_write), + } + } } + +crate::instructions_test!( + mod test_any_global for data_teevariable(t) { + fields = super::test::make_fields(IrType::Any, crate::sb3::VarVal::Float(0.0), false, flags()); + } ); crate::instructions_test!( -mod float_global for data_teevariable(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Float, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap()) - , - local_read_write: RefCell::new(false), - }; -} + mod test_float_global for data_teevariable(t) { + fields = super::test::make_fields(IrType::Float, crate::sb3::VarVal::Float(0.0), false, flags()); + } ); crate::instructions_test!( -mod string_global for data_teevariable(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::String, - &crate::sb3::VarVal::String("".into()), - None, - &flags() - ).unwrap()) - , - local_read_write: RefCell::new(false), - }; -} + mod test_string_global for data_teevariable(t) { + fields = super::test::make_fields(IrType::String, crate::sb3::VarVal::String("".into()), false, flags()); + } ); crate::instructions_test!( -mod int_global for data_teevariable(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Int, - &crate::sb3::VarVal::Int(1), - None, - &flags() - ).unwrap()) - , - local_read_write: RefCell::new(false), - }; -} + mod test_int_global for data_teevariable(t) { + fields = super::test::make_fields(IrType::Int, crate::sb3::VarVal::Int(0), false, flags()); + } ); crate::instructions_test!( -mod any_local for data_teevariable(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Any, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap() - ), - local_read_write: RefCell::new(true), - }; -} + mod test_any_local for data_teevariable(t) { + fields = super::test::make_fields(IrType::Any, crate::sb3::VarVal::Float(0.0), true, flags()); + } ); crate::instructions_test!( -mod float_local for data_teevariable(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Float, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap() - ), - local_read_write: RefCell::new(true), - }; -} + mod test_float_local for data_teevariable(t) { + fields = super::test::make_fields(IrType::Float, crate::sb3::VarVal::Float(0.0), true, flags()); + } ); crate::instructions_test!( -mod string_local for data_teevariable(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::String, - &crate::sb3::VarVal::String("".into()), - None, - &flags() - ).unwrap()), - local_read_write: RefCell::new(true), - }; -} + mod test_string_local for data_teevariable(t) { + fields = super::test::make_fields(IrType::String, crate::sb3::VarVal::String("".into()), true, flags()); + } ); crate::instructions_test!( -mod int_local for data_teevariable(t) { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Int, - &crate::sb3::VarVal::Int(1), - None, - &flags() - ).unwrap()), - local_read_write: RefCell::new(true), - }; -} + mod test_int_local for data_teevariable(t) { + fields = super::test::make_fields(IrType::Int, crate::sb3::VarVal::Int(0), true, flags()); + } ); diff --git a/src/instructions/data/variable.rs b/src/instructions/data/variable.rs index b3e17263..486e991b 100644 --- a/src/instructions/data/variable.rs +++ b/src/instructions/data/variable.rs @@ -76,141 +76,94 @@ pub fn const_fold( } } -crate::instructions_test!( -mod any_global for data_variable { - fields = super::Fields { - var: RefCell::new - ( - crate::ir::RcVar::new( - IrType::Any, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap() - ) - , - local_read: RefCell::new(false) - }; +#[cfg(test)] +pub mod test_util { + use super::*; + use crate::ir::{IrMonitor, RcVar}; + use crate::wasm::WasmFlags; + + pub fn make_var( + ty: IrType, + initial: crate::sb3::VarVal, + monitor: Option, + flags: WasmFlags, + ) -> RefCell { + RefCell::new(crate::ir::RcVar::new(ty, &initial, monitor, &flags).unwrap()) + } +} + +#[cfg(test)] +mod test { + use test_util::*; + + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + use crate::wasm::flags::unit_test_wasm_features; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields( + IrType::Any, + crate::sb3::VarVal::Float(0.0), + true, + WasmFlags::new(unit_test_wasm_features()), + ); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(ty: IrType, initial: VarVal, local_read: bool, flags: WasmFlags) -> Fields { + Fields { + var: make_var(ty, initial, None, flags), + local_read: RefCell::new(local_read), + } + } } + +crate::instructions_test!( + mod test_any_global for data_variable { + fields = super::test::make_fields(IrType::Any, crate::sb3::VarVal::Float(0.0), false, flags()); + } ); crate::instructions_test!( -mod float_global for data_variable { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Float, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap() - ), - local_read: RefCell::new(false) - }; -} + mod test_float_global for data_variable { + fields = super::test::make_fields(IrType::Float, crate::sb3::VarVal::Float(0.0), false, flags()); + } ); crate::instructions_test!( -mod string_global for data_variable { - fields = super::Fields { - var: RefCell::new - ( - crate::ir::RcVar::new( - IrType::String, - &crate::sb3::VarVal::String("".into()), - None, - &flags() - ).unwrap() - ) - , - local_read: RefCell::new(false) - }; -} + mod test_string_global for data_variable { + fields = super::test::make_fields(IrType::String, crate::sb3::VarVal::String("".into()), false, flags()); + } ); crate::instructions_test!( -mod int_global for data_variable { - fields = super::Fields { - var: RefCell::new - ( - crate::ir::RcVar::new( - IrType::Int, - &crate::sb3::VarVal::Int(1), - None, - &flags() - ).unwrap() - ) - , - local_read: RefCell::new(false) - }; -} + mod test_int_global for data_variable { + fields = super::test::make_fields(IrType::Int, crate::sb3::VarVal::Int(0), false, flags()); + } ); crate::instructions_test!( -mod any_local for data_variable { - fields = super::Fields { - var: RefCell::new - ( - crate::ir::RcVar::new( - IrType::Any, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap() - ) - , - local_read: RefCell::new(true) - }; -} + mod test_any_local for data_variable { + fields = super::test::make_fields(IrType::Any, crate::sb3::VarVal::Float(0.0), true, flags()); + } ); crate::instructions_test!( -mod float_local for data_variable { - fields = super::Fields { - var: RefCell::new - ( - crate::ir::RcVar::new( - IrType::Float, - &crate::sb3::VarVal::Float(0.0), - None, - &flags() - ).unwrap() - ) - , - local_read: RefCell::new(true) - }; -} + mod test_float_local for data_variable { + fields = super::test::make_fields(IrType::Float, crate::sb3::VarVal::Float(0.0), true, flags()); + } ); crate::instructions_test!( -mod string_local for data_variable { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::String, - &crate::sb3::VarVal::String("".into()), - None, - &flags() - ).unwrap() - - ), - local_read: RefCell::new(true) - }; -} + mod test_string_local for data_variable { + fields = super::test::make_fields(IrType::String, crate::sb3::VarVal::String("".into()), true, flags()); + } ); crate::instructions_test!( -mod int_local for data_variable { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Int, - &crate::sb3::VarVal::Int(1), - None, - &flags() - ).unwrap() - ), - local_read: RefCell::new(true) - }; -} + mod test_int_local for data_variable { + fields = super::test::make_fields(IrType::Int, crate::sb3::VarVal::Int(0), true, flags()); + } ); diff --git a/src/instructions/data/visvariable.rs b/src/instructions/data/visvariable.rs index bd83c7dd..014a7280 100644 --- a/src/instructions/data/visvariable.rs +++ b/src/instructions/data/visvariable.rs @@ -69,21 +69,38 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test!( -mod test for data_visvariable { - fields = super::Fields { - var: RefCell::new( - crate::ir::RcVar::new( - IrType::Any, - &crate::sb3::VarVal::Float(0.0), - Some(crate::ir::IrMonitor { - id: "".into(), - is_ever_visible: RefCell::new(true,) - }), - &flags() - ).unwrap()) - , - visible: true - }; +#[cfg(test)] +mod test { + use super::super::variable::test_util::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::WasmFlags; + use crate::wasm::flags::unit_test_wasm_features; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(WasmFlags::new(unit_test_wasm_features())); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(flags: WasmFlags) -> Fields { + Fields { + var: make_var( + IrType::Any, + crate::sb3::VarVal::Float(0.0), + Some(crate::ir::IrMonitor { + id: "".into(), + is_ever_visible: RefCell::new(true), + }), + flags, + ), + visible: true, + } + } } + +crate::instructions_test!( + mod test2 for data_visvariable { + fields = super::test::make_fields(flags()); + } ); diff --git a/src/instructions/event/broadcast.rs b/src/instructions/event/broadcast.rs index fba38342..0dc6357a 100644 --- a/src/instructions/event/broadcast.rs +++ b/src/instructions/event/broadcast.rs @@ -1,5 +1,5 @@ use super::super::prelude::*; -use crate::wasm::StepFunc; +use crate::{instructions_test, wasm::StepFunc}; #[derive(Clone, Debug)] pub struct Fields(pub Box); @@ -9,7 +9,7 @@ impl fmt::Display for Fields { write!( f, r#"{{ - "broadcast": "{:}", + "broadcast": "{:}" }}"#, self.0 ) @@ -43,3 +43,25 @@ pub const fn const_fold( ) -> HQResult { Ok(NotFoldable) } + +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields() -> Fields { + Fields("".into()) + } +} + +instructions_test!( + mod test2 for event_broadcast { + fields = super::test::make_fields(); + } +); diff --git a/src/instructions/event/broadcast_and_wait.rs b/src/instructions/event/broadcast_and_wait.rs index f222da93..3923b3fc 100644 --- a/src/instructions/event/broadcast_and_wait.rs +++ b/src/instructions/event/broadcast_and_wait.rs @@ -1,6 +1,7 @@ use wasm_encoder::{HeapType, StorageType}; use super::super::prelude::*; +use crate::instructions_test; use crate::ir::StepIndex; use crate::wasm::StepFunc; @@ -67,3 +68,45 @@ pub const fn const_fold( ) -> HQResult { Ok(NotFoldable) } + +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + use crate::wasm::registries::TypeRegistry; + use crate::wasm::{StepTarget, WasmFlags, WasmProject}; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields() -> Fields { + Fields { + broadcast: "".into(), + poll_step: StepIndex(0), + next_step: StepIndex(0), + } + } + + pub fn setup_project(wasm_proj: &WasmProject, flags: WasmFlags) { + let step_func = StepFunc::new_with_types( + Box::from([ValType::I32, TypeRegistry::STRUCT_REF]), + Box::from([]), + wasm_proj.registries(), + flags, + StepTarget::Sprite(0), + 0, + Rc::new(vec![]), + ); + wasm_proj.steps().borrow_mut().push(step_func); + } +} + +instructions_test!( + mod test2 for event_broadcast_and_wait { + fields = super::test::make_fields(); + setup = super::test::setup_project; + } +); diff --git a/src/instructions/hq/boolean.rs b/src/instructions/hq/boolean.rs index ae13b134..584419eb 100644 --- a/src/instructions/hq/boolean.rs +++ b/src/instructions/hq/boolean.rs @@ -52,13 +52,25 @@ pub fn const_fold( )]))) } -crate::instructions_test! ( -mod tests_false for hq_boolean { - fields = super::Fields(false); +#[cfg(test)] +mod tests { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + assert_valid_json(format!("{}", Fields(true))); + } } + +crate::instructions_test! ( + mod tests_false for hq_boolean { + fields = super::Fields(false); + } ); + crate::instructions_test! ( -mod tests_true for hq_boolean { - fields = super::Fields(true); -} + mod tests_true for hq_boolean { + fields = super::Fields(true); + } ); diff --git a/src/instructions/hq/box.rs b/src/instructions/hq/box.rs index 8cde63fc..21d22a2b 100644 --- a/src/instructions/hq/box.rs +++ b/src/instructions/hq/box.rs @@ -53,8 +53,21 @@ pub fn const_fold( }) } -crate::instructions_test! ( -mod tests for hq_box(t) { - fields = super::Fields { output_ty: IrType::Any }; +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + assert_valid_json(format!("{}", Fields { + output_ty: IrType::Any, + })); + } } + +crate::instructions_test! ( + mod tests for hq_box(t) { + fields = super::Fields { output_ty: IrType::Any }; + } ); diff --git a/src/instructions/hq/cast.rs b/src/instructions/hq/cast.rs index 7188a1cc..ce84a4bc 100644 --- a/src/instructions/hq/cast.rs +++ b/src/instructions/hq/cast.rs @@ -346,23 +346,37 @@ pub fn const_fold( }) } -crate::instructions_test! ( -mod float for hq_cast(t) { - fields = super::Fields(IrType::Float); +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + assert_valid_json(format!("{}", Fields(IrType::Float))); + } } + +crate::instructions_test! ( + mod test_float for hq_cast(t) { + fields = super::Fields(IrType::Float); + } ); + crate::instructions_test! ( -mod string for hq_cast(t) { - fields = super::Fields(IrType::String); -} + mod test_string for hq_cast(t) { + fields = super::Fields(IrType::String); + } ); + crate::instructions_test! ( -mod int for hq_cast(t) { - fields = super::Fields(IrType::Int); -} + mod test_int for hq_cast(t) { + fields = super::Fields(IrType::Int); + } ); + crate::instructions_test! ( -mod boolean for hq_cast(t) { - fields = super::Fields(IrType::Boolean); -} + mod test_boolean for hq_cast(t) { + fields = super::Fields(IrType::Boolean); + } ); diff --git a/src/instructions/hq/color_rgb.rs b/src/instructions/hq/color_rgb.rs index 6be6915f..89bbebfa 100644 --- a/src/instructions/hq/color_rgb.rs +++ b/src/instructions/hq/color_rgb.rs @@ -54,8 +54,19 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! ( -mod tests for hq_color_rgb { - fields = super::Fields { r: 134, g: 56, b: 109 }; +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + assert_valid_json(format!("{}", Fields { r: 1, g: 2, b: 3 })); + } } + +crate::instructions_test! ( + mod tests for hq_color_rgb { + fields = super::Fields { r: 134, g: 56, b: 109 }; + } ); diff --git a/src/instructions/hq/drop.rs b/src/instructions/hq/drop.rs index 3917b146..88f44195 100644 --- a/src/instructions/hq/drop.rs +++ b/src/instructions/hq/drop.rs @@ -19,6 +19,5 @@ pub fn const_fold(_inputs: &[ConstFoldItem], _state: &mut ConstFoldState) -> HQR } crate::instructions_test! ( -mod tests for hq_drop(t) { -} + mod tests for hq_drop(t) {} ); diff --git a/src/instructions/hq/dup.rs b/src/instructions/hq/dup.rs index e9508bdc..7f3458c4 100644 --- a/src/instructions/hq/dup.rs +++ b/src/instructions/hq/dup.rs @@ -25,6 +25,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for hq_dup(t) { -} + mod tests for hq_dup(t) {} ); diff --git a/src/instructions/hq/float.rs b/src/instructions/hq/float.rs index 7998bccc..e35b3508 100644 --- a/src/instructions/hq/float.rs +++ b/src/instructions/hq/float.rs @@ -58,8 +58,19 @@ pub fn const_fold( )]))) } -crate::instructions_test! ( -mod tests for hq_float { - fields = super::Fields(0.0); +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + assert_valid_json(format!("{}", Fields(0.0))); + } } + +crate::instructions_test! ( + mod tests for hq_float { + fields = super::Fields(0.0); + } ); diff --git a/src/instructions/hq/integer.rs b/src/instructions/hq/integer.rs index 8bf34296..88534486 100644 --- a/src/instructions/hq/integer.rs +++ b/src/instructions/hq/integer.rs @@ -53,8 +53,19 @@ pub fn const_fold( )]))) } -crate::instructions_test! ( -mod tests for hq_integer { - fields = super::Fields(0); +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + assert_valid_json(format!("{}", Fields(0))); + } } + +crate::instructions_test! ( + mod tests for hq_integer { + fields = super::Fields(0); + } ); diff --git a/src/instructions/hq/swap.rs b/src/instructions/hq/swap.rs index 1d4ed52a..8eb951ca 100644 --- a/src/instructions/hq/swap.rs +++ b/src/instructions/hq/swap.rs @@ -33,6 +33,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for hq_swap(t1,t2) { -} + mod tests for hq_swap(t1, t2) {} ); diff --git a/src/instructions/hq/text.rs b/src/instructions/hq/text.rs index 83919939..6d03b6aa 100644 --- a/src/instructions/hq/text.rs +++ b/src/instructions/hq/text.rs @@ -60,8 +60,19 @@ pub fn const_fold( )]))) } -crate::instructions_test! ( -mod tests for hq_text { - fields = super::Fields("hello, world!".into()); +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + assert_valid_json(format!("{}", Fields("".into()))); + } } + +crate::instructions_test! ( + mod tests for hq_text { + fields = super::Fields("hello, world!".into()); + } ); diff --git a/src/instructions/hq/yield.rs b/src/instructions/hq/yield.rs index 49426ac3..6f04d8de 100644 --- a/src/instructions/hq/yield.rs +++ b/src/instructions/hq/yield.rs @@ -1,6 +1,7 @@ use wasm_encoder::{BlockType, ConstExpr, HeapType}; use super::super::prelude::*; +use crate::instructions_test; use crate::ir::{Step, StepIndex}; use crate::wasm::{GlobalExportable, GlobalMutable, StepFunc, ThreadsTable}; @@ -193,39 +194,67 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! ( -mod none for hq_yield { - fields = super::Fields { mode: super::YieldMode::None }; +#[cfg(test)] +mod test { + use super::super::super::tests::*; + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + let target = make_target(); + for mode in [ + YieldMode::None, + YieldMode::Return, + make_schedule(), + YieldMode::Inline(Rc::new(RefCell::new(Step::new_empty( + Weak::new(), + false, + target, + )))), + ] { + assert_valid_json(format!("{}", Fields { mode })); + } + } + + pub fn make_schedule() -> YieldMode { + YieldMode::Schedule(StepIndex(0)) + } + + pub fn make_inline() -> YieldMode { + let target = make_target(); + YieldMode::Inline(Rc::new(RefCell::new(Step::new_empty( + Weak::new(), + false, + target, + )))) + } } + +instructions_test! ( + mod test_none for hq_yield { + fields = super::Fields { mode: super::YieldMode::None }; + } ); -crate::instructions_test! ( -mod ret for hq_yield { - fields = super::Fields { mode: super::YieldMode::Return }; -} +instructions_test! ( + mod test_return for hq_yield { + fields = super::Fields { mode: super::YieldMode::Return }; + } +); + +instructions_test! ( + mod test_schedule for hq_yield { + fields = super::Fields { + mode: super::test::make_schedule() + }; + } ); -// crate::instructions_test! ( -// mod schedule for hq_yield { -// fields = super::Fields { -// mode: super::YieldMode::Schedule( -// crate::rc::Rc::downgrade(&crate::ir::Step::new_empty( -// &crate::rc::Rc::downgrade(&Rc::new(crate::ir::IrProject::new(BTreeMap::default(), BTreeMap::default(), Box::from([])))), -// true, -// Rc::new( -// crate::ir::Target::new( -// false, -// BTreeMap::default(), -// BTreeMap::default(), -// crate::rc::Rc::downgrade(&Rc::new(crate::ir::IrProject::new(BTreeMap::default(), BTreeMap::default(), Box::from([])))), -// RefCell::default(), -// 0, -// Box::from([]) -// ) -// ) -// ).unwrap()) -// ) -// } -//; -// } -// ); +instructions_test!( + mod test_inline for hq_yield { + fields = super::Fields { + mode: super::test::make_inline() + }; + } +); diff --git a/src/instructions/procedures/call_nonwarp.rs b/src/instructions/procedures/call_nonwarp.rs index 4d553a39..54347734 100644 --- a/src/instructions/procedures/call_nonwarp.rs +++ b/src/instructions/procedures/call_nonwarp.rs @@ -137,12 +137,14 @@ pub const fn const_fold( #[cfg(test)] mod test { + use super::super::super::tests::*; use super::*; + use crate::ir::{PartialStep, StepIndex}; #[test] fn fields_display_is_valid_json() { let fields = make_fields(2); - assert!(serde_json::from_str::(format!("{fields}").as_str()).is_ok()); + assert_valid_json(format!("{fields}")); } pub fn test_project_setup(wasm_proj: &WasmProject, flags: crate::wasm::WasmFlags) { @@ -164,17 +166,7 @@ mod test { pub fn make_fields(num_inputs: usize) -> super::Fields { super::Fields { proc: { - use crate::ir::{PartialStep, StepIndex, Target}; - - let target = Rc::new(Target::new( - false, - BTreeMap::default(), - BTreeMap::default(), - Weak::new(), - RefCell::new(BTreeMap::default()), - 0, - Box::new([]), - )); + let target = make_target(); let proc = Rc::new(super::Proc::new( format!("foo {}", core::iter::repeat_n("%s", num_inputs).join(" ")).into(), RefCell::new(None), diff --git a/src/instructions/procedures/call_warp.rs b/src/instructions/procedures/call_warp.rs index 40025399..d5579f8f 100644 --- a/src/instructions/procedures/call_warp.rs +++ b/src/instructions/procedures/call_warp.rs @@ -109,12 +109,14 @@ pub const fn const_fold( #[cfg(test)] mod test { + use super::super::super::tests::*; use super::*; + use crate::ir::{PartialStep, StepIndex}; #[test] fn fields_display_is_valid_json() { let fields = make_fields(&[IrType::Any]); - assert!(serde_json::from_str::(format!("{fields}").as_str()).is_ok()); + assert_valid_json(format!("{fields}")); } pub fn test_project_setup( @@ -144,17 +146,7 @@ mod test { pub fn make_fields(inputs: &[IrType]) -> super::Fields { super::Fields { proc: { - use crate::ir::{PartialStep, StepIndex, Target}; - - let target = Rc::new(Target::new( - false, - BTreeMap::default(), - BTreeMap::default(), - Weak::new(), - RefCell::new(BTreeMap::default()), - 0, - Box::new([]), - )); + let target = make_target(); let proc = Rc::new(super::Proc::new( format!("foo {}", core::iter::repeat_n("%s", inputs.len()).join(" ")).into(), RefCell::new(None), diff --git a/src/instructions/tests.rs b/src/instructions/tests.rs index d111d49b..0365d312 100644 --- a/src/instructions/tests.rs +++ b/src/instructions/tests.rs @@ -104,7 +104,12 @@ macro_rules! instructions_test { }; let registries = proj.registries(); let types: &[IrType] = &[$($($type_arg,)*)?]; - let params = [ValType::I32, $crate::wasm::registries::TypeRegistry::STRUCT_REF].into_iter().chain([$($($type_arg,)*)?].into_iter().map(WasmProject::ir_type_to_wasm)).collect::>(); + let params = types + .into_iter() + .copied() + .map(WasmProject::ir_type_to_wasm) + .chain([ValType::I32, $crate::wasm::registries::TypeRegistry::STRUCT_REF]) + .collect::>(); let result = match output_type { ReturnType::Singleton(output) => vec![WasmProject::ir_type_to_wasm(output)], ReturnType::MultiValue(outputs) => outputs.iter().copied().map(WasmProject::ir_type_to_wasm).collect(), @@ -116,7 +121,7 @@ macro_rules! instructions_test { continue; }; for (i, _) in types.iter().enumerate() { - step_func.add_instructions([$crate::wasm::InternalInstruction::Immediate(wasm_encoder::Instruction::LocalGet((i + 2).try_into().unwrap()))])? + step_func.add_instructions([$crate::wasm::InternalInstruction::Immediate(wasm_encoder::Instruction::LocalGet(i.try_into().unwrap()))])? } step_func.add_instructions(wasm)?; @@ -149,13 +154,11 @@ macro_rules! instructions_test { println!("{output_type:?}"); let registries = proj.registries(); let types: &[IrType] = &[$($($type_arg,)*)?]; - let params = [ValType::I32, $crate::wasm::registries::TypeRegistry::STRUCT_REF] + let params = types .into_iter() - .chain( - [$($($type_arg,)*)?] - .into_iter() - .map(WasmProject::ir_type_to_wasm) - ) + .copied() + .map(WasmProject::ir_type_to_wasm) + .chain([ValType::I32, $crate::wasm::registries::TypeRegistry::STRUCT_REF]) .collect::>(); let result = vec![]; let step_func = StepFunc::new_with_types( @@ -186,7 +189,7 @@ macro_rules! instructions_test { step_func.add_instructions( [$crate::wasm::InternalInstruction::Immediate( wasm_encoder::Instruction::LocalGet( - (i + 2).try_into().unwrap() + i.try_into().unwrap() ) )] )? @@ -305,3 +308,46 @@ macro_rules! instructions_test { } } } + + +#[cfg(test)] +pub use test_util::*; + +#[cfg(test)] +mod test_util { + use crate::ir::{Step, StepContext, Target}; + use crate::prelude::*; + + pub fn make_target() -> Rc { + Rc::new(Target::new( + false, + BTreeMap::default(), + BTreeMap::default(), + Weak::new(), + RefCell::default(), + 0, + Box::default(), + )) + } + + pub fn make_context(target: &Rc) -> StepContext { + StepContext { + target: Rc::clone(target), + warp: false, + proc_context: None, + debug: false, + } + } + + pub fn make_step(target: &Rc) -> Rc> { + Rc::new(RefCell::new(Step::new_empty( + Weak::new(), + false, + Rc::clone(target), + ))) + } + + pub fn assert_valid_json>(test: S) { + assert!(serde_json::from_str::(&test).is_ok()); + } +} From 95cf090c14f3ff40f6b7c3d5f201daad3da898fb Mon Sep 17 00:00:00 2001 From: pufferfish101007 <50246616+pufferfish101007@users.noreply.github.com> Date: Mon, 10 Aug 2026 16:49:59 +0100 Subject: [PATCH 7/9] more instructions tests [part 2] --- src/instructions/looks/backdropnumber.rs | 3 +- src/instructions/looks/costumename.rs | 7 ++- src/instructions/looks/costumenumber.rs | 3 +- src/instructions/looks/say.rs | 29 ++++++++++--- src/instructions/looks/setsizeto.rs | 3 +- src/instructions/looks/setvisible.rs | 3 +- src/instructions/looks/size.rs | 3 +- src/instructions/looks/switchbackdropto.rs | 3 +- src/instructions/looks/switchcostumeto.rs | 3 +- src/instructions/looks/think.rs | 23 +++++++--- src/instructions/motion/direction.rs | 3 +- src/instructions/motion/gotoxy.rs | 3 +- src/instructions/motion/pointindirection.rs | 3 +- src/instructions/motion/setx.rs | 3 +- src/instructions/motion/sety.rs | 3 +- src/instructions/motion/xposition.rs | 3 +- src/instructions/motion/yposition.rs | 3 +- src/instructions/operator/abs.rs | 3 +- src/instructions/operator/acos.rs | 3 +- src/instructions/operator/add.rs | 3 +- src/instructions/operator/and.rs | 3 +- src/instructions/operator/asin.rs | 3 +- src/instructions/operator/atan.rs | 3 +- src/instructions/operator/ceiling.rs | 3 +- src/instructions/operator/contains.rs | 3 +- src/instructions/operator/cos.rs | 3 +- src/instructions/operator/divide.rs | 3 +- src/instructions/operator/equals.rs | 3 +- src/instructions/operator/exp.rs | 3 +- src/instructions/operator/floor.rs | 3 +- src/instructions/operator/gt.rs | 3 +- src/instructions/operator/join.rs | 3 +- src/instructions/operator/length.rs | 3 +- src/instructions/operator/letter_of.rs | 3 +- src/instructions/operator/ln.rs | 3 +- src/instructions/operator/log.rs | 3 +- src/instructions/operator/lt.rs | 3 +- src/instructions/operator/modulo.rs | 3 +- src/instructions/operator/multiply.rs | 3 +- src/instructions/operator/not.rs | 3 +- src/instructions/operator/or.rs | 3 +- src/instructions/operator/pow10.rs | 3 +- src/instructions/operator/random.rs | 3 +- src/instructions/operator/round.rs | 3 +- src/instructions/operator/sin.rs | 3 +- src/instructions/operator/sqrt.rs | 3 +- src/instructions/operator/subtract.rs | 3 +- src/instructions/operator/tan.rs | 3 +- src/instructions/pen/changecolorparamby.rs | 3 +- src/instructions/pen/clear.rs | 3 +- src/instructions/pen/pendown.rs | 3 +- src/instructions/pen/penup.rs | 3 +- src/instructions/pen/setpencolorparamto.rs | 3 +- src/instructions/pen/setpencolortocolor.rs | 3 +- src/instructions/pen/setpensizeto.rs | 3 +- src/instructions/procedures/argument.rs | 23 ++++++++++ src/instructions/sensing/answer.rs | 3 +- src/instructions/sensing/askandwait.rs | 47 +++++++++++++++++---- src/instructions/sensing/dayssince2000.rs | 3 +- src/instructions/sensing/keypressed.rs | 3 +- src/instructions/sensing/mousedown.rs | 3 +- src/instructions/sensing/mousex.rs | 3 +- src/instructions/sensing/mousey.rs | 3 +- src/instructions/sensing/reset_timer.rs | 3 +- src/instructions/sensing/timer.rs | 3 +- src/instructions/tests.rs | 12 +++--- src/wasm/project.rs | 9 +++- 67 files changed, 178 insertions(+), 152 deletions(-) diff --git a/src/instructions/looks/backdropnumber.rs b/src/instructions/looks/backdropnumber.rs index b2a1e4fc..e5c01fb2 100644 --- a/src/instructions/looks/backdropnumber.rs +++ b/src/instructions/looks/backdropnumber.rs @@ -34,6 +34,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for looks_backdropnumber { -} + mod tests for looks_backdropnumber {} ); diff --git a/src/instructions/looks/costumename.rs b/src/instructions/looks/costumename.rs index 5dd35977..57ecc9a3 100644 --- a/src/instructions/looks/costumename.rs +++ b/src/instructions/looks/costumename.rs @@ -64,7 +64,6 @@ pub const fn const_fold( Ok(NotFoldable) } -// crate::instructions_test! ( -// mod tests for looks_costumename { -// } -// ); +crate::instructions_test! ( + mod tests for looks_costumename {} +); diff --git a/src/instructions/looks/costumenumber.rs b/src/instructions/looks/costumenumber.rs index 0b2b8615..68fe3020 100644 --- a/src/instructions/looks/costumenumber.rs +++ b/src/instructions/looks/costumenumber.rs @@ -40,6 +40,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for looks_costumenumber { -} + mod tests for looks_costumenumber {} ); diff --git a/src/instructions/looks/say.rs b/src/instructions/looks/say.rs index c78575a2..db940437 100644 --- a/src/instructions/looks/say.rs +++ b/src/instructions/looks/say.rs @@ -96,13 +96,30 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! ( -mod tests_debug for looks_say(t) { - fields = super::Fields { debug: true, target_idx: 0 }; +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + assert_valid_json(format!( + "{}", + Fields { + debug: false, + target_idx: 0 + } + )); + } } + +crate::instructions_test! ( + mod tests_debug for looks_say(t) { + fields = super::Fields { debug: true, target_idx: 0 }; + } ); crate::instructions_test! ( -mod tests_non_debug for looks_say(t) { - fields = super::Fields { debug: false, target_idx: 0, }; -} + mod tests_non_debug for looks_say(t) { + fields = super::Fields { debug: false, target_idx: 0, }; + } ); diff --git a/src/instructions/looks/setsizeto.rs b/src/instructions/looks/setsizeto.rs index ce38be37..28488252 100644 --- a/src/instructions/looks/setsizeto.rs +++ b/src/instructions/looks/setsizeto.rs @@ -56,6 +56,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for looks_setsizeto(t) { -} + mod tests for looks_setsizeto(t) {} ); diff --git a/src/instructions/looks/setvisible.rs b/src/instructions/looks/setvisible.rs index 90d612f9..8ddd8a0e 100644 --- a/src/instructions/looks/setvisible.rs +++ b/src/instructions/looks/setvisible.rs @@ -53,6 +53,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for looks_setvisible(t) { -} + mod tests for looks_setvisible(t) {} ); diff --git a/src/instructions/looks/size.rs b/src/instructions/looks/size.rs index f0409d57..4184ce2b 100644 --- a/src/instructions/looks/size.rs +++ b/src/instructions/looks/size.rs @@ -38,6 +38,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for looks_size { -} + mod tests for looks_size {} ); diff --git a/src/instructions/looks/switchbackdropto.rs b/src/instructions/looks/switchbackdropto.rs index 2b4723f0..821e7464 100644 --- a/src/instructions/looks/switchbackdropto.rs +++ b/src/instructions/looks/switchbackdropto.rs @@ -65,6 +65,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for looks_switchbackdropto(t) { -} + mod tests for looks_switchbackdropto(t) {} ); diff --git a/src/instructions/looks/switchcostumeto.rs b/src/instructions/looks/switchcostumeto.rs index 7628a270..bce84e18 100644 --- a/src/instructions/looks/switchcostumeto.rs +++ b/src/instructions/looks/switchcostumeto.rs @@ -77,6 +77,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for looks_switchcostumeto(t) { -} + mod tests for looks_switchcostumeto(t) {} ); diff --git a/src/instructions/looks/think.rs b/src/instructions/looks/think.rs index 51029b1c..413b3e76 100644 --- a/src/instructions/looks/think.rs +++ b/src/instructions/looks/think.rs @@ -96,13 +96,24 @@ pub const fn const_fold( Ok(NotFoldable) } -crate::instructions_test! ( -mod tests_debug for looks_think(t) { - fields = super::Fields { debug: true, target_idx: 0 }; +#[cfg(test)] +mod test { + use super::*; + use crate::instructions::tests::assert_valid_json; + + #[test] + fn fields_display_is_valid_json() { + assert_valid_json(format!("{}", Fields { debug: false, target_idx: 0 })); + } } + +crate::instructions_test! ( + mod tests_debug for looks_think(t) { + fields = super::Fields { debug: true, target_idx: 0 }; + } ); crate::instructions_test! ( -mod tests_non_debug for looks_think(t) { - fields = super::Fields { debug: false, target_idx: 0, }; -} + mod tests_non_debug for looks_think(t) { + fields = super::Fields { debug: false, target_idx: 0, }; + } ); diff --git a/src/instructions/motion/direction.rs b/src/instructions/motion/direction.rs index 6fcbc468..828eefe5 100644 --- a/src/instructions/motion/direction.rs +++ b/src/instructions/motion/direction.rs @@ -39,6 +39,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for motion_direction { -} + mod tests for motion_direction {} ); diff --git a/src/instructions/motion/gotoxy.rs b/src/instructions/motion/gotoxy.rs index ebb10da7..5f29c7f8 100644 --- a/src/instructions/motion/gotoxy.rs +++ b/src/instructions/motion/gotoxy.rs @@ -162,6 +162,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for motion_gotoxy(t1,t2) { -} + mod tests for motion_gotoxy(t1,t2) {} ); diff --git a/src/instructions/motion/pointindirection.rs b/src/instructions/motion/pointindirection.rs index 509a77f4..9b07dbe8 100644 --- a/src/instructions/motion/pointindirection.rs +++ b/src/instructions/motion/pointindirection.rs @@ -57,6 +57,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for motion_pointindirection(t) { -} + mod tests for motion_pointindirection(t) {} ); diff --git a/src/instructions/motion/setx.rs b/src/instructions/motion/setx.rs index f7fc83b6..1590505c 100644 --- a/src/instructions/motion/setx.rs +++ b/src/instructions/motion/setx.rs @@ -171,6 +171,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for motion_setx(t) { -} + mod tests for motion_setx(t) {} ); diff --git a/src/instructions/motion/sety.rs b/src/instructions/motion/sety.rs index cf29d265..72a759bd 100644 --- a/src/instructions/motion/sety.rs +++ b/src/instructions/motion/sety.rs @@ -171,6 +171,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for motion_setx(t) { -} + mod tests for motion_setx(t) {} ); diff --git a/src/instructions/motion/xposition.rs b/src/instructions/motion/xposition.rs index c73528b6..cee4ae65 100644 --- a/src/instructions/motion/xposition.rs +++ b/src/instructions/motion/xposition.rs @@ -39,6 +39,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for motion_xposition { -} + mod tests for motion_xposition {} ); diff --git a/src/instructions/motion/yposition.rs b/src/instructions/motion/yposition.rs index 94e69d37..602c2424 100644 --- a/src/instructions/motion/yposition.rs +++ b/src/instructions/motion/yposition.rs @@ -39,6 +39,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for motion_yposition { -} + mod tests for motion_yposition {} ); diff --git a/src/instructions/operator/abs.rs b/src/instructions/operator/abs.rs index 1992ba40..9774abb8 100644 --- a/src/instructions/operator/abs.rs +++ b/src/instructions/operator/abs.rs @@ -75,6 +75,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_abs(t) { -} + mod tests for operator_abs(t) {} ); diff --git a/src/instructions/operator/acos.rs b/src/instructions/operator/acos.rs index 588e02c6..82ebad96 100644 --- a/src/instructions/operator/acos.rs +++ b/src/instructions/operator/acos.rs @@ -35,6 +35,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_acos(t) { -} + mod tests for operator_acos(t) {} ); diff --git a/src/instructions/operator/add.rs b/src/instructions/operator/add.rs index 6966f483..008f01f7 100644 --- a/src/instructions/operator/add.rs +++ b/src/instructions/operator/add.rs @@ -87,6 +87,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_add(t1,t2) { -} + mod tests for operator_add(t1,t2) {} ); diff --git a/src/instructions/operator/and.rs b/src/instructions/operator/and.rs index 41e3a88a..531ac111 100644 --- a/src/instructions/operator/and.rs +++ b/src/instructions/operator/and.rs @@ -22,6 +22,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_and(t1,t2) { -} + mod tests for operator_and(t1,t2) {} ); diff --git a/src/instructions/operator/asin.rs b/src/instructions/operator/asin.rs index f427cb01..272eb7b0 100644 --- a/src/instructions/operator/asin.rs +++ b/src/instructions/operator/asin.rs @@ -35,6 +35,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_asin(t) { -} + mod tests for operator_asin(t) {} ); diff --git a/src/instructions/operator/atan.rs b/src/instructions/operator/atan.rs index 4cf9ca79..8160665a 100644 --- a/src/instructions/operator/atan.rs +++ b/src/instructions/operator/atan.rs @@ -35,6 +35,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_atan(t) { -} + mod tests for operator_atan(t) {} ); diff --git a/src/instructions/operator/ceiling.rs b/src/instructions/operator/ceiling.rs index 47f75bef..915d723d 100644 --- a/src/instructions/operator/ceiling.rs +++ b/src/instructions/operator/ceiling.rs @@ -62,6 +62,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_ceiling(t) { -} + mod tests for operator_ceiling(t) {} ); diff --git a/src/instructions/operator/contains.rs b/src/instructions/operator/contains.rs index 64fc0d50..1da4264d 100644 --- a/src/instructions/operator/contains.rs +++ b/src/instructions/operator/contains.rs @@ -30,6 +30,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_contains(t1,t2) { -} + mod tests for operator_contains(t1,t2) {} ); diff --git a/src/instructions/operator/cos.rs b/src/instructions/operator/cos.rs index 107ad6b7..854786cf 100644 --- a/src/instructions/operator/cos.rs +++ b/src/instructions/operator/cos.rs @@ -42,6 +42,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_cos(t) { -} + mod tests for operator_cos(t) {} ); diff --git a/src/instructions/operator/divide.rs b/src/instructions/operator/divide.rs index e49c71ad..8cb5d559 100644 --- a/src/instructions/operator/divide.rs +++ b/src/instructions/operator/divide.rs @@ -51,6 +51,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_divide(t1,t2) { -} + mod tests for operator_divide(t1,t2) {} ); diff --git a/src/instructions/operator/equals.rs b/src/instructions/operator/equals.rs index d813e39c..d9c68156 100644 --- a/src/instructions/operator/equals.rs +++ b/src/instructions/operator/equals.rs @@ -401,6 +401,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_equals(t1,t2) { -} + mod tests for operator_equals(t1,t2) {} ); diff --git a/src/instructions/operator/exp.rs b/src/instructions/operator/exp.rs index c43bd4a2..ce96e0de 100644 --- a/src/instructions/operator/exp.rs +++ b/src/instructions/operator/exp.rs @@ -39,6 +39,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_exp(t) { -} + mod tests for operator_exp(t) {} ); diff --git a/src/instructions/operator/floor.rs b/src/instructions/operator/floor.rs index 0634d195..390e7e10 100644 --- a/src/instructions/operator/floor.rs +++ b/src/instructions/operator/floor.rs @@ -62,6 +62,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_floor(t) { -} + mod tests for operator_floor(t) {} ); diff --git a/src/instructions/operator/gt.rs b/src/instructions/operator/gt.rs index 1b53825e..5528e052 100644 --- a/src/instructions/operator/gt.rs +++ b/src/instructions/operator/gt.rs @@ -327,6 +327,5 @@ pub fn const_fold(inputs: &[ConstFoldItem], _state: &mut ConstFoldState) -> HQRe } crate::instructions_test! ( -mod tests for operator_lt(t1,t2) { -} + mod tests for operator_lt(t1,t2) {} ); diff --git a/src/instructions/operator/join.rs b/src/instructions/operator/join.rs index 41fe537d..6e39d57d 100644 --- a/src/instructions/operator/join.rs +++ b/src/instructions/operator/join.rs @@ -35,6 +35,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_join(t1,t2) { -} + mod tests for operator_join(t1,t2) {} ); diff --git a/src/instructions/operator/length.rs b/src/instructions/operator/length.rs index e92ff8bf..4821fe3b 100644 --- a/src/instructions/operator/length.rs +++ b/src/instructions/operator/length.rs @@ -27,6 +27,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_length(t) { -} + mod tests for operator_length(t) {} ); diff --git a/src/instructions/operator/letter_of.rs b/src/instructions/operator/letter_of.rs index a9bb51c4..912900e2 100644 --- a/src/instructions/operator/letter_of.rs +++ b/src/instructions/operator/letter_of.rs @@ -48,6 +48,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_letter_of(t1,t2) { -} + mod tests for operator_letter_of(t1,t2) {} ); diff --git a/src/instructions/operator/ln.rs b/src/instructions/operator/ln.rs index d7350e77..e02fb6d0 100644 --- a/src/instructions/operator/ln.rs +++ b/src/instructions/operator/ln.rs @@ -43,6 +43,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_ln(t) { -} + mod tests for operator_ln(t) {} ); diff --git a/src/instructions/operator/log.rs b/src/instructions/operator/log.rs index 84922854..47dbfb7c 100644 --- a/src/instructions/operator/log.rs +++ b/src/instructions/operator/log.rs @@ -41,6 +41,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_log(t) { -} + mod tests for operator_log(t) {} ); diff --git a/src/instructions/operator/lt.rs b/src/instructions/operator/lt.rs index 61cf1e26..b90a2343 100644 --- a/src/instructions/operator/lt.rs +++ b/src/instructions/operator/lt.rs @@ -288,6 +288,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_lt(t1,t2) { -} + mod tests for operator_lt(t1,t2) {} ); diff --git a/src/instructions/operator/modulo.rs b/src/instructions/operator/modulo.rs index cfe4afdb..8a09a785 100644 --- a/src/instructions/operator/modulo.rs +++ b/src/instructions/operator/modulo.rs @@ -188,6 +188,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_modulo(t1,t2) { -} + mod tests for operator_modulo(t1,t2) {} ); diff --git a/src/instructions/operator/multiply.rs b/src/instructions/operator/multiply.rs index c9d66d87..4a05770f 100644 --- a/src/instructions/operator/multiply.rs +++ b/src/instructions/operator/multiply.rs @@ -91,6 +91,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_multiply(t1,t2) { -} + mod tests for operator_multiply(t1,t2) {} ); diff --git a/src/instructions/operator/not.rs b/src/instructions/operator/not.rs index e71cf464..7e325d24 100644 --- a/src/instructions/operator/not.rs +++ b/src/instructions/operator/not.rs @@ -22,6 +22,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_not(t) { -} + mod tests for operator_not(t) {} ); diff --git a/src/instructions/operator/or.rs b/src/instructions/operator/or.rs index 5c450a9f..85082323 100644 --- a/src/instructions/operator/or.rs +++ b/src/instructions/operator/or.rs @@ -22,6 +22,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_or(t1,t2) { -} + mod tests for operator_or(t1,t2) {} ); diff --git a/src/instructions/operator/pow10.rs b/src/instructions/operator/pow10.rs index 1af6fced..32a74862 100644 --- a/src/instructions/operator/pow10.rs +++ b/src/instructions/operator/pow10.rs @@ -39,6 +39,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_pow10(t) { -} + mod tests for operator_pow10(t) {} ); diff --git a/src/instructions/operator/random.rs b/src/instructions/operator/random.rs index 7e3854e1..f8177954 100644 --- a/src/instructions/operator/random.rs +++ b/src/instructions/operator/random.rs @@ -194,6 +194,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_random(t1,t2) { -} + mod tests for operator_random(t1,t2) {} ); diff --git a/src/instructions/operator/round.rs b/src/instructions/operator/round.rs index de576a2e..00668df6 100644 --- a/src/instructions/operator/round.rs +++ b/src/instructions/operator/round.rs @@ -39,6 +39,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_round(t) { -} + mod tests for operator_round(t) {} ); diff --git a/src/instructions/operator/sin.rs b/src/instructions/operator/sin.rs index 5f7190b3..20a982a6 100644 --- a/src/instructions/operator/sin.rs +++ b/src/instructions/operator/sin.rs @@ -42,6 +42,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_sin(t) { -} + mod tests for operator_sin(t) {} ); diff --git a/src/instructions/operator/sqrt.rs b/src/instructions/operator/sqrt.rs index 603b4f3f..b2be43ed 100644 --- a/src/instructions/operator/sqrt.rs +++ b/src/instructions/operator/sqrt.rs @@ -33,6 +33,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_sqrt(t) { -} + mod tests for operator_sqrt(t) {} ); diff --git a/src/instructions/operator/subtract.rs b/src/instructions/operator/subtract.rs index 39124536..45e21c4c 100644 --- a/src/instructions/operator/subtract.rs +++ b/src/instructions/operator/subtract.rs @@ -89,6 +89,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_subtract(t1,t2) { -} + mod tests for operator_subtract(t1,t2) {} ); diff --git a/src/instructions/operator/tan.rs b/src/instructions/operator/tan.rs index 44adbd4d..98194225 100644 --- a/src/instructions/operator/tan.rs +++ b/src/instructions/operator/tan.rs @@ -39,6 +39,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for operator_tan(t) { -} + mod tests for operator_tan(t) {} ); diff --git a/src/instructions/pen/changecolorparamby.rs b/src/instructions/pen/changecolorparamby.rs index 084cbfed..f6596c60 100644 --- a/src/instructions/pen/changecolorparamby.rs +++ b/src/instructions/pen/changecolorparamby.rs @@ -148,6 +148,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests_colour for pen_changecolorparamby(t1,t2) { -} + mod tests_colour for pen_changecolorparamby(t1,t2) {} ); diff --git a/src/instructions/pen/clear.rs b/src/instructions/pen/clear.rs index 757af79f..afbf0b2e 100644 --- a/src/instructions/pen/clear.rs +++ b/src/instructions/pen/clear.rs @@ -26,6 +26,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for pen_clear { -} + mod tests for pen_clear {} ); diff --git a/src/instructions/pen/pendown.rs b/src/instructions/pen/pendown.rs index 0589fc18..7a5b1ad2 100644 --- a/src/instructions/pen/pendown.rs +++ b/src/instructions/pen/pendown.rs @@ -96,6 +96,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for pen_pendown { -} + mod tests for pen_pendown {} ); diff --git a/src/instructions/pen/penup.rs b/src/instructions/pen/penup.rs index 1a0fb04a..1f62b673 100644 --- a/src/instructions/pen/penup.rs +++ b/src/instructions/pen/penup.rs @@ -38,6 +38,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for pen_penup { -} + mod tests for pen_penup {} ); diff --git a/src/instructions/pen/setpencolorparamto.rs b/src/instructions/pen/setpencolorparamto.rs index 3e99e425..9dc3cd92 100644 --- a/src/instructions/pen/setpencolorparamto.rs +++ b/src/instructions/pen/setpencolorparamto.rs @@ -120,6 +120,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests_colour for pen_setpencolorparamto(t1,t2) { -} + mod tests_colour for pen_setpencolorparamto(t1,t2) {} ); diff --git a/src/instructions/pen/setpencolortocolor.rs b/src/instructions/pen/setpencolortocolor.rs index 709e456c..12450fd4 100644 --- a/src/instructions/pen/setpencolortocolor.rs +++ b/src/instructions/pen/setpencolortocolor.rs @@ -123,6 +123,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for pen_setpencolortocolor(t) { -} + mod tests for pen_setpencolortocolor(t) {} ); diff --git a/src/instructions/pen/setpensizeto.rs b/src/instructions/pen/setpensizeto.rs index b5ee0ef0..3442e323 100644 --- a/src/instructions/pen/setpensizeto.rs +++ b/src/instructions/pen/setpensizeto.rs @@ -45,6 +45,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for pen_setpensizeto(t) { -} + mod tests for pen_setpensizeto(t) {} ); diff --git a/src/instructions/procedures/argument.rs b/src/instructions/procedures/argument.rs index f52ef4b3..aa399808 100644 --- a/src/instructions/procedures/argument.rs +++ b/src/instructions/procedures/argument.rs @@ -117,3 +117,26 @@ pub const fn const_fold( ) -> HQResult { Ok(NotFoldable) } + +#[cfg(test)] +mod test { + use super::*; + use super::super::super::tests::*; + use crate::wasm::{WasmFlags, flags::unit_test_wasm_features}; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(true, WasmFlags::new(unit_test_wasm_features())); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields(in_warped: bool, flags: WasmFlags) -> Fields { + let var = RcVar::new(IrType::Any, &VarVal::Float(0.0), None, &flags).unwrap(); + Fields { + index: 0, + arg_var: var.clone(), + in_warped, + arg_vars: Rc::new(RefCell::new(vec![var])), + } + } +} \ No newline at end of file diff --git a/src/instructions/sensing/answer.rs b/src/instructions/sensing/answer.rs index b70b1ab1..2e3eb28a 100644 --- a/src/instructions/sensing/answer.rs +++ b/src/instructions/sensing/answer.rs @@ -37,6 +37,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for sensing_answer { -} + mod tests for sensing_answer {} ); diff --git a/src/instructions/sensing/askandwait.rs b/src/instructions/sensing/askandwait.rs index f30c100f..40cd8c3e 100644 --- a/src/instructions/sensing/askandwait.rs +++ b/src/instructions/sensing/askandwait.rs @@ -93,11 +93,42 @@ pub const fn const_fold( Ok(NotFoldable) } -// crate::instructions_test! ( -// mod tests for sensing_askandwait { -// fields = super::Fields { -// poll_step: super::StepIndex(0), -// next_step: super::StepIndex(0), -// }; -// } -// ); +#[cfg(test)] +mod test { + use super::super::super::tests::*; + use super::*; + use crate::wasm::{StepTarget, WasmFlags, WasmProject, registries::TypeRegistry}; + + #[test] + fn fields_display_is_valid_json() { + let fields = make_fields(); + assert_valid_json(format!("{fields}")); + } + + pub fn make_fields() -> Fields { + Fields { + poll_step: StepIndex(0), + next_step: StepIndex(0), + } + } + + pub fn setup_project(wasm_proj: &WasmProject, flags: WasmFlags) { + let step_func = StepFunc::new_with_types( + Box::from([ValType::I32, TypeRegistry::STRUCT_REF]), + Box::from([]), + wasm_proj.registries(), + flags, + StepTarget::Sprite(0), + 0, + Rc::new(vec![]), + ); + wasm_proj.steps().borrow_mut().push(step_func); + } +} + +crate::instructions_test! ( + mod tests for sensing_askandwait(t) { + fields = super::test::make_fields(); + setup = super::test::setup_project; + } +); diff --git a/src/instructions/sensing/dayssince2000.rs b/src/instructions/sensing/dayssince2000.rs index 0a29df20..906e5430 100644 --- a/src/instructions/sensing/dayssince2000.rs +++ b/src/instructions/sensing/dayssince2000.rs @@ -27,6 +27,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for sensing_dayssince2000 { -} + mod tests for sensing_dayssince2000 {} ); diff --git a/src/instructions/sensing/keypressed.rs b/src/instructions/sensing/keypressed.rs index 513ca25c..5822d5c1 100644 --- a/src/instructions/sensing/keypressed.rs +++ b/src/instructions/sensing/keypressed.rs @@ -26,6 +26,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for sensing_keypressed(t) { -} + mod tests for sensing_keypressed(t) {} ); diff --git a/src/instructions/sensing/mousedown.rs b/src/instructions/sensing/mousedown.rs index 24f7035b..a849edc1 100644 --- a/src/instructions/sensing/mousedown.rs +++ b/src/instructions/sensing/mousedown.rs @@ -36,6 +36,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for sensing_mousedown { -} + mod tests for sensing_mousedown {} ); diff --git a/src/instructions/sensing/mousex.rs b/src/instructions/sensing/mousex.rs index 1b0cb466..83cd8140 100644 --- a/src/instructions/sensing/mousex.rs +++ b/src/instructions/sensing/mousex.rs @@ -36,6 +36,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for sensing_mousex { -} + mod tests for sensing_mousex {} ); diff --git a/src/instructions/sensing/mousey.rs b/src/instructions/sensing/mousey.rs index 64887bb3..bc14f835 100644 --- a/src/instructions/sensing/mousey.rs +++ b/src/instructions/sensing/mousey.rs @@ -36,6 +36,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for sensing_mousey { -} + mod tests for sensing_mousey {} ); diff --git a/src/instructions/sensing/reset_timer.rs b/src/instructions/sensing/reset_timer.rs index 8f3c2f6a..91cfb86f 100644 --- a/src/instructions/sensing/reset_timer.rs +++ b/src/instructions/sensing/reset_timer.rs @@ -37,6 +37,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for sensing_reset_timer { -} + mod tests for sensing_reset_timer {} ); diff --git a/src/instructions/sensing/timer.rs b/src/instructions/sensing/timer.rs index 977ab3fc..3b08246c 100644 --- a/src/instructions/sensing/timer.rs +++ b/src/instructions/sensing/timer.rs @@ -36,6 +36,5 @@ pub const fn const_fold( } crate::instructions_test! ( -mod tests for sensing_timer { -} + mod tests for sensing_timer {} ); diff --git a/src/instructions/tests.rs b/src/instructions/tests.rs index 0365d312..911472ab 100644 --- a/src/instructions/tests.rs +++ b/src/instructions/tests.rs @@ -76,11 +76,11 @@ macro_rules! instructions_test { for ($($($type_arg,)*)?) in types_iter(true) { #[allow(unused_mut, reason = "may not be unused")] #[allow(unused, reason = "might not be unused")] - let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser); + let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser, vec![vec!["".into()]]); $($setup(&mut proj, flags());)? let output_type_result = output_type(Rc::from([$($($type_arg,)*)?]), $(&$fields)?); let registries = Rc::new(Registries::default()); - let step_func = StepFunc::new(Rc::clone(®istries), flags(), StepTarget::Sprite(0), 0, Rc::new(vec![])); + let step_func = StepFunc::new(Rc::clone(®istries), flags(), StepTarget::Sprite(0), 0, Rc::clone(proj.costume_names())); let wasm_result = wasm(&step_func, Rc::from([$($($type_arg,)*)?]), $(&$fields)?); match (output_type_result.clone(), wasm_result.clone()) { (Err(..), Ok(..)) | (Ok(..), Err(..)) => panic!("output_type result doesn't match wasm result for type(s) {:?}:\noutput_type: {:?},\nwasm: {:?}", ($($($type_arg,)*)?), output_type_result, wasm_result), @@ -96,7 +96,7 @@ macro_rules! instructions_test { fn wasm_output_type_matches_expected_output_type() -> HQResult<()> { for ($($($type_arg,)*)?) in types_iter(true) { #[allow(unused_mut, reason = "may not be unused")] - let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser); + let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser, vec![vec!["".into()]]); $($setup(&mut proj, flags());)? let Ok(output_type) = output_type(Rc::from([$($($type_arg,)*)?]), $(&$fields)?) else { println!("skipping failed output_type"); @@ -115,7 +115,7 @@ macro_rules! instructions_test { ReturnType::MultiValue(outputs) => outputs.iter().copied().map(WasmProject::ir_type_to_wasm).collect(), ReturnType::None => vec![], }; - let step_func = StepFunc::new_with_types(params.into(), result.into(), Rc::clone(®istries), flags(), StepTarget::Sprite(0), 0, Rc::new(vec![])); + let step_func = StepFunc::new_with_types(params.into(), result.into(), Rc::clone(®istries), flags(), StepTarget::Sprite(0), 0, Rc::clone(proj.costume_names())); let Ok(wasm) = wasm(&step_func, Rc::from([$($($type_arg,)*)?]), $(&$fields)?) else { println!("skipping failed wasm"); continue; @@ -142,7 +142,7 @@ macro_rules! instructions_test { fn wasm_output_type_matches_wrapped_expected_output_type() -> HQResult<()> { for ($($($type_arg,)*)?) in types_iter(false) { #[allow(unused_mut, reason = "may not be unused")] - let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser); + let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser, vec![vec!["".into()]]); $($setup(&mut proj, flags());)? let Ok(output_type) = $crate::instructions::boxed_output_type( |inputs| output_type(inputs, $(&$fields)?), @@ -168,7 +168,7 @@ macro_rules! instructions_test { flags(), StepTarget::Sprite(0), 0, - Rc::new(vec![]) + Rc::clone(proj.costume_names()) ); let drops = match output_type { ReturnType::Singleton(_) => 1, diff --git a/src/wasm/project.rs b/src/wasm/project.rs index a01477e5..3e9f7483 100644 --- a/src/wasm/project.rs +++ b/src/wasm/project.rs @@ -39,7 +39,7 @@ impl WasmProject { )] #[allow(dead_code, reason = "not dead in test mode")] #[must_use] - pub fn new(flags: WasmFlags, environment: ExternalEnvironment) -> Self { + pub fn new(flags: WasmFlags, environment: ExternalEnvironment, costume_names: Vec>>) -> Self { Self { flags, steps: Rc::new(RefCell::new(Vec::new())), @@ -47,7 +47,7 @@ impl WasmProject { environment, registries: Rc::new(Registries::default()), target_names: vec![], - costume_names: Rc::new(vec![]), + costume_names: Rc::new(costume_names), } } @@ -56,6 +56,11 @@ impl WasmProject { Rc::clone(&self.registries) } + #[must_use] + pub const fn costume_names(&self) -> &Rc>>> { + &self.costume_names + } + #[must_use] pub const fn environment(&self) -> ExternalEnvironment { self.environment From 87f4fb0638f35f427104a2c5fae025bf8eb4ae73 Mon Sep 17 00:00:00 2001 From: pufferfish101007 <50246616+pufferfish101007@users.noreply.github.com> Date: Mon, 10 Aug 2026 21:13:11 +0100 Subject: [PATCH 8/9] separate some instructions_test functions out of the macro --- src/instructions/tests.rs | 278 +++++++++++++++++++++++--------------- 1 file changed, 167 insertions(+), 111 deletions(-) diff --git a/src/instructions/tests.rs b/src/instructions/tests.rs index 911472ab..00cd5a7d 100644 --- a/src/instructions/tests.rs +++ b/src/instructions/tests.rs @@ -28,11 +28,11 @@ macro_rules! instructions_test { mod $module { #![expect(clippy::allow_attributes, reason = "might not always trigger")] - use super::{wasm, output_type, acceptable_inputs}; + use super::{output_type, acceptable_inputs}; use $crate::prelude::*; - use $crate::ir::{IrType, ReturnType}; - use wasm_encoder::ValType; - use $crate::wasm::{StepFunc, Registries, WasmProject, WasmFlags, StepTarget, ExternalEnvironment}; + use $crate::ir::IrType; + use $crate::instructions::IrOpcode; + use $crate::wasm::{StepFunc, Registries, WasmProject, WasmFlags, StepTarget, ExternalEnvironment, InternalInstruction}; #[allow(unused, reason = "it might not be unused")] use $crate::wasm::flags::{Switch, unit_test_wasm_features}; @@ -74,14 +74,15 @@ macro_rules! instructions_test { #[test] fn output_type_fails_when_wasm_fails() { for ($($($type_arg,)*)?) in types_iter(true) { + let types = &[$($($type_arg,)*)?]; #[allow(unused_mut, reason = "may not be unused")] #[allow(unused, reason = "might not be unused")] let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser, vec![vec!["".into()]]); $($setup(&mut proj, flags());)? - let output_type_result = output_type(Rc::from([$($($type_arg,)*)?]), $(&$fields)?); + let output_type_result = output_type(types.clone().into(), $(&$fields)?); let registries = Rc::new(Registries::default()); let step_func = StepFunc::new(Rc::clone(®istries), flags(), StepTarget::Sprite(0), 0, Rc::clone(proj.costume_names())); - let wasm_result = wasm(&step_func, Rc::from([$($($type_arg,)*)?]), $(&$fields)?); + let wasm_result = wasm(&step_func, types); match (output_type_result.clone(), wasm_result.clone()) { (Err(..), Ok(..)) | (Ok(..), Err(..)) => panic!("output_type result doesn't match wasm result for type(s) {:?}:\noutput_type: {:?},\nwasm: {:?}", ($($($type_arg,)*)?), output_type_result, wasm_result), (Err(HQError { err_type: e1, .. }), Err(HQError { err_type: e2, .. })) if e1 != e2 => { @@ -92,127 +93,40 @@ macro_rules! instructions_test { } } + fn wasm(step_func: &StepFunc, types: &[IrType]) -> HQResult> { + super::wasm(step_func, types.clone().into(), $(&$fields)?) + } + + #[test] fn wasm_output_type_matches_expected_output_type() -> HQResult<()> { for ($($($type_arg,)*)?) in types_iter(true) { + let types: &[IrType] = &[$($($type_arg,)*)?]; #[allow(unused_mut, reason = "may not be unused")] let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser, vec![vec!["".into()]]); $($setup(&mut proj, flags());)? - let Ok(output_type) = output_type(Rc::from([$($($type_arg,)*)?]), $(&$fields)?) else { - println!("skipping failed output_type"); - continue; - }; - let registries = proj.registries(); - let types: &[IrType] = &[$($($type_arg,)*)?]; - let params = types - .into_iter() - .copied() - .map(WasmProject::ir_type_to_wasm) - .chain([ValType::I32, $crate::wasm::registries::TypeRegistry::STRUCT_REF]) - .collect::>(); - let result = match output_type { - ReturnType::Singleton(output) => vec![WasmProject::ir_type_to_wasm(output)], - ReturnType::MultiValue(outputs) => outputs.iter().copied().map(WasmProject::ir_type_to_wasm).collect(), - ReturnType::None => vec![], - }; - let step_func = StepFunc::new_with_types(params.into(), result.into(), Rc::clone(®istries), flags(), StepTarget::Sprite(0), 0, Rc::clone(proj.costume_names())); - let Ok(wasm) = wasm(&step_func, Rc::from([$($($type_arg,)*)?]), $(&$fields)?) else { - println!("skipping failed wasm"); - continue; - }; - for (i, _) in types.iter().enumerate() { - step_func.add_instructions([$crate::wasm::InternalInstruction::Immediate(wasm_encoder::Instruction::LocalGet(i.try_into().unwrap()))])? - } - step_func.add_instructions(wasm)?; - - proj.steps() - .borrow_mut() - .push(step_func); - - let wasm_bytes = proj.finish().unwrap().wasm_bytes; - - println!("{}", wasmprinter::print_bytes(wasm_bytes.clone()).unwrap()); - - wasmparser::validate(&wasm_bytes).map_err(|err| make_hq_bug!("invalid wasm module with types {:?}. Original error message: {}", ($($($type_arg,)*)?), err.message()))?; + let output_type2 = || output_type(Rc::from([$($($type_arg,)*)?]), $(&$fields)?); + $crate::instructions::tests::wasm_output_type_matches_expected_output_type(proj, types, output_type2, wasm, flags())?; } Ok(()) } + fn wrap_instructions(step_func: &StepFunc, types: &[IrType], opcodes: Vec) -> HQResult> { + $crate::instructions::wrap_instructions(step_func, types.clone().into(), &opcodes) + } + #[test] fn wasm_output_type_matches_wrapped_expected_output_type() -> HQResult<()> { for ($($($type_arg,)*)?) in types_iter(false) { + let types: &[IrType] = &[$($($type_arg,)*)?]; #[allow(unused_mut, reason = "may not be unused")] let mut proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser, vec![vec!["".into()]]); $($setup(&mut proj, flags());)? - let Ok(output_type) = $crate::instructions::boxed_output_type( + let output_type2 = || $crate::instructions::boxed_output_type( |inputs| output_type(inputs, $(&$fields)?), - Rc::from([$($($type_arg,)*)?]), - ) else { - println!("skipping failed output_type"); - continue; - }; - println!("{output_type:?}"); - let registries = proj.registries(); - let types: &[IrType] = &[$($($type_arg,)*)?]; - let params = types - .into_iter() - .copied() - .map(WasmProject::ir_type_to_wasm) - .chain([ValType::I32, $crate::wasm::registries::TypeRegistry::STRUCT_REF]) - .collect::>(); - let result = vec![]; - let step_func = StepFunc::new_with_types( - params.into(), - result.into(), - Rc::clone(®istries), - flags(), - StepTarget::Sprite(0), - 0, - Rc::clone(proj.costume_names()) + types.clone().into(), ); - let drops = match output_type { - ReturnType::Singleton(_) => 1, - ReturnType::MultiValue(outs) => outs.len(), - ReturnType::None => 0, - }; - let test_opcodes = [$crate::instructions::IrOpcode::$opcode$(($fields))?] - .into_iter() - .chain(core::iter::repeat_n($crate::instructions::IrOpcode::hq_drop, drops)) - .collect::>(); - let wasm = $crate::instructions::wrap_instructions( - &step_func, - Rc::from([$($($type_arg,)*)?]), - &test_opcodes, - )?; - // println!("{wasm:?}"); - for (i, _) in types.iter().enumerate() { - step_func.add_instructions( - [$crate::wasm::InternalInstruction::Immediate( - wasm_encoder::Instruction::LocalGet( - i.try_into().unwrap() - ) - )] - )? - } - step_func.add_instructions(wasm)?; - - // println!("{:?}", step_func.instructions().borrow()); - - proj.steps() - .borrow_mut() - .push(step_func); - - let wasm_bytes = proj.finish().unwrap().wasm_bytes; - - println!("{}", wasmprinter::print_bytes(wasm_bytes.clone()).unwrap()); - - wasmparser::validate(&wasm_bytes).map_err(|err| - make_hq_bug!( - "invalid wasm module with types {:?}. Original error message: {}", - ($($($type_arg,)*)?), - err.message() - ) - )?; + $crate::instructions::tests::wasm_output_type_matches_wrapped_expected_output_type(proj, types, output_type2, wrap_instructions, flags(), IrOpcode::$opcode$(($fields))?)?; } Ok(()) } @@ -309,14 +223,18 @@ macro_rules! instructions_test { } } - #[cfg(test)] pub use test_util::*; #[cfg(test)] mod test_util { - use crate::ir::{Step, StepContext, Target}; + use wasm_encoder::ValType; + + use crate::instructions::IrOpcode; + use crate::ir::{IrType, ReturnType, Step, StepContext, Target}; use crate::prelude::*; + use crate::wasm::registries::TypeRegistry; + use crate::wasm::{InternalInstruction, StepFunc, StepTarget, WasmFlags, WasmProject}; pub fn make_target() -> Rc { Rc::new(Target::new( @@ -350,4 +268,142 @@ mod test_util { pub fn assert_valid_json>(test: S) { assert!(serde_json::from_str::(&test).is_ok()); } + + pub fn wasm_output_type_matches_expected_output_type( + proj: WasmProject, + types: &[IrType], + output_type: OT, + wasm: W, + flags: WasmFlags, + ) -> HQResult<()> + where + OT: FnOnce() -> HQResult, + W: FnOnce(&StepFunc, &[IrType]) -> HQResult>, + { + let Ok(output_type) = output_type() else { + println!("skipping failed output_type"); + return Ok(()); + }; + let registries = proj.registries(); + let params = types + .iter() + .copied() + .map(WasmProject::ir_type_to_wasm) + .chain([ValType::I32, TypeRegistry::STRUCT_REF]) + .collect::>(); + let result = match output_type { + ReturnType::Singleton(output) => vec![WasmProject::ir_type_to_wasm(output)], + ReturnType::MultiValue(outputs) => outputs + .iter() + .copied() + .map(WasmProject::ir_type_to_wasm) + .collect(), + ReturnType::None => vec![], + }; + let step_func = StepFunc::new_with_types( + params.into(), + result.into(), + Rc::clone(®istries), + flags, + StepTarget::Sprite(0), + 0, + Rc::clone(proj.costume_names()), + ); + let Ok(wasm) = wasm(&step_func, types) else { + println!("skipping failed wasm"); + return Ok(()); + }; + for (i, _) in types.iter().enumerate() { + step_func.add_instructions([crate::wasm::InternalInstruction::Immediate( + wasm_encoder::Instruction::LocalGet(i.try_into().unwrap()), + )])?; + } + step_func.add_instructions(wasm)?; + + proj.steps().borrow_mut().push(step_func); + + let wasm_bytes = proj.finish().unwrap().wasm_bytes; + + println!("{}", wasmprinter::print_bytes(wasm_bytes.clone()).unwrap()); + + wasmparser::validate(&wasm_bytes).map_err(|err| { + make_hq_bug!( + "invalid wasm module with types {:?}. Original error message: {}", + types, + err.message() + ) + })?; + + Ok(()) + } + + pub fn wasm_output_type_matches_wrapped_expected_output_type( + proj: WasmProject, + types: &[IrType], + output_type: OT, + wasm: W, + flags: WasmFlags, + opcode: IrOpcode, + ) -> HQResult<()> + where + OT: FnOnce() -> HQResult, + W: FnOnce(&StepFunc, &[IrType], Vec) -> HQResult>, + { + let Ok(output_type) = output_type() else { + println!("skipping failed output_type"); + return Ok(()); + }; + println!("{output_type:?}"); + let registries = proj.registries(); + let params = types + .iter() + .copied() + .map(WasmProject::ir_type_to_wasm) + .chain([ValType::I32, TypeRegistry::STRUCT_REF]) + .collect::>(); + let result = vec![]; + let step_func = StepFunc::new_with_types( + params.into(), + result.into(), + Rc::clone(®istries), + flags, + StepTarget::Sprite(0), + 0, + Rc::clone(proj.costume_names()), + ); + let drops = match output_type { + ReturnType::Singleton(_) => 1, + ReturnType::MultiValue(outs) => outs.len(), + ReturnType::None => 0, + }; + let test_opcodes = core::iter::once(opcode) + .chain(core::iter::repeat_n(IrOpcode::hq_drop, drops)) + .collect::>(); + let wasm = wasm(&step_func, types, test_opcodes)?; + // println!("{wasm:?}"); + for (i, _) in types.iter().enumerate() { + step_func.add_instructions([InternalInstruction::Immediate( + wasm_encoder::Instruction::LocalGet(i.try_into().unwrap()), + )])?; + } + step_func.add_instructions(wasm)?; + + // println!("{:?}", step_func.instructions().borrow()); + + proj.steps().borrow_mut().push(step_func); + + let wasm_bytes = proj.finish().unwrap().wasm_bytes; + + println!("{}", wasmprinter::print_bytes(wasm_bytes.clone()).unwrap()); + + wasmparser::validate(&wasm_bytes).map_err(|err| { + make_hq_bug!( + "invalid wasm module with types {:?}. Original error message: {}", + types, + err.message() + ) + })?; + + Ok(()) + } } From e024b17448fb382e847ec937469dda8c57cfb013 Mon Sep 17 00:00:00 2001 From: pufferfish101007 <50246616+pufferfish101007@users.noreply.github.com> Date: Mon, 10 Aug 2026 21:13:27 +0100 Subject: [PATCH 9/9] format --- src/instructions/control/if_else.rs | 2 +- src/instructions/control/stop_all.rs | 5 +++-- src/instructions/control/wait.rs | 1 - src/instructions/data/listcontents.rs | 6 ++++-- src/instructions/data/replaceitemoflist.rs | 2 +- src/instructions/data/teevariable.rs | 7 ++++++- src/instructions/event/broadcast.rs | 3 ++- src/instructions/hq/box.rs | 9 ++++++--- src/instructions/looks/think.rs | 8 +++++++- src/instructions/procedures/argument.rs | 7 ++++--- src/instructions/sensing/askandwait.rs | 3 ++- src/wasm/project.rs | 6 +++++- 12 files changed, 41 insertions(+), 18 deletions(-) diff --git a/src/instructions/control/if_else.rs b/src/instructions/control/if_else.rs index e2f78c36..8dbf412d 100644 --- a/src/instructions/control/if_else.rs +++ b/src/instructions/control/if_else.rs @@ -87,8 +87,8 @@ pub fn const_fold( #[cfg(test)] mod test { - use super::*; use super::super::super::tests::*; + use super::*; #[test] fn fields_display_is_valid_json() { diff --git a/src/instructions/control/stop_all.rs b/src/instructions/control/stop_all.rs index f60994d7..3b2ca327 100644 --- a/src/instructions/control/stop_all.rs +++ b/src/instructions/control/stop_all.rs @@ -1,7 +1,8 @@ use wasm_encoder::{ConstExpr, HeapType}; use super::super::prelude::*; -use crate::{instructions_test, wasm::{GlobalExportable, GlobalMutable, ThreadsTable}}; +use crate::instructions_test; +use crate::wasm::{GlobalExportable, GlobalMutable, ThreadsTable}; pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult> { let threads_count = func.registries().globals().register( @@ -46,4 +47,4 @@ pub const fn const_fold( instructions_test!( mod test for control_stop_all {} -); \ No newline at end of file +); diff --git a/src/instructions/control/wait.rs b/src/instructions/control/wait.rs index 8e749f9f..18ab64a5 100644 --- a/src/instructions/control/wait.rs +++ b/src/instructions/control/wait.rs @@ -146,4 +146,3 @@ instructions_test!( setup = super::test::setup_project; } ); - diff --git a/src/instructions/data/listcontents.rs b/src/instructions/data/listcontents.rs index b039e4a8..e6e9f8c9 100644 --- a/src/instructions/data/listcontents.rs +++ b/src/instructions/data/listcontents.rs @@ -285,7 +285,8 @@ pub const fn const_fold( #[cfg(test)] pub mod test_utils { use super::*; - use crate::wasm::{WasmFlags, flags::{Switch, unit_test_wasm_features}}; + use crate::wasm::WasmFlags; + use crate::wasm::flags::{Switch, unit_test_wasm_features}; pub fn make_list(mutable: bool, ty: IrType, flags: WasmFlags) -> RcList { let list = crate::ir::RcList::new(vec![], &flags).unwrap(); @@ -303,8 +304,9 @@ pub mod test_utils { #[cfg(test)] mod test { - use super::*; pub use test_utils::*; + + use super::*; use crate::instructions::tests::assert_valid_json; use crate::wasm::WasmFlags; diff --git a/src/instructions/data/replaceitemoflist.rs b/src/instructions/data/replaceitemoflist.rs index 649613a4..4b7e3254 100644 --- a/src/instructions/data/replaceitemoflist.rs +++ b/src/instructions/data/replaceitemoflist.rs @@ -162,4 +162,4 @@ crate::instructions_test!( mod test_any_static for data_replaceitemoflist(t1, t2) { fields = super::test::make_fields(false, IrType::Any, flags()); } -); \ No newline at end of file +); diff --git a/src/instructions/data/teevariable.rs b/src/instructions/data/teevariable.rs index b969cc45..e9e30a17 100644 --- a/src/instructions/data/teevariable.rs +++ b/src/instructions/data/teevariable.rs @@ -154,7 +154,12 @@ mod test { assert_valid_json(format!("{fields}")); } - pub fn make_fields(ty: IrType, initial: VarVal, local_read_write: bool, flags: WasmFlags) -> Fields { + pub fn make_fields( + ty: IrType, + initial: VarVal, + local_read_write: bool, + flags: WasmFlags, + ) -> Fields { Fields { var: make_var(ty, initial, None, flags), local_read_write: RefCell::new(local_read_write), diff --git a/src/instructions/event/broadcast.rs b/src/instructions/event/broadcast.rs index 0dc6357a..32aa9752 100644 --- a/src/instructions/event/broadcast.rs +++ b/src/instructions/event/broadcast.rs @@ -1,5 +1,6 @@ use super::super::prelude::*; -use crate::{instructions_test, wasm::StepFunc}; +use crate::instructions_test; +use crate::wasm::StepFunc; #[derive(Clone, Debug)] pub struct Fields(pub Box); diff --git a/src/instructions/hq/box.rs b/src/instructions/hq/box.rs index 21d22a2b..ad14493b 100644 --- a/src/instructions/hq/box.rs +++ b/src/instructions/hq/box.rs @@ -60,9 +60,12 @@ mod test { #[test] fn fields_display_is_valid_json() { - assert_valid_json(format!("{}", Fields { - output_ty: IrType::Any, - })); + assert_valid_json(format!( + "{}", + Fields { + output_ty: IrType::Any, + } + )); } } diff --git a/src/instructions/looks/think.rs b/src/instructions/looks/think.rs index 413b3e76..8edf9975 100644 --- a/src/instructions/looks/think.rs +++ b/src/instructions/looks/think.rs @@ -103,7 +103,13 @@ mod test { #[test] fn fields_display_is_valid_json() { - assert_valid_json(format!("{}", Fields { debug: false, target_idx: 0 })); + assert_valid_json(format!( + "{}", + Fields { + debug: false, + target_idx: 0 + } + )); } } diff --git a/src/instructions/procedures/argument.rs b/src/instructions/procedures/argument.rs index aa399808..be757b32 100644 --- a/src/instructions/procedures/argument.rs +++ b/src/instructions/procedures/argument.rs @@ -120,9 +120,10 @@ pub const fn const_fold( #[cfg(test)] mod test { - use super::*; use super::super::super::tests::*; - use crate::wasm::{WasmFlags, flags::unit_test_wasm_features}; + use super::*; + use crate::wasm::WasmFlags; + use crate::wasm::flags::unit_test_wasm_features; #[test] fn fields_display_is_valid_json() { @@ -139,4 +140,4 @@ mod test { arg_vars: Rc::new(RefCell::new(vec![var])), } } -} \ No newline at end of file +} diff --git a/src/instructions/sensing/askandwait.rs b/src/instructions/sensing/askandwait.rs index 40cd8c3e..5c2f4a95 100644 --- a/src/instructions/sensing/askandwait.rs +++ b/src/instructions/sensing/askandwait.rs @@ -97,7 +97,8 @@ pub const fn const_fold( mod test { use super::super::super::tests::*; use super::*; - use crate::wasm::{StepTarget, WasmFlags, WasmProject, registries::TypeRegistry}; + use crate::wasm::registries::TypeRegistry; + use crate::wasm::{StepTarget, WasmFlags, WasmProject}; #[test] fn fields_display_is_valid_json() { diff --git a/src/wasm/project.rs b/src/wasm/project.rs index 3e9f7483..b3ecb3bf 100644 --- a/src/wasm/project.rs +++ b/src/wasm/project.rs @@ -39,7 +39,11 @@ impl WasmProject { )] #[allow(dead_code, reason = "not dead in test mode")] #[must_use] - pub fn new(flags: WasmFlags, environment: ExternalEnvironment, costume_names: Vec>>) -> Self { + pub fn new( + flags: WasmFlags, + environment: ExternalEnvironment, + costume_names: Vec>>, + ) -> Self { Self { flags, steps: Rc::new(RefCell::new(Vec::new())),