From 5fc6e67d6eed7863e289a0b858bd3fa1054f5f4a Mon Sep 17 00:00:00 2001
From: aritkulova <aritkulova.yuliia@gmail.com>
Date: Thu, 21 May 2026 16:44:58 +0300
Subject: [PATCH 1/4] updated test with negative path for asserts

---
 simf/mock/asserts_mock.simf | 109 ++++++++++++++++++---
 tests/asserts_test.rs       | 188 +++++++++++++++++++++++++++++++++++-
 2 files changed, 281 insertions(+), 16 deletions(-)

diff --git a/simf/mock/asserts_mock.simf b/simf/mock/asserts_mock.simf
index f6644eb..33351d6 100644
--- a/simf/mock/asserts_mock.simf
+++ b/simf/mock/asserts_mock.simf
@@ -45,22 +45,107 @@ pub fn assert_none256(val: Option<u256>) {
 }
 
 fn main() {
+    let flag: u8 = witness::FLAG;
+    let ifHappyPath: bool = jet::eq_8(flag, 0);
+
     let some_u8: u8 = 255;
     let some_u16: u16 = 65535;
     let some_u32: u32 = 4294967295;
     let some_u64: u64 = 18446744073709551615;
+    let some_u128: u128 = 340282366920938463463374607431768211455;
     let some_u256: u256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
 
-    assert_eq8(some_u8, some_u8);
-    assert_eq16(some_u16, some_u16);
-    assert_eq32(some_u32, some_u32);
-    assert_eq64(some_u64, some_u64);
-    assert_eq256(some_u256, some_u256);
-    
-    assert_none8(None);
-    assert_none16(None);
-    assert_none32(None);
-    assert_none64(None);
-    assert_none128(None);
-    assert_none256(None);
+    match ifHappyPath {
+        true => {
+            assert_eq8(some_u8, some_u8);
+            assert_eq16(some_u16, some_u16);
+            assert_eq32(some_u32, some_u32);
+            assert_eq64(some_u64, some_u64);
+            assert_eq256(some_u256, some_u256);
+            
+            assert_none8(None);
+            assert_none16(None);
+            assert_none32(None);
+            assert_none64(None);
+            assert_none128(None);
+            assert_none256(None);
+        }, false => { 
+            let ifTestNextFunction: bool = jet::eq_8(flag, 1);
+
+            match jet::eq_8(flag, 1) {
+                true => assert_eq8(1, 2),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 2);
+
+            match ifTestNextFunction {
+                true => assert_eq16(1, 2),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 3);
+
+            match ifTestNextFunction {
+                true => assert_eq32(1, 2),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 4);
+
+            match ifTestNextFunction {
+                true => assert_eq64(1, 2),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 5);
+
+            match ifTestNextFunction {
+                true => assert_eq256(1, 2),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 6);
+
+            match ifTestNextFunction {
+                true => assert_none8(Some(some_u8)),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 7);
+
+            match ifTestNextFunction {
+                true => assert_none16(Some(some_u16)),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 8);
+
+            match ifTestNextFunction {
+                true => assert_none32(Some(some_u32)),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 9);
+
+            match ifTestNextFunction {
+                true => assert_none64(Some(some_u64)),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 10);
+
+            match ifTestNextFunction {
+                true => assert_none128(Some(some_u128)),
+                false => (),
+            };
+
+            let ifTestNextFunction: bool = jet::eq_8(flag, 11);
+
+            match ifTestNextFunction {
+                true => assert_none256(Some(some_u256)),
+                false => (),
+            };
+        }
+    }
 }
diff --git a/tests/asserts_test.rs b/tests/asserts_test.rs
index 1091943..75b0722 100644
--- a/tests/asserts_test.rs
+++ b/tests/asserts_test.rs
@@ -26,7 +26,7 @@ fn fund_script(context: &simplex::TestContext) -> anyhow::Result<()> {
     Ok(()) 
 }
 
-fn spend_script(context: &simplex::TestContext) -> anyhow::Result<()> {
+fn spend_script(context: &simplex::TestContext, flag: u8) -> anyhow::Result<()> {
     let signer = context.get_default_signer();
     let provider = context.get_default_provider();
 
@@ -36,7 +36,7 @@ fn spend_script(context: &simplex::TestContext) -> anyhow::Result<()> {
 
     let mut ft = FinalTransaction::new();
 
-    let witness = AssertsMockWitness {};
+    let witness = AssertsMockWitness {flag: flag};
 
     ft.add_program_input(
         PartialInput::new(asserts_utxos[0].clone()),
@@ -51,9 +51,189 @@ fn spend_script(context: &simplex::TestContext) -> anyhow::Result<()> {
 }
 
 #[simplex::test]
-fn asserts_test(context: simplex::TestContext) -> anyhow::Result<()> {
+fn asserts_test_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 0;
+
+    fund_script(&context)?;
+    spend_script(&context, flag)?;
+
+    Ok(())
+}
+
+#[simplex::test]
+fn assert_eq8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 1;
+
     fund_script(&context)?;
-    spend_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+#[simplex::test]
+fn assert_eq16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 2;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+#[simplex::test]
+fn assert_eq32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 3;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+#[simplex::test]
+fn assert_eq64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 4;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+#[simplex::test]
+fn assert_eq256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 5;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+#[simplex::test]
+fn assert_none8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 6;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+#[simplex::test]
+fn assert_none16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 7;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+#[simplex::test]
+fn assert_none32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 8;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+#[simplex::test]
+fn assert_none64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 9;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+
+#[simplex::test]
+fn assert_none128_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 10;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
+
+    Ok(())
+}
+
+
+#[simplex::test]
+fn assert_none256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+    let flag: u8 = 11;
+
+    fund_script(&context)?;
+
+    let txid_result = spend_script(&context, flag);
+
+    assert!(
+        txid_result.is_err(),
+        "Expected a test to fail but it succeeded"
+    );
 
     Ok(())
 }

From 75aa8fc93920398794e0392e884ef7fab0f1a4cd Mon Sep 17 00:00:00 2001
From: aritkulova <aritkulova.yuliia@gmail.com>
Date: Mon, 25 May 2026 14:14:24 +0300
Subject: [PATCH 2/4] fixed typo

---
 simf/mock/asserts_mock.simf | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/simf/mock/asserts_mock.simf b/simf/mock/asserts_mock.simf
index 33351d6..e7e9bf9 100644
--- a/simf/mock/asserts_mock.simf
+++ b/simf/mock/asserts_mock.simf
@@ -1,46 +1,45 @@
 // todo: switch to function import when available
-
-pub fn assert_eq8(a: u8, b: u8) {
+pub fn assert_eq8(a: u8, b: u8) { // 1
     assert!(jet::eq_8(a, b));
 }
 
-pub fn assert_eq16(a: u16, b: u16) {
+pub fn assert_eq16(a: u16, b: u16) { // 2
     assert!(jet::eq_16(a, b));
 }
 
-pub fn assert_eq32(a: u32, b: u32) {
+pub fn assert_eq32(a: u32, b: u32) { // 3
     assert!(jet::eq_32(a, b));
 }
 
-pub fn assert_eq64(a: u64, b: u64) {
+pub fn assert_eq64(a: u64, b: u64) { // 4
     assert!(jet::eq_64(a, b));
 }
 
-pub fn assert_eq256(a: u256, b: u256) {
+pub fn assert_eq256(a: u256, b: u256) { // 5
     assert!(jet::eq_256(a, b));
 }
 
-pub fn assert_none8(val: Option<u8>) {
+pub fn assert_none8(val: Option<u8>) { // 6
     assert!(is_none::<u8>(val));
 }
 
-pub fn assert_none16(val: Option<u16>) {
+pub fn assert_none16(val: Option<u16>) { // 7
     assert!(is_none::<u16>(val));
 }
 
-pub fn assert_none32(val: Option<u32>) {
+pub fn assert_none32(val: Option<u32>) { // 8
     assert!(is_none::<u32>(val));
 }
 
-pub fn assert_none64(val: Option<u64>) {
+pub fn assert_none64(val: Option<u64>) { // 9
     assert!(is_none::<u64>(val));
 }
 
-pub fn assert_none128(val: Option<u128>) {
+pub fn assert_none128(val: Option<u128>) { // 10
     assert!(is_none::<u128>(val));
 }
 
-pub fn assert_none256(val: Option<u256>) {
+pub fn assert_none256(val: Option<u256>) { // 11
     assert!(is_none::<u256>(val));
 }
 
@@ -72,7 +71,7 @@ fn main() {
         }, false => { 
             let ifTestNextFunction: bool = jet::eq_8(flag, 1);
 
-            match jet::eq_8(flag, 1) {
+            match ifTestNextFunction {
                 true => assert_eq8(1, 2),
                 false => (),
             };

From 10afc40c5acb7de4b2560f0cf91e75a683910b99 Mon Sep 17 00:00:00 2001
From: aritkulova <aritkulova.yuliia@gmail.com>
Date: Mon, 25 May 2026 17:03:11 +0300
Subject: [PATCH 3/4] added helper function to mock; fixed typo

---
 simf/mock/asserts_mock.simf | 50 ++++++++++++-------------------------
 tests/asserts_test.rs       | 22 ++++++++--------
 2 files changed, 27 insertions(+), 45 deletions(-)

diff --git a/simf/mock/asserts_mock.simf b/simf/mock/asserts_mock.simf
index e7e9bf9..f20b8c8 100644
--- a/simf/mock/asserts_mock.simf
+++ b/simf/mock/asserts_mock.simf
@@ -43,9 +43,13 @@ pub fn assert_none256(val: Option<u256>) { // 11
     assert!(is_none::<u256>(val));
 }
 
+fn if_test_this_function(index: u8, flag: u8) -> bool {
+   jet::eq_8(index, flag)
+}
+
 fn main() {
     let flag: u8 = witness::FLAG;
-    let ifHappyPath: bool = jet::eq_8(flag, 0);
+    let ifHappyPath: bool = if_test_this_function(0, flag);
 
     let some_u8: u8 = 255;
     let some_u16: u16 = 65535;
@@ -69,79 +73,57 @@ fn main() {
             assert_none128(None);
             assert_none256(None);
         }, false => { 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 1);
-
-            match ifTestNextFunction {
+            match if_test_this_function(1, flag) {
                 true => assert_eq8(1, 2),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 2);
-
-            match ifTestNextFunction {
+            match if_test_this_function(2, flag) {
                 true => assert_eq16(1, 2),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 3);
-
-            match ifTestNextFunction {
+            match if_test_this_function(3, flag) {
                 true => assert_eq32(1, 2),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 4);
-
-            match ifTestNextFunction {
+            match if_test_this_function(4, flag) {
                 true => assert_eq64(1, 2),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 5);
-
-            match ifTestNextFunction {
+            match if_test_this_function(5, flag) {
                 true => assert_eq256(1, 2),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 6);
-
-            match ifTestNextFunction {
+            match if_test_this_function(6, flag) {
                 true => assert_none8(Some(some_u8)),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 7);
-
-            match ifTestNextFunction {
+            match if_test_this_function(7, flag) {
                 true => assert_none16(Some(some_u16)),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 8);
-
-            match ifTestNextFunction {
+            match if_test_this_function(8, flag) {
                 true => assert_none32(Some(some_u32)),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 9);
-
-            match ifTestNextFunction {
+            match if_test_this_function(9, flag) {
                 true => assert_none64(Some(some_u64)),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 10);
-
-            match ifTestNextFunction {
+            match if_test_this_function(10, flag) {
                 true => assert_none128(Some(some_u128)),
                 false => (),
             };
 
-            let ifTestNextFunction: bool = jet::eq_8(flag, 11);
-
-            match ifTestNextFunction {
+            match if_test_this_function(11, flag) {
                 true => assert_none256(Some(some_u256)),
                 false => (),
             };
diff --git a/tests/asserts_test.rs b/tests/asserts_test.rs
index 75b0722..2822583 100644
--- a/tests/asserts_test.rs
+++ b/tests/asserts_test.rs
@@ -70,7 +70,7 @@ fn assert_eq8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()>
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -86,7 +86,7 @@ fn assert_eq16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()>
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -102,7 +102,7 @@ fn assert_eq32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()>
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -118,7 +118,7 @@ fn assert_eq64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()>
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -134,7 +134,7 @@ fn assert_eq256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -150,7 +150,7 @@ fn assert_none8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -166,7 +166,7 @@ fn assert_none16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<(
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -182,7 +182,7 @@ fn assert_none32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<(
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -198,7 +198,7 @@ fn assert_none64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<(
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -215,7 +215,7 @@ fn assert_none128_unhappy_path(context: simplex::TestContext) -> anyhow::Result<
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())
@@ -232,7 +232,7 @@ fn assert_none256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<
 
     assert!(
         txid_result.is_err(),
-        "Expected a test to fail but it succeeded"
+        "Expected this test to fail but it succeeded"
     );
 
     Ok(())

From 1249363359efe9a9e676a51d8dc24457f17e3207 Mon Sep 17 00:00:00 2001
From: aritkulova <aritkulova.yuliia@gmail.com>
Date: Sat, 30 May 2026 11:00:00 +0300
Subject: [PATCH 4/4] added more specific error check

---
 tests/asserts_test.rs | 35 +++++++++++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/tests/asserts_test.rs b/tests/asserts_test.rs
index 2822583..468340c 100644
--- a/tests/asserts_test.rs
+++ b/tests/asserts_test.rs
@@ -73,6 +73,9 @@ fn assert_eq8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()>
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
@@ -89,6 +92,9 @@ fn assert_eq16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()>
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
@@ -105,6 +111,9 @@ fn assert_eq32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()>
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
@@ -121,6 +130,9 @@ fn assert_eq64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()>
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
@@ -137,6 +149,9 @@ fn assert_eq256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
@@ -153,6 +168,9 @@ fn assert_none8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
@@ -169,6 +187,9 @@ fn assert_none16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<(
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
@@ -185,6 +206,9 @@ fn assert_none32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<(
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
@@ -201,10 +225,12 @@ fn assert_none64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<(
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
-
 #[simplex::test]
 fn assert_none128_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
     let flag: u8 = 10;
@@ -218,10 +244,12 @@ fn assert_none128_unhappy_path(context: simplex::TestContext) -> anyhow::Result<
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }
 
-
 #[simplex::test]
 fn assert_none256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
     let flag: u8 = 11;
@@ -235,5 +263,8 @@ fn assert_none256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<
         "Expected this test to fail but it succeeded"
     );
 
+    let err: String = txid_result.unwrap_err().to_string();
+    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+
     Ok(())
 }