diff --git a/README.md b/README.md
index c6ef5c7..19229ef 100644
--- a/README.md
+++ b/README.md
@@ -6,16 +6,13 @@ This repository contains the standard library for [SimplicityHL](https://github.
 > If you are using the VS Code syntax highlighting extension, you may see errors because the extension does not support modules and imports yet.
 
 ## Dev Info
+
 ### Installation
 
 > Project currently uses Simplex version 0.0.6 from the dev branch.
 
 To compile the project, execute the following command:
 
-```bash
-cargo build
-```
-
 To download simplexup, run:
 
 ```bash
@@ -62,6 +59,12 @@ To run a specific test:
 simplex test test_name
 ```
 
+To run a specific test module:
+
+```bash
+simplex test u8_test
+```
+
 ### Linting
 
 To format the rust files, execute the following command:
diff --git a/simf/asserts_mock.simf b/simf/asserts_mock.simf
deleted file mode 100644
index 32daeb6..0000000
--- a/simf/asserts_mock.simf
+++ /dev/null
@@ -1,102 +0,0 @@
-use crate::lib::asserts::{assert_eq_8, assert_eq_16, assert_eq_32, assert_eq_64, assert_eq_256, assert_none_8, assert_none_16, assert_none_32, assert_none_64,assert_none_128, assert_none_256};
-
-use crate::helper::if_test_this_function;
-
-fn main() {
-    let function_index: u8 = witness::FUNCTION_INDEX;
-
-    let first_arg_u8: Option<u8> = witness::FIRST_ARG_U8;
-    let second_arg_u8: Option<u8> = witness::SECOND_ARG_U8;
-
-    let first_arg_u16: Option<u16> = witness::FIRST_ARG_U16;
-    let second_arg_u16: Option<u16> = witness::SECOND_ARG_U16;
-    
-    let first_arg_u32: Option<u32> = witness::FIRST_ARG_U32;
-    let second_arg_u32: Option<u32> = witness::SECOND_ARG_U32;
-
-    let first_arg_u64: Option<u64> = witness::FIRST_ARG_U64;
-    let second_arg_u64: Option<u64> = witness::SECOND_ARG_U64;
-
-    let first_arg_u128: Option<u128> = witness::FIRST_ARG_U128;
-    let second_arg_u128: Option<u128> = witness::SECOND_ARG_U128;
-
-    let first_arg_u256: Option<u256> = witness::FIRST_ARG_U256;
-    let second_arg_u256: Option<u256> = witness::SECOND_ARG_U256;
-
-    match if_test_this_function(0, function_index) {
-        true => {
-            assert_eq_8(unwrap(first_arg_u8), unwrap(second_arg_u8));
-        },
-        false => (),
-    };
-
-    match if_test_this_function(1, function_index) {
-        true => {
-            assert_eq_16(unwrap(first_arg_u16), unwrap(second_arg_u16));
-        },
-        false => (),
-    };
-
-    match if_test_this_function(2, function_index) {
-        true => {
-            assert_eq_32(unwrap(first_arg_u32), unwrap(second_arg_u32));
-        },
-        false => (),
-    };
-
-    match if_test_this_function(3, function_index) {
-        true => {
-            assert_eq_64(unwrap(first_arg_u64), unwrap(second_arg_u64));
-        },
-        false => (),
-    };
-
-    match if_test_this_function(4, function_index) {
-        true => {
-            assert_eq_256(unwrap(first_arg_u256), unwrap(second_arg_u256));
-        },
-        false => (),
-    };
-
-    match if_test_this_function(5, function_index) {
-        true => {
-            assert_none_8(first_arg_u8);
-        },
-        false => (),
-    };
-
-    match if_test_this_function(6, function_index) {
-        true => {
-            assert_none_16(first_arg_u16);
-        },
-        false => (),
-    };
-
-    match if_test_this_function(7, function_index) {
-        true => {
-            assert_none_32(first_arg_u32);
-        },
-        false => (),
-    };
-
-    match if_test_this_function(8, function_index) {
-        true => {
-            assert_none_64(first_arg_u64);
-        },
-        false => (),
-    };
-
-    match if_test_this_function(9, function_index) {
-        true => {
-            assert_none_128(first_arg_u128);
-        },
-        false => (),
-    };
-
-    match if_test_this_function(10, function_index) {
-        true => {
-            assert_none_256(first_arg_u256);
-        },
-        false => (),
-    };
-}
diff --git a/simf/asserts_test.simf b/simf/asserts_test.simf
new file mode 100644
index 0000000..bfda99e
--- /dev/null
+++ b/simf/asserts_test.simf
@@ -0,0 +1,40 @@
+use crate::lib::asserts::{assert_eq_8, assert_eq_16, assert_eq_32, assert_eq_64, assert_eq_256, assert_none_8, assert_none_16, assert_none_32, assert_none_64,assert_none_128, assert_none_256};
+
+use crate::helper::if_test_this_function;
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let a_u8: Option<u8> = witness::FIRST_ARG_U8;
+    let b_u8: Option<u8> = witness::SECOND_ARG_U8;
+
+    let a_u16: Option<u16> = witness::FIRST_ARG_U16;
+    let b_u16: Option<u16> = witness::SECOND_ARG_U16;
+    
+    let a_u32: Option<u32> = witness::FIRST_ARG_U32;
+    let b_u32: Option<u32> = witness::SECOND_ARG_U32;
+
+    let a_u64: Option<u64> = witness::FIRST_ARG_U64;
+    let b_u64: Option<u64> = witness::SECOND_ARG_U64;
+
+    let a_u128: Option<u128> = witness::FIRST_ARG_U128;
+    let b_u128: Option<u128> = witness::SECOND_ARG_U128;
+
+    let a_u256: Option<u256> = witness::FIRST_ARG_U256;
+    let b_u256: Option<u256> = witness::SECOND_ARG_U256;
+
+    // Assert Eq
+    match if_test_this_function(0, fn_idx) { true => { assert_eq_8(unwrap(a_u8), unwrap(b_u8)); }, false => (), };
+    match if_test_this_function(1, fn_idx) { true => { assert_eq_16(unwrap(a_u16), unwrap(b_u16)); }, false => (), };
+    match if_test_this_function(2, fn_idx) { true => { assert_eq_32(unwrap(a_u32), unwrap(b_u32)); }, false => (), };
+    match if_test_this_function(3, fn_idx) { true => { assert_eq_64(unwrap(a_u64), unwrap(b_u64)); }, false => (), };
+    match if_test_this_function(4, fn_idx) { true => { assert_eq_256(unwrap(a_u256), unwrap(b_u256)); }, false => (), };
+
+    // Assert None
+    match if_test_this_function(5, fn_idx) { true => { assert_none_8(a_u8); }, false => (), };
+    match if_test_this_function(6, fn_idx) { true => { assert_none_16(a_u16); }, false => (), };
+    match if_test_this_function(7, fn_idx) { true => { assert_none_32(a_u32); }, false => (), };
+    match if_test_this_function(8, fn_idx) { true => { assert_none_64(a_u64); }, false => (), };
+    match if_test_this_function(9, fn_idx) { true => { assert_none_128(a_u128); }, false => (), };
+    match if_test_this_function(10, fn_idx) { true => { assert_none_256(a_u256); }, false => (), };
+}
diff --git a/simf/logical_operations_mock.simf b/simf/logical_ops_test.simf
similarity index 92%
rename from simf/logical_operations_mock.simf
rename to simf/logical_ops_test.simf
index e428ec6..45e48e4 100644
--- a/simf/logical_operations_mock.simf
+++ b/simf/logical_ops_test.simf
@@ -2,7 +2,7 @@ use crate::lib::logical_operations::{not, or, and};
 
 fn main() {
    assert!(not(false));
-   assert!(not((not(true))));
+   assert!(not(not(true)));
 
    assert!(or(true, false));
    assert!(or(false, true));
diff --git a/simf/u16_mock.simf b/simf/u16_mock.simf
deleted file mode 100644
index ffe58c0..0000000
--- a/simf/u16_mock.simf
+++ /dev/null
@@ -1,140 +0,0 @@
-use crate::lib::u16::{checked_add_16, safe_add_16, checked_sub_16, safe_sub_16, checked_mul_16, safe_mul_16, checked_div_16, safe_div_16};
-
-use crate::helper::if_test_this_function;
-
-fn main() {
-    let function_index: u8 = witness::FUNCTION_INDEX;
-    let if_test_overflow: bool = witness::IF_TEST_OVERFLOW;
-
-    let first_arg: u16 = witness::FIRST_ARG;
-    let second_arg: u16 = witness::SECOND_ARG;
-    let result: u16 = witness::RESULT;
-
-    // add
-    match if_test_this_function(0, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u16: Option<u16> = checked_add_16(first_arg, second_arg);
-                    assert!(is_none::<u16>(overflowing_u16));
-                },
-                false => {
-                    let fitting_u16: Option<u16> = checked_add_16(first_arg, second_arg);
-                    assert!(jet::eq_16(unwrap(fitting_u16), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(1, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u16: u16 = safe_add_16(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u16: u16 = safe_add_16(first_arg, second_arg);
-                    assert!(jet::eq_16(fitting_u16, result));
-                }
-            }
-        },
-        false => (),
-    };
-   
-    // subtract
-    match if_test_this_function(2, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u16: Option<u16> = checked_sub_16(first_arg, second_arg);
-                    assert!(is_none::<u16>(overflowing_u16));
-                },
-                false => {
-                    let fitting_u16: Option<u16> = checked_sub_16(first_arg, second_arg);
-                    assert!(jet::eq_16(unwrap(fitting_u16), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(3, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u16: u16 = safe_sub_16(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u16: u16 = safe_sub_16(first_arg, second_arg);
-                    assert!(jet::eq_16(fitting_u16, result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    // multiply
-    match if_test_this_function(4, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u16: Option<u16> = checked_mul_16(first_arg, second_arg);
-                    assert!(is_none::<u16>(overflowing_u16));
-                },
-                false => {
-                    let fitting_u16: Option<u16> = checked_mul_16(first_arg, second_arg);
-                    assert!(jet::eq_16(unwrap(fitting_u16), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(5, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u16: u16 = safe_mul_16(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u16: u16 = safe_mul_16(first_arg, second_arg);
-                    assert!(jet::eq_16(fitting_u16, result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    // divide 
-    match if_test_this_function(6, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u16: Option<u16> = checked_div_16(first_arg, second_arg);
-                    assert!(is_none::<u16>(overflowing_u16));
-                },
-                false => {
-                    let fitting_u16: Option<u16> = checked_div_16(first_arg, second_arg);
-                    assert!(jet::eq_16(unwrap(fitting_u16), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(7, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u16: u16 = safe_div_16(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u16: u16 = safe_div_16(first_arg, second_arg);
-                    assert!(jet::eq_16(fitting_u16, result));
-                }
-            }
-        },
-        false => (),
-    };
-}
diff --git a/simf/u16_test.simf b/simf/u16_test.simf
new file mode 100644
index 0000000..d603ec2
--- /dev/null
+++ b/simf/u16_test.simf
@@ -0,0 +1,37 @@
+use crate::lib::u16::{checked_add_16, safe_add_16, checked_sub_16, safe_sub_16, checked_mul_16, safe_mul_16, checked_div_16, safe_div_16};
+
+use crate::helper::if_test_this_function;
+
+// Asserts a `checked_*` result equals the expected Option.
+// `None` encodes the overflow case, `Some(e)` the fitting case, so a single
+// witness value carries both, removing the need for a separate overflow flag.
+fn assert_eq_opt(result: Option<u16>, expected: Option<u16>) {
+    match expected {
+        None => assert!(is_none::<u16>(result)),
+        Some(e: u16) => assert!(jet::eq_16(unwrap(result), e)),
+    }
+}
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let a: u16 = witness::FIRST_ARG;
+    let b: u16 = witness::SECOND_ARG;
+    let expected: Option<u16> = witness::EXPECTED;
+
+    // add
+    match if_test_this_function(0, fn_idx) { true => { assert_eq_opt(checked_add_16(a, b), expected); }, false => (), };
+    match if_test_this_function(1, fn_idx) { true => { assert!(jet::eq_16(safe_add_16(a, b), unwrap(expected))); }, false => (), };
+
+    // sub
+    match if_test_this_function(2, fn_idx) { true => { assert_eq_opt(checked_sub_16(a, b), expected); }, false => (), };
+    match if_test_this_function(3, fn_idx) { true => { assert!(jet::eq_16(safe_sub_16(a, b), unwrap(expected))); }, false => (), };
+
+    // mul
+    match if_test_this_function(4, fn_idx) { true => { assert_eq_opt(checked_mul_16(a, b), expected); }, false => (), };
+    match if_test_this_function(5, fn_idx) { true => { assert!(jet::eq_16(safe_mul_16(a, b), unwrap(expected))); }, false => (), };
+
+    // div
+    match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_16(a, b), expected); }, false => (), };
+    match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_16(safe_div_16(a, b), unwrap(expected))); }, false => (), };
+}
diff --git a/simf/u32_mock.simf b/simf/u32_mock.simf
deleted file mode 100644
index a1ae4b4..0000000
--- a/simf/u32_mock.simf
+++ /dev/null
@@ -1,140 +0,0 @@
-use crate::lib::u32::{checked_add_32, safe_add_32, checked_sub_32, safe_sub_32, checked_mul_32, safe_mul_32, checked_div_32, safe_div_32};
-
-use crate::helper::if_test_this_function;
-
-fn main() {
-    let function_index: u8 = witness::FUNCTION_INDEX;
-    let if_test_overflow: bool = witness::IF_TEST_OVERFLOW;
-
-    let first_arg: u32 = witness::FIRST_ARG;
-    let second_arg: u32 = witness::SECOND_ARG;
-    let result: u32 = witness::RESULT;
-
-    // add
-    match if_test_this_function(0, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u32: Option<u32> = checked_add_32(first_arg, second_arg);
-                    assert!(is_none::<u32>(overflowing_u32));
-                },
-                false => {
-                    let fitting_u32: Option<u32> = checked_add_32(first_arg, second_arg);
-                    assert!(jet::eq_32(unwrap(fitting_u32), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(1, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u32: u32 = safe_add_32(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u32: u32 = safe_add_32(first_arg, second_arg);
-                    assert!(jet::eq_32(fitting_u32, result));
-                }
-            }
-        },
-        false => (),
-    };
-   
-    // subtract
-    match if_test_this_function(2, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u32: Option<u32> = checked_sub_32(first_arg, second_arg);
-                    assert!(is_none::<u32>(overflowing_u32));
-                },
-                false => {
-                    let fitting_u32: Option<u32> = checked_sub_32(first_arg, second_arg);
-                    assert!(jet::eq_32(unwrap(fitting_u32), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(3, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u32: u32 = safe_sub_32(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u32: u32 = safe_sub_32(first_arg, second_arg);
-                    assert!(jet::eq_32(fitting_u32, result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    // multiply
-    match if_test_this_function(4, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u32: Option<u32> = checked_mul_32(first_arg, second_arg);
-                    assert!(is_none::<u32>(overflowing_u32));
-                },
-                false => {
-                    let fitting_u32: Option<u32> = checked_mul_32(first_arg, second_arg);
-                    assert!(jet::eq_32(unwrap(fitting_u32), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(5, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u32: u32 = safe_mul_32(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u32: u32 = safe_mul_32(first_arg, second_arg);
-                    assert!(jet::eq_32(fitting_u32, result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    // divide 
-    match if_test_this_function(6, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u32: Option<u32> = checked_div_32(first_arg, second_arg);
-                    assert!(is_none::<u32>(overflowing_u32));
-                },
-                false => {
-                    let fitting_u32: Option<u32> = checked_div_32(first_arg, second_arg);
-                    assert!(jet::eq_32(unwrap(fitting_u32), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(7, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u32: u32 = safe_div_32(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u32: u32 = safe_div_32(first_arg, second_arg);
-                    assert!(jet::eq_32(fitting_u32, result));
-                }
-            }
-        },
-        false => (),
-    };
-}
diff --git a/simf/u32_test.simf b/simf/u32_test.simf
new file mode 100644
index 0000000..f5654cc
--- /dev/null
+++ b/simf/u32_test.simf
@@ -0,0 +1,34 @@
+use crate::lib::u32::{checked_add_32, safe_add_32, checked_sub_32, safe_sub_32, checked_mul_32, safe_mul_32, checked_div_32, safe_div_32};
+
+use crate::helper::if_test_this_function;
+
+fn assert_eq_opt(result: Option<u32>, expected: Option<u32>) {
+    match expected {
+        None => assert!(is_none::<u32>(result)),
+        Some(e: u32) => assert!(jet::eq_32(unwrap(result), e)),
+    }
+}
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let a: u32 = witness::FIRST_ARG;
+    let b: u32 = witness::SECOND_ARG;
+    let expected: Option<u32> = witness::EXPECTED;
+
+    // add
+    match if_test_this_function(0, fn_idx) { true => { assert_eq_opt(checked_add_32(a, b), expected); }, false => (), };
+    match if_test_this_function(1, fn_idx) { true => { assert!(jet::eq_32(safe_add_32(a, b), unwrap(expected))); }, false => (), };
+
+    // sub
+    match if_test_this_function(2, fn_idx) { true => { assert_eq_opt(checked_sub_32(a, b), expected); }, false => (), };
+    match if_test_this_function(3, fn_idx) { true => { assert!(jet::eq_32(safe_sub_32(a, b), unwrap(expected))); }, false => (), };
+
+    // mul
+    match if_test_this_function(4, fn_idx) { true => { assert_eq_opt(checked_mul_32(a, b), expected); }, false => (), };
+    match if_test_this_function(5, fn_idx) { true => { assert!(jet::eq_32(safe_mul_32(a, b), unwrap(expected))); }, false => (), };
+
+    // div
+    match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_32(a, b), expected); }, false => (), };
+    match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_32(safe_div_32(a, b), unwrap(expected))); }, false => (), };
+}
diff --git a/simf/u64_mock.simf b/simf/u64_mock.simf
deleted file mode 100644
index 5f20922..0000000
--- a/simf/u64_mock.simf
+++ /dev/null
@@ -1,140 +0,0 @@
-use crate::lib::u64::{checked_add_64, safe_add_64, checked_sub_64, safe_sub_64, checked_mul_64, safe_mul_64, checked_div_64, safe_div_64};
-
-use crate::helper::if_test_this_function;
-
-fn main() {
-    let function_index: u8 = witness::FUNCTION_INDEX;
-    let if_test_overflow: bool = witness::IF_TEST_OVERFLOW;
-
-    let first_arg: u64 = witness::FIRST_ARG;
-    let second_arg: u64 = witness::SECOND_ARG;
-    let result: u64 = witness::RESULT;
-
-    // add
-    match if_test_this_function(0, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u64: Option<u64> = checked_add_64(first_arg, second_arg);
-                    assert!(is_none::<u64>(overflowing_u64));
-                },
-                false => {
-                    let fitting_u64: Option<u64> = checked_add_64(first_arg, second_arg);
-                    assert!(jet::eq_64(unwrap(fitting_u64), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(1, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u64: u64 = safe_add_64(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u64: u64 = safe_add_64(first_arg, second_arg);
-                    assert!(jet::eq_64(fitting_u64, result));
-                }
-            }
-        },
-        false => (),
-    };
-   
-    // subtract
-    match if_test_this_function(2, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u64: Option<u64> = checked_sub_64(first_arg, second_arg);
-                    assert!(is_none::<u64>(overflowing_u64));
-                },
-                false => {
-                    let fitting_u64: Option<u64> = checked_sub_64(first_arg, second_arg);
-                    assert!(jet::eq_64(unwrap(fitting_u64), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(3, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u64: u64 = safe_sub_64(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u64: u64 = safe_sub_64(first_arg, second_arg);
-                    assert!(jet::eq_64(fitting_u64, result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    // multiply
-    match if_test_this_function(4, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u64: Option<u64> = checked_mul_64(first_arg, second_arg);
-                    assert!(is_none::<u64>(overflowing_u64));
-                },
-                false => {
-                    let fitting_u64: Option<u64> = checked_mul_64(first_arg, second_arg);
-                    assert!(jet::eq_64(unwrap(fitting_u64), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(5, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u64: u64 = safe_mul_64(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u64: u64 = safe_mul_64(first_arg, second_arg);
-                    assert!(jet::eq_64(fitting_u64, result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    // divide 
-    match if_test_this_function(6, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u64: Option<u64> = checked_div_64(first_arg, second_arg);
-                    assert!(is_none::<u64>(overflowing_u64));
-                },
-                false => {
-                    let fitting_u64: Option<u64> = checked_div_64(first_arg, second_arg);
-                    assert!(jet::eq_64(unwrap(fitting_u64), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(7, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u64: u64 = safe_div_64(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u64: u64 = safe_div_64(first_arg, second_arg);
-                    assert!(jet::eq_64(fitting_u64, result));
-                }
-            }
-        },
-        false => (),
-    };
-}
diff --git a/simf/u64_test.simf b/simf/u64_test.simf
new file mode 100644
index 0000000..8d01e15
--- /dev/null
+++ b/simf/u64_test.simf
@@ -0,0 +1,34 @@
+use crate::lib::u64::{checked_add_64, safe_add_64, checked_sub_64, safe_sub_64, checked_mul_64, safe_mul_64, checked_div_64, safe_div_64};
+
+use crate::helper::if_test_this_function;
+
+fn assert_eq_opt(result: Option<u64>, expected: Option<u64>) {
+    match expected {
+        None => assert!(is_none::<u64>(result)),
+        Some(e: u64) => assert!(jet::eq_64(unwrap(result), e)),
+    }
+}
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let a: u64 = witness::FIRST_ARG;
+    let b: u64 = witness::SECOND_ARG;
+    let expected: Option<u64> = witness::EXPECTED;
+
+    match if_test_this_function(0, fn_idx) { true => { assert_eq_opt(checked_add_64(a, b), expected); }, false => (), };
+    match if_test_this_function(1, fn_idx) { true => { assert!(jet::eq_64(safe_add_64(a, b), unwrap(expected))); }, false => (), };
+
+    // sub
+    match if_test_this_function(2, fn_idx) { true => { assert_eq_opt(checked_sub_64(a, b), expected); }, false => (), };
+    match if_test_this_function(3, fn_idx) { true => { assert!(jet::eq_64(safe_sub_64(a, b), unwrap(expected))); }, false => (), };
+
+    // mul
+    match if_test_this_function(4, fn_idx) { true => { assert_eq_opt(checked_mul_64(a, b), expected); }, false => (), };
+    match if_test_this_function(5, fn_idx) { true => { assert!(jet::eq_64(safe_mul_64(a, b), unwrap(expected))); }, false => (), };
+
+    // div
+    match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_64(a, b), expected); }, false => (), };
+    match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_64(safe_div_64(a, b), unwrap(expected))); }, false => (), };
+
+}
diff --git a/simf/u8_mock.simf b/simf/u8_mock.simf
deleted file mode 100644
index d45fcd3..0000000
--- a/simf/u8_mock.simf
+++ /dev/null
@@ -1,140 +0,0 @@
-use crate::lib::u8::{checked_add_8, safe_add_8, checked_sub_8, safe_sub_8, checked_mul_8, safe_mul_8, checked_div_8, safe_div_8};
-
-use crate::helper::if_test_this_function;
-
-fn main() {
-    let function_index: u8 = witness::FUNCTION_INDEX;
-    let if_test_overflow: bool = witness::IF_TEST_OVERFLOW;
-
-    let first_arg: u8 = witness::FIRST_ARG;
-    let second_arg: u8 = witness::SECOND_ARG;
-    let result: u8 = witness::RESULT;
-
-    // add
-    match if_test_this_function(0, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u8: Option<u8> = checked_add_8(first_arg, second_arg);
-                    assert!(is_none::<u8>(overflowing_u8));
-                },
-                false => {
-                    let fitting_u8: Option<u8> = checked_add_8(first_arg, second_arg);
-                    assert!(jet::eq_8(unwrap(fitting_u8), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(1, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u8: u8 = safe_add_8(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u8: u8 = safe_add_8(first_arg, second_arg);
-                    assert!(jet::eq_8(fitting_u8, result));
-                }
-            }
-        },
-        false => (),
-    };
-   
-    // subtract
-    match if_test_this_function(2, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u8: Option<u8> = checked_sub_8(first_arg, second_arg);
-                    assert!(is_none::<u8>(overflowing_u8));
-                },
-                false => {
-                    let fitting_u8: Option<u8> = checked_sub_8(first_arg, second_arg);
-                    assert!(jet::eq_8(unwrap(fitting_u8), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(3, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u8: u8 = safe_sub_8(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u8: u8 = safe_sub_8(first_arg, second_arg);
-                    assert!(jet::eq_8(fitting_u8, result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    // multiply
-    match if_test_this_function(4, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u8: Option<u8> = checked_mul_8(first_arg, second_arg);
-                    assert!(is_none::<u8>(overflowing_u8));
-                },
-                false => {
-                    let fitting_u8: Option<u8> = checked_mul_8(first_arg, second_arg);
-                    assert!(jet::eq_8(unwrap(fitting_u8), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(5, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u8: u8 = safe_mul_8(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u8: u8 = safe_mul_8(first_arg, second_arg);
-                    assert!(jet::eq_8(fitting_u8, result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    // divide 
-    match if_test_this_function(6, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u8: Option<u8> = checked_div_8(first_arg, second_arg);
-                    assert!(is_none::<u8>(overflowing_u8));
-                },
-                false => {
-                    let fitting_u8: Option<u8> = checked_div_8(first_arg, second_arg);
-                    assert!(jet::eq_8(unwrap(fitting_u8), result));
-                }
-            }
-        },
-        false => (),
-    };
-
-    match if_test_this_function(7, function_index) {
-        true => {
-            match if_test_overflow {
-                true => {
-                    let overflowing_u8: u8 = safe_div_8(first_arg, second_arg);
-                },
-                false => {
-                    let fitting_u8: u8 = safe_div_8(first_arg, second_arg);
-                    assert!(jet::eq_8(fitting_u8, result));
-                }
-            }
-        },
-        false => (),
-    };
-}
diff --git a/simf/u8_test.simf b/simf/u8_test.simf
new file mode 100644
index 0000000..40fa44e
--- /dev/null
+++ b/simf/u8_test.simf
@@ -0,0 +1,37 @@
+use crate::lib::u8::{checked_add_8, safe_add_8, checked_sub_8, safe_sub_8, checked_mul_8, safe_mul_8, checked_div_8, safe_div_8};
+
+use crate::helper::if_test_this_function;
+
+// Asserts a `checked_*` result equals the expected Option.
+// `None` encodes the overflow case, `Some(e)` the fitting case, so a single
+// witness value carries both, removing the need for a separate overflow flag.
+fn assert_eq_opt(result: Option<u8>, expected: Option<u8>) {
+    match expected {
+        None => assert!(is_none::<u8>(result)),
+        Some(e: u8) => assert!(jet::eq_8(unwrap(result), e)),
+    }
+}
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let a: u8 = witness::FIRST_ARG;
+    let b: u8 = witness::SECOND_ARG;
+    let expected: Option<u8> = witness::EXPECTED;
+
+    // add
+    match if_test_this_function(0, fn_idx) { true => { assert_eq_opt(checked_add_8(a, b), expected); }, false => (), };
+    match if_test_this_function(1, fn_idx) { true => { assert!(jet::eq_8(safe_add_8(a, b), unwrap(expected))); }, false => (), };
+
+    // sub
+    match if_test_this_function(2, fn_idx) { true => { assert_eq_opt(checked_sub_8(a, b), expected); }, false => (), };
+    match if_test_this_function(3, fn_idx) { true => { assert!(jet::eq_8(safe_sub_8(a, b), unwrap(expected))); }, false => (), };
+
+    // mul
+    match if_test_this_function(4, fn_idx) { true => { assert_eq_opt(checked_mul_8(a, b), expected); }, false => (), };
+    match if_test_this_function(5, fn_idx) { true => { assert!(jet::eq_8(safe_mul_8(a, b), unwrap(expected))); }, false => (), };
+
+    // div
+    match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_8(a, b), expected); }, false => (), };
+    match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_8(safe_div_8(a, b), unwrap(expected))); }, false => (), };
+}
diff --git a/tests/asserts_test.rs b/tests/asserts_test.rs
index a13a988..c7dc178 100644
--- a/tests/asserts_test.rs
+++ b/tests/asserts_test.rs
@@ -1,16 +1,16 @@
-use simplex::simplicityhl::elements::Script;
+mod common;
 
-use simplex::transaction::{FinalTransaction, PartialInput, ProgramInput, RequiredSignature};
+use rand::Rng;
 
-use simplicityhl_std::artifacts::asserts_mock::AssertsMockProgram;
-use simplicityhl_std::artifacts::asserts_mock::derived_asserts_mock::{
-    AssertsMockArguments, AssertsMockWitness,
-};
-
-mod helper;
+use common::{Expect, run};
 
-use crate::helper::{cast_to_bool, generate_uints_in_one_range};
+use simplicityhl_std::artifacts::asserts_test::AssertsTestProgram;
+use simplicityhl_std::artifacts::asserts_test::derived_asserts_test::{
+    AssertsTestArguments, AssertsTestWitness,
+};
 
+// Dispatch indices — must match the `if_test_this_function(N, ..)` arms in
+// simf/asserts_test.simf.
 enum FunctionToTest {
     AssertEq8,
     AssertEq16,
@@ -32,42 +32,36 @@ const DEFAULT_SOME_U64: Option<u64> = Some(0);
 const DEFAULT_SOME_U128: Option<u128> = Some(0);
 const DEFAULT_SOME_U256: Option<[u8; 32]> = Some([0; 32]);
 
-pub enum IfTestSameValues {
-    DifferentValues,
-    SameValues,
+fn program() -> AssertsTestProgram {
+    AssertsTestProgram::new(AssertsTestArguments {})
 }
-pub enum IfTestNoneValue {
-    NotNoneValue,
-    NoneValue,
-}
-
-fn get_asserts_test_script(context: &simplex::TestContext) -> (AssertsMockProgram, Script) {
-    let arguments = AssertsMockArguments {};
 
-    let asserts_program = AssertsMockProgram::new(arguments);
+/// Returns two values in `[min, max]` that are equal when `same`, distinct otherwise.
+pub fn generate_uints_in_one_range(same: bool, min_val: u128, max_val: u128) -> (u128, u128) {
+    let some_u = rand::thread_rng().gen_range(min_val..=max_val);
 
-    let asserts_script = asserts_program.get_script_pubkey(context.get_network());
-
-    (asserts_program, asserts_script)
-}
+    if same {
+        return (some_u, some_u);
+    }
 
-fn fund_script(context: &simplex::TestContext) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
+    assert!(
+        min_val != max_val,
+        "cannot generate distinct values in a single-value range"
+    );
 
-    let (_, asserts_script) = get_asserts_test_script(context);
+    let mut other_u = rand::thread_rng().gen_range(min_val..=max_val);
 
-    let tx_receipt = signer.send(asserts_script.clone(), 50)?;
-    println!("Broadcast: {}", tx_receipt);
+    while other_u == some_u {
+        other_u = rand::thread_rng().gen_range(min_val..=max_val);
+    }
 
-    Ok(())
+    (some_u, other_u)
 }
 
-fn generate_test_witness(
-    function_index: FunctionToTest,
-    if_same_values: bool,
-    if_none_value: bool,
-) -> AssertsMockWitness {
-    let mut witness: AssertsMockWitness = AssertsMockWitness {
+/// Builds the witness for one assert call. `same` controls the two `assert_eq`
+/// args; `none` makes the single `assert_none` arg `None`.
+fn build_witness(function: FunctionToTest, same: bool, none: bool) -> AssertsTestWitness {
+    let mut witness = AssertsTestWitness {
         function_index: 0,
         first_arg_u8: DEFAULT_SOME_U8,
         second_arg_u8: DEFAULT_SOME_U8,
@@ -83,500 +77,317 @@ fn generate_test_witness(
         second_arg_u256: DEFAULT_SOME_U256,
     };
 
-    match function_index {
+    match function {
         FunctionToTest::AssertEq8 => {
-            let (first_arg, second_arg) =
-                generate_uints_in_one_range(if_same_values, 0, u8::MAX as u128);
-
-            (witness.first_arg_u8, witness.second_arg_u8) =
-                (Some(first_arg as u8), Some(second_arg as u8));
+            let (a, b) = generate_uints_in_one_range(same, 0, u8::MAX as u128);
+            (witness.first_arg_u8, witness.second_arg_u8) = (Some(a as u8), Some(b as u8));
         }
         FunctionToTest::AssertEq16 => {
-            let (first_arg, second_arg) =
-                generate_uints_in_one_range(if_same_values, 0, u16::MAX as u128);
-
-            (witness.first_arg_u16, witness.second_arg_u16) =
-                (Some(first_arg as u16), Some(second_arg as u16));
+            let (a, b) = generate_uints_in_one_range(same, 0, u16::MAX as u128);
+            (witness.first_arg_u16, witness.second_arg_u16) = (Some(a as u16), Some(b as u16));
         }
         FunctionToTest::AssertEq32 => {
-            let (first_arg, second_arg) =
-                generate_uints_in_one_range(if_same_values, 0, u32::MAX as u128);
-
-            (witness.first_arg_u32, witness.second_arg_u32) =
-                (Some(first_arg as u32), Some(second_arg as u32));
+            let (a, b) = generate_uints_in_one_range(same, 0, u32::MAX as u128);
+            (witness.first_arg_u32, witness.second_arg_u32) = (Some(a as u32), Some(b as u32));
         }
         FunctionToTest::AssertEq64 => {
-            let (first_arg, second_arg) =
-                generate_uints_in_one_range(if_same_values, 0, u64::MAX as u128);
-
-            (witness.first_arg_u64, witness.second_arg_u64) =
-                (Some(first_arg as u64), Some(second_arg as u64));
+            let (a, b) = generate_uints_in_one_range(same, 0, u64::MAX as u128);
+            (witness.first_arg_u64, witness.second_arg_u64) = (Some(a as u64), Some(b as u64));
         }
         FunctionToTest::AssertEq256 => {
-            let (first_arg, second_arg) =
-                generate_uints_in_one_range(if_same_values, 0, u8::MAX as u128);
-
+            let (a, b) = generate_uints_in_one_range(same, 0, u8::MAX as u128);
             (witness.first_arg_u256, witness.second_arg_u256) =
-                (Some([first_arg as u8; 32]), Some([second_arg as u8; 32]));
+                (Some([a as u8; 32]), Some([b as u8; 32]));
         }
         FunctionToTest::AssertNone8 => {
-            if if_none_value {
+            if none {
                 witness.first_arg_u8 = None;
-            };
+            }
         }
         FunctionToTest::AssertNone16 => {
-            if if_none_value {
+            if none {
                 witness.first_arg_u16 = None;
-            };
+            }
         }
         FunctionToTest::AssertNone32 => {
-            if if_none_value {
+            if none {
                 witness.first_arg_u32 = None;
-            };
+            }
         }
         FunctionToTest::AssertNone64 => {
-            if if_none_value {
+            if none {
                 witness.first_arg_u64 = None;
-            };
+            }
         }
         FunctionToTest::AssertNone128 => {
-            if if_none_value {
+            if none {
                 witness.first_arg_u128 = None;
-            };
+            }
         }
         FunctionToTest::AssertNone256 => {
-            if if_none_value {
+            if none {
                 witness.first_arg_u256 = None;
-            };
+            }
         }
     }
 
-    witness.function_index = function_index as u8;
+    witness.function_index = function as u8;
     witness
 }
 
-fn spend_script(
+fn run_assert(
     context: &simplex::TestContext,
-    function_index: FunctionToTest,
-    if_same_values: IfTestSameValues,
-    if_none_value: IfTestNoneValue,
+    function: FunctionToTest,
+    same: bool,
+    none: bool,
+    expect: Expect,
 ) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-    let provider = context.get_default_provider();
-
-    let (asserts_program, asserts_script) = get_asserts_test_script(context);
-
-    let asserts_utxos = provider.fetch_scripthash_utxos(&asserts_script)?;
-
-    let mut ft = FinalTransaction::new();
-
-    let witness: AssertsMockWitness = generate_test_witness(
-        function_index,
-        cast_to_bool(if_same_values as u8),
-        cast_to_bool(if_none_value as u8),
-    );
-
-    ft.add_program_input(
-        PartialInput::new(asserts_utxos[0].clone()),
-        ProgramInput::new(
-            Box::new(asserts_program.as_ref().clone()),
-            Box::new(witness.clone()),
-        ),
-        RequiredSignature::None,
-    );
-
-    let tx_receipt = signer.broadcast(&ft)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-#[simplex::test]
-fn assert_eq_8_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::AssertEq8,
-        IfTestSameValues::SameValues,
-        IfTestNoneValue::NotNoneValue,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn assert_eq_8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertEq8,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "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_eq_16_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::AssertEq16,
-        IfTestSameValues::SameValues,
-        IfTestNoneValue::NotNoneValue,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn assert_eq_16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertEq16,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "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_eq_32_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::AssertEq32,
-        IfTestSameValues::SameValues,
-        IfTestNoneValue::NotNoneValue,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn assert_eq_32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertEq32,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "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_eq_64_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::AssertEq64,
-        IfTestSameValues::SameValues,
-        IfTestNoneValue::NotNoneValue,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn assert_eq_64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertEq64,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "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_eq_256_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::AssertEq256,
-        IfTestSameValues::SameValues,
-        IfTestNoneValue::NotNoneValue,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn assert_eq_256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertEq256,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "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_none_8_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::AssertNone8,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NoneValue,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn assert_none_8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertNone8,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "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_none_16_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    spend_script(
-        &context,
-        FunctionToTest::AssertNone16,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NoneValue,
-    )?;
-
-    Ok(())
+    run(
+        context,
+        program(),
+        build_witness(function, same, none),
+        expect,
+    )
 }
 
-#[simplex::test]
-fn assert_none_16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertNone16,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "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_none_32_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    spend_script(
-        &context,
-        FunctionToTest::AssertNone32,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NoneValue,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn assert_none_32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertNone32,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "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(())
-}
+mod asserts_test {
+    use super::*;
 
-#[simplex::test]
-fn assert_none_64_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-
-    spend_script(
-        &context,
-        FunctionToTest::AssertNone64,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NoneValue,
-    )?;
-
-    Ok(())
-}
+    // ---------- assert_eq: happy = equal args, unhappy = distinct args ----------
+    #[simplex::test]
+    fn assert_eq_8_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(&context, FunctionToTest::AssertEq8, true, false, Expect::Ok)
+    }
 
-#[simplex::test]
-fn assert_none_64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
+    #[simplex::test]
+    fn assert_eq_8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertEq8,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertNone64,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
+    #[simplex::test]
+    fn assert_eq_16_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertEq16,
+            true,
+            false,
+            Expect::Ok,
+        )
+    }
 
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
+    #[simplex::test]
+    fn assert_eq_16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertEq16,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-    let err: String = txid_result.unwrap_err().to_string();
-    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+    #[simplex::test]
+    fn assert_eq_32_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertEq32,
+            true,
+            false,
+            Expect::Ok,
+        )
+    }
 
-    Ok(())
-}
+    #[simplex::test]
+    fn assert_eq_32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertEq32,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-#[simplex::test]
-fn assert_none_128_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
+    #[simplex::test]
+    fn assert_eq_64_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertEq64,
+            true,
+            false,
+            Expect::Ok,
+        )
+    }
 
-    spend_script(
-        &context,
-        FunctionToTest::AssertNone128,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NoneValue,
-    )?;
+    #[simplex::test]
+    fn assert_eq_64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertEq64,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-    Ok(())
-}
+    #[simplex::test]
+    fn assert_eq_256_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertEq256,
+            true,
+            false,
+            Expect::Ok,
+        )
+    }
 
-#[simplex::test]
-fn assert_none_128_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
+    #[simplex::test]
+    fn assert_eq_256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertEq256,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertNone128,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
+    // ---------- assert_none: happy = None arg, unhappy = Some arg ----------
+    #[simplex::test]
+    fn assert_none_8_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone8,
+            false,
+            true,
+            Expect::Ok,
+        )
+    }
 
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
+    #[simplex::test]
+    fn assert_none_8_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone8,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-    let err: String = txid_result.unwrap_err().to_string();
-    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+    #[simplex::test]
+    fn assert_none_16_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone16,
+            false,
+            true,
+            Expect::Ok,
+        )
+    }
 
-    Ok(())
-}
+    #[simplex::test]
+    fn assert_none_16_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone16,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-#[simplex::test]
-fn assert_none_256_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
+    #[simplex::test]
+    fn assert_none_32_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone32,
+            false,
+            true,
+            Expect::Ok,
+        )
+    }
 
-    spend_script(
-        &context,
-        FunctionToTest::AssertNone256,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NoneValue,
-    )?;
+    #[simplex::test]
+    fn assert_none_32_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone32,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-    Ok(())
-}
+    #[simplex::test]
+    fn assert_none_64_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone64,
+            false,
+            true,
+            Expect::Ok,
+        )
+    }
 
-#[simplex::test]
-fn assert_none_256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
+    #[simplex::test]
+    fn assert_none_64_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone64,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::AssertNone256,
-        IfTestSameValues::DifferentValues,
-        IfTestNoneValue::NotNoneValue,
-    );
+    #[simplex::test]
+    fn assert_none_128_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone128,
+            false,
+            true,
+            Expect::Ok,
+        )
+    }
 
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
+    #[simplex::test]
+    fn assert_none_128_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone128,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 
-    let err: String = txid_result.unwrap_err().to_string();
-    assert_eq!(err, "Failed to prune program: Jet failed during execution");
+    #[simplex::test]
+    fn assert_none_256_happy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone256,
+            false,
+            true,
+            Expect::Ok,
+        )
+    }
 
-    Ok(())
+    #[simplex::test]
+    fn assert_none_256_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> {
+        run_assert(
+            &context,
+            FunctionToTest::AssertNone256,
+            false,
+            false,
+            Expect::AssertFailed,
+        )
+    }
 }
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
new file mode 100644
index 0000000..6e2fb5e
--- /dev/null
+++ b/tests/common/mod.rs
@@ -0,0 +1,97 @@
+// Each `tests/*.rs` is a separate crate that mounts this module but uses only
+// part of it, so per-crate dead-code analysis would warn about the rest.
+#![allow(dead_code)]
+
+use simplex::program::{Program, WitnessTrait};
+use simplex::simplicityhl::elements::Script;
+use simplex::transaction::{FinalTransaction, PartialInput, ProgramInput, RequiredSignature};
+
+pub mod uint;
+
+// ---------------------------------------------------------------------------
+// Spend plumbing (shared by every test, of every category)
+// ---------------------------------------------------------------------------
+
+#[derive(Clone, Copy)]
+pub enum Expect {
+    /// The spend succeeds.
+    Ok,
+    /// A failed `assert!` in the contract — the assertion jet fails.
+    AssertFailed,
+    /// Execution reached a pruned branch (e.g. `unwrap(None)`, a `safe_*` overflow).
+    PrunedBranch,
+}
+
+impl Expect {
+    /// The exact broadcast error message for a failing expectation (`None` for `Ok`).
+    fn error_message(self) -> Option<&'static str> {
+        match self {
+            Expect::Ok => None,
+            Expect::AssertFailed => Some("Failed to prune program: Jet failed during execution"),
+            Expect::PrunedBranch => {
+                Some("Failed to prune program: Execution reached a pruned branch")
+            }
+        }
+    }
+}
+
+/// Send sats to the program's script so it has a UTXO to spend.
+pub fn fund(
+    context: &simplex::TestContext,
+    program: &impl AsRef<Program>,
+) -> anyhow::Result<Script> {
+    let script = program.as_ref().get_script_pubkey(context.get_network());
+    context.get_default_signer().send(script.clone(), 50)?;
+    Ok(script)
+}
+
+/// Spend the funded UTXO with `witness`. Returns the broadcast result.
+pub fn spend<W>(
+    context: &simplex::TestContext,
+    program: &impl AsRef<Program>,
+    script: &Script,
+    witness: W,
+) -> anyhow::Result<String>
+where
+    W: WitnessTrait + 'static,
+{
+    let utxos = context
+        .get_default_provider()
+        .fetch_scripthash_utxos(script)?;
+
+    let mut ft = FinalTransaction::new();
+    ft.add_program_input(
+        PartialInput::new(utxos[0].clone()),
+        ProgramInput::new(Box::new(program.as_ref().clone()), Box::new(witness)),
+        RequiredSignature::None,
+    );
+
+    Ok(context.get_default_signer().broadcast(&ft)?.to_string())
+}
+
+/// Fund + spend + assert the outcome, in one call.
+pub fn run<W>(
+    context: &simplex::TestContext,
+    program: impl AsRef<Program>,
+    witness: W,
+    expect: Expect,
+) -> anyhow::Result<()>
+where
+    W: WitnessTrait + 'static,
+{
+    let script = fund(context, &program)?;
+    let result = spend(context, &program, &script, witness);
+
+    match expect.error_message() {
+        None => {
+            result?;
+        }
+        Some(expected) => {
+            let err = result
+                .expect_err("expected the spend to fail, but it succeeded")
+                .to_string();
+            assert!(err.contains(expected));
+        }
+    }
+    Ok(())
+}
diff --git a/tests/common/uint.rs b/tests/common/uint.rs
new file mode 100644
index 0000000..15ea9bf
--- /dev/null
+++ b/tests/common/uint.rs
@@ -0,0 +1,271 @@
+// Each `tests/*.rs` is a separate crate that mounts this module but uses only
+// part of it, so per-crate dead-code analysis would warn about the rest.
+#![allow(dead_code)]
+
+use std::ops::{Add, Div, Mul, Sub};
+
+use rand::Rng;
+use rand::distributions::uniform::SampleUniform;
+
+use simplex::program::{Program, WitnessTrait};
+
+use super::{Expect, run};
+
+/// Dispatch indices for the operations that exist for every unsigned width.
+/// These map 1:1 onto the `if_test_this_function(N, ..)` arms in each width's
+/// `*_test.simf`.
+pub enum CommonOp {
+    CheckedAdd,
+    SafeAdd,
+    CheckedSub,
+    SafeSub,
+    CheckedMul,
+    SafeMul,
+    CheckedDiv,
+    SafeDiv,
+}
+
+/// Width-specific operations number their dispatch indices from here.
+/// Slots 0..192 are reserved for common ops; 192..256 for per-width extras.
+pub const CUSTOM_BASE: u8 = 192;
+
+/// Everything the generic scenarios need to know about a width: its program /
+/// witness types, a few numeric bounds, and how to fill the witness.
+/// Implementing this is the only per-width code for the common operations.
+pub trait TestUint:
+    Copy
+    + Ord
+    + SampleUniform
+    + Add<Output = Self>
+    + Sub<Output = Self>
+    + Mul<Output = Self>
+    + Div<Output = Self>
+{
+    type Program: AsRef<Program>;
+    type Witness: WitnessTrait + 'static;
+
+    const ZERO: Self;
+    const ONE: Self;
+    const MAX: Self;
+    /// `MAX / 2`; two values up to this can be added without overflowing.
+    const HALF_MAX: Self;
+    /// `2^(bits/2)`; two values below this can be multiplied without overflowing.
+    const MUL_BOUND: Self;
+
+    fn program() -> Self::Program;
+    fn witness(op: u8, a: Self, b: Self, expected: Option<Self>) -> Self::Witness;
+}
+
+#[inline]
+fn op(o: CommonOp) -> u8 {
+    o as u8
+}
+
+// add
+pub fn checked_add_fitting<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::HALF_MAX);
+    let b = rand::thread_rng().gen_range(T::ZERO..=T::HALF_MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::CheckedAdd), a, b, Some(a + b)),
+        Expect::Ok,
+    )
+}
+
+pub fn checked_add_overflow<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let b = rand::thread_rng().gen_range(T::ONE..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::CheckedAdd), T::MAX, b, None),
+        Expect::Ok,
+    )
+}
+
+pub fn safe_add_fitting<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::HALF_MAX);
+    let b = rand::thread_rng().gen_range(T::ZERO..=T::HALF_MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::SafeAdd), a, b, Some(a + b)),
+        Expect::Ok,
+    )
+}
+
+pub fn safe_add_overflow<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let b = rand::thread_rng().gen_range(T::ONE..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::SafeAdd), T::MAX, b, None),
+        Expect::PrunedBranch,
+    )
+}
+
+// sub
+pub fn checked_sub_fitting<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::MAX);
+    let b = rand::thread_rng().gen_range(T::ZERO..=a);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::CheckedSub), a, b, Some(a - b)),
+        Expect::Ok,
+    )
+}
+
+pub fn checked_sub_overflow<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::MAX - T::ONE);
+    let b = rand::thread_rng().gen_range(a + T::ONE..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::CheckedSub), a, b, None),
+        Expect::Ok,
+    )
+}
+
+pub fn safe_sub_fitting<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::MAX);
+    let b = rand::thread_rng().gen_range(T::ZERO..=a);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::SafeSub), a, b, Some(a - b)),
+        Expect::Ok,
+    )
+}
+
+pub fn safe_sub_overflow<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::MAX - T::ONE);
+    let b = rand::thread_rng().gen_range(a + T::ONE..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::SafeSub), a, b, None),
+        Expect::PrunedBranch,
+    )
+}
+
+// mul
+pub fn checked_mul_fitting<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..T::MUL_BOUND);
+    let b = rand::thread_rng().gen_range(T::ZERO..T::MUL_BOUND);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::CheckedMul), a, b, Some(a * b)),
+        Expect::Ok,
+    )
+}
+
+pub fn checked_mul_overflow<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let two = T::ONE + T::ONE;
+    let b = rand::thread_rng().gen_range(two..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::CheckedMul), T::MAX, b, None),
+        Expect::Ok,
+    )
+}
+
+pub fn safe_mul_fitting<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..T::MUL_BOUND);
+    let b = rand::thread_rng().gen_range(T::ZERO..T::MUL_BOUND);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::SafeMul), a, b, Some(a * b)),
+        Expect::Ok,
+    )
+}
+
+pub fn safe_mul_overflow<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let two = T::ONE + T::ONE;
+    let b = rand::thread_rng().gen_range(two..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::SafeMul), T::MAX, b, None),
+        Expect::PrunedBranch,
+    )
+}
+
+// div
+pub fn checked_div_fitting<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::MAX);
+    let b = rand::thread_rng().gen_range(T::ONE..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::CheckedDiv), a, b, Some(a / b)),
+        Expect::Ok,
+    )
+}
+
+pub fn checked_div_by_zero<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::CheckedDiv), a, T::ZERO, None),
+        Expect::Ok,
+    )
+}
+
+pub fn safe_div_fitting<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::MAX);
+    let b = rand::thread_rng().gen_range(T::ONE..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::SafeDiv), a, b, Some(a / b)),
+        Expect::Ok,
+    )
+}
+
+pub fn safe_div_by_zero<T: TestUint>(context: simplex::TestContext) -> anyhow::Result<()> {
+    let a = rand::thread_rng().gen_range(T::ZERO..=T::MAX);
+    run(
+        &context,
+        T::program(),
+        T::witness(op(CommonOp::SafeDiv), a, T::ZERO, None),
+        Expect::PrunedBranch,
+    )
+}
+
+/// Stamps the `#[simplex::test]` entry points for one width.
+///
+/// This contains NO test logic, it only maps each scenario name to a concrete
+/// `fn` that calls the generic scenario in this module. All the real logic lives
+/// in the functions above. Usage in a width's test file:
+///
+/// ```ignore
+/// uint_tests!(u8);
+/// ```
+#[macro_export]
+macro_rules! uint_tests {
+    ($t:ty) => {
+        $crate::uint_tests!(@stub $t;
+            checked_add_fitting checked_add_overflow
+            safe_add_fitting    safe_add_overflow
+            checked_sub_fitting checked_sub_overflow
+            safe_sub_fitting    safe_sub_overflow
+            checked_mul_fitting checked_mul_overflow
+            safe_mul_fitting    safe_mul_overflow
+            checked_div_fitting checked_div_by_zero
+            safe_div_fitting    safe_div_by_zero
+        );
+    };
+    (@stub $t:ty; $($name:ident)+) => {
+        $(
+            #[simplex::test]
+            fn $name(context: simplex::TestContext) -> anyhow::Result<()> {
+                $crate::common::uint::$name::<$t>(context)
+            }
+        )+
+    };
+}
diff --git a/tests/helper.rs b/tests/helper.rs
deleted file mode 100644
index b714244..0000000
--- a/tests/helper.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use rand::Rng;
-
-#[allow(dead_code)]
-pub enum IfTestOverflow {
-    NotOverflow,
-    Overflow,
-}
-
-pub fn cast_to_bool(flag: u8) -> bool {
-    flag == 1
-}
-
-#[allow(dead_code)]
-pub fn generate_uints_in_one_range(if_same: bool, min_val: u128, max_val: u128) -> (u128, u128) {
-    let some_u = rand::thread_rng().gen_range(min_val..=max_val);
-
-    if if_same {
-        (some_u, some_u)
-    } else {
-        if min_val == max_val {
-            panic!("Can not generate different values when range is one number");
-        }
-
-        let mut other_u = rand::thread_rng().gen_range(min_val..=max_val);
-
-        while other_u == some_u {
-            other_u = rand::thread_rng().gen_range(min_val..=max_val);
-        }
-
-        (some_u, other_u)
-    }
-}
diff --git a/tests/logical_operations_test.rs b/tests/logical_operations_test.rs
deleted file mode 100644
index 55fb092..0000000
--- a/tests/logical_operations_test.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use simplex::simplicityhl::elements::Script;
-
-use simplex::transaction::{FinalTransaction, PartialInput, ProgramInput, RequiredSignature};
-
-use simplicityhl_std::artifacts::logical_operations_mock::LogicalOperationsMockProgram;
-use simplicityhl_std::artifacts::logical_operations_mock::derived_logical_operations_mock::{
-    LogicalOperationsMockArguments, LogicalOperationsMockWitness,
-};
-
-fn get_script(context: &simplex::TestContext) -> (LogicalOperationsMockProgram, Script) {
-    let arguments = LogicalOperationsMockArguments {};
-
-    let logical_operations_program = LogicalOperationsMockProgram::new(arguments);
-
-    let logical_operations_script =
-        logical_operations_program.get_script_pubkey(context.get_network());
-
-    (logical_operations_program, logical_operations_script)
-}
-
-fn fund_script(context: &simplex::TestContext) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-
-    let (_, logical_operations_script) = get_script(context);
-
-    let tx_receipt = signer.send(logical_operations_script.clone(), 50)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-fn spend_script(context: &simplex::TestContext) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-    let provider = context.get_default_provider();
-
-    let (logical_operations_program, logical_operations_script) = get_script(context);
-
-    let asserts_utxos = provider.fetch_scripthash_utxos(&logical_operations_script)?;
-
-    let mut ft = FinalTransaction::new();
-
-    let witness = LogicalOperationsMockWitness {};
-
-    ft.add_program_input(
-        PartialInput::new(asserts_utxos[0].clone()),
-        ProgramInput::new(
-            Box::new(logical_operations_program.as_ref().clone()),
-            Box::new(witness.clone()),
-        ),
-        RequiredSignature::None,
-    );
-
-    let tx_receipt = signer.broadcast(&ft)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-#[simplex::test]
-fn logical_operations_test(context: simplex::TestContext) -> anyhow::Result<()> {
-    fund_script(&context)?;
-    spend_script(&context)?;
-
-    Ok(())
-}
diff --git a/tests/logical_ops_test.rs b/tests/logical_ops_test.rs
new file mode 100644
index 0000000..f7ac6ee
--- /dev/null
+++ b/tests/logical_ops_test.rs
@@ -0,0 +1,18 @@
+mod common;
+
+use common::{Expect, run};
+
+use simplicityhl_std::artifacts::logical_ops_test::LogicalOpsTestProgram;
+use simplicityhl_std::artifacts::logical_ops_test::derived_logical_ops_test::{
+    LogicalOpsTestArguments, LogicalOpsTestWitness,
+};
+
+mod logical_ops_tests {
+    use super::*;
+
+    #[simplex::test]
+    fn logical_operations_test(context: simplex::TestContext) -> anyhow::Result<()> {
+        let program = LogicalOpsTestProgram::new(LogicalOpsTestArguments {});
+        run(&context, program, LogicalOpsTestWitness {}, Expect::Ok)
+    }
+}
diff --git a/tests/u16_test.rs b/tests/u16_test.rs
index 70fd686..7274e4e 100644
--- a/tests/u16_test.rs
+++ b/tests/u16_test.rs
@@ -1,424 +1,38 @@
-use rand::Rng;
+mod common;
 
-use simplex::simplicityhl::elements::Script;
+use common::uint::TestUint;
 
-use simplex::transaction::{FinalTransaction, PartialInput, ProgramInput, RequiredSignature};
+use simplicityhl_std::artifacts::u16_test::U16TestProgram;
+use simplicityhl_std::artifacts::u16_test::derived_u16_test::{U16TestArguments, U16TestWitness};
 
-use simplicityhl_std::artifacts::u16_mock::U16MockProgram;
-use simplicityhl_std::artifacts::u16_mock::derived_u16_mock::{U16MockArguments, U16MockWitness};
+// The only per-width code for the common operations.
+impl TestUint for u16 {
+    type Program = U16TestProgram;
+    type Witness = U16TestWitness;
 
-mod helper;
+    const ZERO: u16 = 0;
+    const ONE: u16 = 1;
+    const MAX: u16 = u16::MAX;
+    const HALF_MAX: u16 = u16::MAX / 2;
+    const MUL_BOUND: u16 = 1 << 8; // 2^(16/2)
 
-use crate::helper::{IfTestOverflow, cast_to_bool};
+    fn program() -> U16TestProgram {
+        U16TestProgram::new(U16TestArguments {})
+    }
 
-enum FunctionToTest {
-    CheckedAdd16,
-    SafeAdd16,
-    CheckedSub16,
-    SafeSub16,
-    CheckedMul16,
-    SafeMul16,
-    CheckedDiv16,
-    SafeDiv16,
+    fn witness(op: u8, a: u16, b: u16, expected: Option<u16>) -> U16TestWitness {
+        U16TestWitness {
+            function_index: op,
+            first_arg: a,
+            second_arg: b,
+            expected,
+        }
+    }
 }
 
-fn get_script(context: &simplex::TestContext) -> (U16MockProgram, Script) {
-    let arguments = U16MockArguments {};
+mod u16_tests {
+    use super::*;
 
-    let u16_program = U16MockProgram::new(arguments);
-
-    let u16_script = u16_program.get_script_pubkey(context.get_network());
-
-    (u16_program, u16_script)
-}
-
-fn fund_script(context: &simplex::TestContext) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-
-    let (_, u16_script) = get_script(context);
-
-    let tx_receipt = signer.send(u16_script.clone(), 50)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-fn spend_script(
-    context: &simplex::TestContext,
-    function_index: FunctionToTest,
-    if_test_overflow: IfTestOverflow,
-    first_arg: u16,
-    second_arg: u16,
-    result: u16,
-) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-    let provider = context.get_default_provider();
-
-    let (u16_program, u16_script) = get_script(context);
-
-    let asserts_utxos = provider.fetch_scripthash_utxos(&u16_script)?;
-
-    let mut ft = FinalTransaction::new();
-
-    let witness = U16MockWitness {
-        function_index: function_index as u8,
-        if_test_overflow: cast_to_bool(if_test_overflow as u8),
-        first_arg,
-        second_arg,
-        result,
-    };
-
-    ft.add_program_input(
-        PartialInput::new(asserts_utxos[0].clone()),
-        ProgramInput::new(
-            Box::new(u16_program.as_ref().clone()),
-            Box::new(witness.clone()),
-        ),
-        RequiredSignature::None,
-    );
-
-    let tx_receipt = signer.broadcast(&ft)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_checked_add_16_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX / 2);
-    let second_arg = rand::thread_rng().gen_range(0..=u16::MAX / 2);
-    let result = first_arg + second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedAdd16,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_checked_add_16_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u16::MAX;
-    let second_arg = rand::thread_rng().gen_range(1..=u16::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedAdd16,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_safe_add_16_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX / 2);
-    let second_arg = rand::thread_rng().gen_range(0..=u16::MAX / 2);
-    let result = first_arg + second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeAdd16,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_safe_add_16_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u16::MAX;
-    let second_arg = rand::thread_rng().gen_range(1..=u16::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeAdd16,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_checked_sub_16_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX);
-    let second_arg = rand::thread_rng().gen_range(0..=first_arg);
-    let result = first_arg - second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedSub16,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_checked_sub_16_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX - 1);
-    let second_arg = rand::thread_rng().gen_range(first_arg + 1..=u16::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedSub16,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_safe_sub_16_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX);
-    let second_arg = rand::thread_rng().gen_range(0..=first_arg);
-    let result = first_arg - second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeSub16,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_safe_sub_16_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX - 1);
-    let second_arg = rand::thread_rng().gen_range(first_arg + 1..=u16::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeSub16,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_checked_mul_16_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..2_u16.pow(16 / 2));
-    let second_arg = rand::thread_rng().gen_range(0..2_u16.pow(16 / 2));
-    let result = first_arg * second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedMul16,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_checked_mul_16_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u16::MAX;
-    let second_arg = rand::thread_rng().gen_range(2..=u16::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedMul16,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_safe_mul_16_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..2_u16.pow(16 / 2));
-    let second_arg = rand::thread_rng().gen_range(0..2_u16.pow(16 / 2));
-    let result = first_arg * second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeMul16,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_safe_mul_16_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u16::MAX;
-    let second_arg = rand::thread_rng().gen_range(2..=u16::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeMul16,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_checked_div_16_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX);
-    let second_arg = rand::thread_rng().gen_range(1..=u16::MAX);
-    let result = first_arg / second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedDiv16,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_checked_div_16_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX);
-    let second_arg = 0;
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedDiv16,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_safe_div_16_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX);
-    let second_arg = rand::thread_rng().gen_range(1..=u16::MAX);
-    let result = first_arg / second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeDiv16,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u16_test_safe_div_16_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u16::MAX);
-    let second_arg = 0;
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeDiv16,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
+    // Stamps the 16 `#[simplex::test]` entry points for u16. Logic lives in common::uint.
+    uint_tests!(u16);
 }
diff --git a/tests/u32_test.rs b/tests/u32_test.rs
index 43b4718..262f1c1 100644
--- a/tests/u32_test.rs
+++ b/tests/u32_test.rs
@@ -1,424 +1,37 @@
-use rand::Rng;
-
-use simplex::simplicityhl::elements::Script;
-
-use simplex::transaction::{FinalTransaction, PartialInput, ProgramInput, RequiredSignature};
-
-use simplicityhl_std::artifacts::u32_mock::U32MockProgram;
-use simplicityhl_std::artifacts::u32_mock::derived_u32_mock::{U32MockArguments, U32MockWitness};
-
-mod helper;
-
-use crate::helper::{IfTestOverflow, cast_to_bool};
-
-enum FunctionToTest {
-    CheckedAdd32,
-    SafeAdd32,
-    CheckedSub32,
-    SafeSub32,
-    CheckedMul32,
-    SafeMul32,
-    CheckedDiv32,
-    SafeDiv32,
-}
-
-fn get_script(context: &simplex::TestContext) -> (U32MockProgram, Script) {
-    let arguments = U32MockArguments {};
-
-    let u32_program = U32MockProgram::new(arguments);
-
-    let u32_script = u32_program.get_script_pubkey(context.get_network());
-
-    (u32_program, u32_script)
-}
-
-fn fund_script(context: &simplex::TestContext) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-
-    let (_, u32_script) = get_script(context);
-
-    let tx_receipt = signer.send(u32_script.clone(), 50)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-fn spend_script(
-    context: &simplex::TestContext,
-    function_index: FunctionToTest,
-    if_test_overflow: IfTestOverflow,
-    first_arg: u32,
-    second_arg: u32,
-    result: u32,
-) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-    let provider = context.get_default_provider();
-
-    let (u32_program, u32_script) = get_script(context);
-
-    let asserts_utxos = provider.fetch_scripthash_utxos(&u32_script)?;
-
-    let mut ft = FinalTransaction::new();
-
-    let witness = U32MockWitness {
-        function_index: function_index as u8,
-        if_test_overflow: cast_to_bool(if_test_overflow as u8),
-        first_arg,
-        second_arg,
-        result,
-    };
-
-    ft.add_program_input(
-        PartialInput::new(asserts_utxos[0].clone()),
-        ProgramInput::new(
-            Box::new(u32_program.as_ref().clone()),
-            Box::new(witness.clone()),
-        ),
-        RequiredSignature::None,
-    );
-
-    let tx_receipt = signer.broadcast(&ft)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_checked_add_32_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX / 2);
-    let second_arg = rand::thread_rng().gen_range(0..=u32::MAX / 2);
-    let result = first_arg + second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedAdd32,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_checked_add_32_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u32::MAX;
-    let second_arg = rand::thread_rng().gen_range(1..=u32::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedAdd32,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_safe_add_32_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX / 2);
-    let second_arg = rand::thread_rng().gen_range(0..=u32::MAX / 2);
-    let result = first_arg + second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeAdd32,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_safe_add_32_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u32::MAX;
-    let second_arg = rand::thread_rng().gen_range(1..=u32::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeAdd32,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_checked_sub_32_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX);
-    let second_arg = rand::thread_rng().gen_range(0..=first_arg);
-    let result = first_arg - second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedSub32,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_checked_sub_32_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX - 1);
-    let second_arg = rand::thread_rng().gen_range(first_arg + 1..=u32::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedSub32,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_safe_sub_32_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX);
-    let second_arg = rand::thread_rng().gen_range(0..=first_arg);
-    let result = first_arg - second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeSub32,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_safe_sub_32_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX - 1);
-    let second_arg = rand::thread_rng().gen_range(first_arg + 1..=u32::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeSub32,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_checked_mul_32_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..2_u32.pow(32 / 2));
-    let second_arg = rand::thread_rng().gen_range(0..2_u32.pow(32 / 2));
-    let result = first_arg * second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedMul32,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_checked_mul_32_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u32::MAX;
-    let second_arg = rand::thread_rng().gen_range(2..=u32::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedMul32,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_safe_mul_32_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..2_u32.pow(32 / 2));
-    let second_arg = rand::thread_rng().gen_range(0..2_u32.pow(32 / 2));
-    let result = first_arg * second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeMul32,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_safe_mul_32_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u32::MAX;
-    let second_arg = rand::thread_rng().gen_range(2..=u32::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeMul32,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_checked_div_32_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX);
-    let second_arg = rand::thread_rng().gen_range(1..=u32::MAX);
-    let result = first_arg / second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedDiv32,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_checked_div_32_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX);
-    let second_arg = 0;
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedDiv32,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_safe_div_32_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX);
-    let second_arg = rand::thread_rng().gen_range(1..=u32::MAX);
-    let result = first_arg / second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeDiv32,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u32_test_safe_div_32_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u32::MAX);
-    let second_arg = 0;
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeDiv32,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
+mod common;
+
+use common::uint::TestUint;
+
+use simplicityhl_std::artifacts::u32_test::U32TestProgram;
+use simplicityhl_std::artifacts::u32_test::derived_u32_test::{U32TestArguments, U32TestWitness};
+
+// The only per-width code for the common operations.
+impl TestUint for u32 {
+    type Program = U32TestProgram;
+    type Witness = U32TestWitness;
+
+    const ZERO: u32 = 0;
+    const ONE: u32 = 1;
+    const MAX: u32 = u32::MAX;
+    const HALF_MAX: u32 = u32::MAX / 2;
+    const MUL_BOUND: u32 = 1 << 16; // 2^(32/2)
+
+    fn program() -> U32TestProgram {
+        U32TestProgram::new(U32TestArguments {})
+    }
+
+    fn witness(op: u8, a: u32, b: u32, expected: Option<u32>) -> U32TestWitness {
+        U32TestWitness {
+            function_index: op,
+            first_arg: a,
+            second_arg: b,
+            expected,
+        }
+    }
+}
+
+// Stamps the 32 `#[simplex::test]` entry points for u32. Logic lives in common::uint.
+mod u32_tests {
+    use super::*;
+    uint_tests!(u32);
 }
diff --git a/tests/u64_test.rs b/tests/u64_test.rs
index 2372073..e354846 100644
--- a/tests/u64_test.rs
+++ b/tests/u64_test.rs
@@ -1,424 +1,38 @@
-use rand::Rng;
+mod common;
 
-use simplex::simplicityhl::elements::Script;
+use common::uint::TestUint;
 
-use simplex::transaction::{FinalTransaction, PartialInput, ProgramInput, RequiredSignature};
+use simplicityhl_std::artifacts::u64_test::U64TestProgram;
+use simplicityhl_std::artifacts::u64_test::derived_u64_test::{U64TestArguments, U64TestWitness};
 
-use simplicityhl_std::artifacts::u64_mock::U64MockProgram;
-use simplicityhl_std::artifacts::u64_mock::derived_u64_mock::{U64MockArguments, U64MockWitness};
+// The only per-width code for the common operations.
+impl TestUint for u64 {
+    type Program = U64TestProgram;
+    type Witness = U64TestWitness;
 
-mod helper;
+    const ZERO: u64 = 0;
+    const ONE: u64 = 1;
+    const MAX: u64 = u64::MAX;
+    const HALF_MAX: u64 = u64::MAX / 2;
+    const MUL_BOUND: u64 = 1 << 32; // 2^(64/2)
 
-use crate::helper::{IfTestOverflow, cast_to_bool};
+    fn program() -> U64TestProgram {
+        U64TestProgram::new(U64TestArguments {})
+    }
 
-enum FunctionToTest {
-    CheckedAdd64,
-    SafeAdd64,
-    CheckedSub64,
-    SafeSub64,
-    CheckedMul64,
-    SafeMul64,
-    CheckedDiv64,
-    SafeDiv64,
+    fn witness(op: u8, a: u64, b: u64, expected: Option<u64>) -> U64TestWitness {
+        U64TestWitness {
+            function_index: op,
+            first_arg: a,
+            second_arg: b,
+            expected,
+        }
+    }
 }
 
-fn get_script(context: &simplex::TestContext) -> (U64MockProgram, Script) {
-    let arguments = U64MockArguments {};
+mod u64_tests {
+    use super::*;
 
-    let u64_program = U64MockProgram::new(arguments);
-
-    let u64_script = u64_program.get_script_pubkey(context.get_network());
-
-    (u64_program, u64_script)
-}
-
-fn fund_script(context: &simplex::TestContext) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-
-    let (_, u64_script) = get_script(context);
-
-    let tx_receipt = signer.send(u64_script.clone(), 50)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-fn spend_script(
-    context: &simplex::TestContext,
-    function_index: FunctionToTest,
-    if_test_overflow: IfTestOverflow,
-    first_arg: u64,
-    second_arg: u64,
-    result: u64,
-) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-    let provider = context.get_default_provider();
-
-    let (u64_program, u64_script) = get_script(context);
-
-    let asserts_utxos = provider.fetch_scripthash_utxos(&u64_script)?;
-
-    let mut ft = FinalTransaction::new();
-
-    let witness = U64MockWitness {
-        function_index: function_index as u8,
-        if_test_overflow: cast_to_bool(if_test_overflow as u8),
-        first_arg,
-        second_arg,
-        result,
-    };
-
-    ft.add_program_input(
-        PartialInput::new(asserts_utxos[0].clone()),
-        ProgramInput::new(
-            Box::new(u64_program.as_ref().clone()),
-            Box::new(witness.clone()),
-        ),
-        RequiredSignature::None,
-    );
-
-    let tx_receipt = signer.broadcast(&ft)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_checked_add_64_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX / 2);
-    let second_arg = rand::thread_rng().gen_range(0..=u64::MAX / 2);
-    let result = first_arg + second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedAdd64,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_checked_add_64_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u64::MAX;
-    let second_arg = rand::thread_rng().gen_range(1..=u64::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedAdd64,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_safe_add_64_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX / 2);
-    let second_arg = rand::thread_rng().gen_range(0..=u64::MAX / 2);
-    let result = first_arg + second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeAdd64,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_safe_add_64_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u64::MAX;
-    let second_arg = rand::thread_rng().gen_range(1..=u64::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeAdd64,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_checked_sub_64_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX);
-    let second_arg = rand::thread_rng().gen_range(0..=first_arg);
-    let result = first_arg - second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedSub64,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_checked_sub_64_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX - 1);
-    let second_arg = rand::thread_rng().gen_range(first_arg + 1..=u64::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedSub64,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_safe_sub_64_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX);
-    let second_arg = rand::thread_rng().gen_range(0..=first_arg);
-    let result = first_arg - second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeSub64,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_safe_sub_64_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX - 1);
-    let second_arg = rand::thread_rng().gen_range(first_arg + 1..=u64::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeSub64,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_checked_mul_64_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..2_u64.pow(64 / 2));
-    let second_arg = rand::thread_rng().gen_range(0..2_u64.pow(64 / 2));
-    let result = first_arg * second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedMul64,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_checked_mul_64_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u64::MAX;
-    let second_arg = rand::thread_rng().gen_range(2..=u64::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedMul64,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_safe_mul_64_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..2_u64.pow(64 / 2));
-    let second_arg = rand::thread_rng().gen_range(0..2_u64.pow(64 / 2));
-    let result = first_arg * second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeMul64,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_safe_mul_64_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u64::MAX;
-    let second_arg = rand::thread_rng().gen_range(2..=u64::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeMul64,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_checked_div_64_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX);
-    let second_arg = rand::thread_rng().gen_range(1..=u64::MAX);
-    let result = first_arg / second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedDiv64,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_checked_div_64_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX);
-    let second_arg = 0;
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedDiv64,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_safe_div_64_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX);
-    let second_arg = rand::thread_rng().gen_range(1..=u64::MAX);
-    let result = first_arg / second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeDiv64,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u64_test_safe_div_64_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u64::MAX);
-    let second_arg = 0;
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeDiv64,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
+    // Stamps the 16 `#[simplex::test]` entry points for u64. Logic lives in common::uint.
+    uint_tests!(u64);
 }
diff --git a/tests/u8_test.rs b/tests/u8_test.rs
index 4ce3178..e896765 100644
--- a/tests/u8_test.rs
+++ b/tests/u8_test.rs
@@ -1,424 +1,39 @@
-use rand::Rng;
+mod common;
 
-use simplex::simplicityhl::elements::Script;
+use common::uint::TestUint;
 
-use simplex::transaction::{FinalTransaction, PartialInput, ProgramInput, RequiredSignature};
+use simplicityhl_std::artifacts::u8_test::U8TestProgram;
+use simplicityhl_std::artifacts::u8_test::derived_u8_test::{U8TestArguments, U8TestWitness};
 
-use simplicityhl_std::artifacts::u8_mock::U8MockProgram;
-use simplicityhl_std::artifacts::u8_mock::derived_u8_mock::{U8MockArguments, U8MockWitness};
+// The only per-width code for the common operations.
+impl TestUint for u8 {
+    type Program = U8TestProgram;
+    type Witness = U8TestWitness;
 
-mod helper;
+    const ZERO: u8 = 0;
+    const ONE: u8 = 1;
+    const MAX: u8 = u8::MAX;
+    const HALF_MAX: u8 = u8::MAX / 2;
+    const MUL_BOUND: u8 = 1 << 4; // 2^(8/2)
 
-use crate::helper::{IfTestOverflow, cast_to_bool};
+    fn program() -> U8TestProgram {
+        U8TestProgram::new(U8TestArguments {})
+    }
 
-enum FunctionToTest {
-    CheckedAdd8,
-    SafeAdd8,
-    CheckedSub8,
-    SafeSub8,
-    CheckedMul8,
-    SafeMul8,
-    CheckedDiv8,
-    SafeDiv8,
+    fn witness(op: u8, a: u8, b: u8, expected: Option<u8>) -> U8TestWitness {
+        U8TestWitness {
+            function_index: op,
+            first_arg: a,
+            second_arg: b,
+            expected,
+        }
+    }
 }
 
-fn get_script(context: &simplex::TestContext) -> (U8MockProgram, Script) {
-    let arguments = U8MockArguments {};
+// Use `simplex test u8_tests` to run only the tests in this file.
+mod u8_tests {
+    use super::*;
 
-    let u8_program = U8MockProgram::new(arguments);
-
-    let u8_script = u8_program.get_script_pubkey(context.get_network());
-
-    (u8_program, u8_script)
-}
-
-fn fund_script(context: &simplex::TestContext) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-
-    let (_, u8_script) = get_script(context);
-
-    let tx_receipt = signer.send(u8_script.clone(), 50)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-fn spend_script(
-    context: &simplex::TestContext,
-    function_index: FunctionToTest,
-    if_test_overflow: IfTestOverflow,
-    first_arg: u8,
-    second_arg: u8,
-    result: u8,
-) -> anyhow::Result<()> {
-    let signer = context.get_default_signer();
-    let provider = context.get_default_provider();
-
-    let (u8_program, u8_script) = get_script(context);
-
-    let asserts_utxos = provider.fetch_scripthash_utxos(&u8_script)?;
-
-    let mut ft = FinalTransaction::new();
-
-    let witness = U8MockWitness {
-        function_index: function_index as u8,
-        if_test_overflow: cast_to_bool(if_test_overflow as u8),
-        first_arg,
-        second_arg,
-        result,
-    };
-
-    ft.add_program_input(
-        PartialInput::new(asserts_utxos[0].clone()),
-        ProgramInput::new(
-            Box::new(u8_program.as_ref().clone()),
-            Box::new(witness.clone()),
-        ),
-        RequiredSignature::None,
-    );
-
-    let tx_receipt = signer.broadcast(&ft)?;
-    println!("Broadcast: {}", tx_receipt);
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_checked_add_8_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX / 2);
-    let second_arg = rand::thread_rng().gen_range(0..=u8::MAX / 2);
-    let result = first_arg + second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedAdd8,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_checked_add_8_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u8::MAX;
-    let second_arg = rand::thread_rng().gen_range(1..=u8::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedAdd8,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_safe_add_8_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX / 2);
-    let second_arg = rand::thread_rng().gen_range(0..=u8::MAX / 2);
-    let result = first_arg + second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeAdd8,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_safe_add_8_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u8::MAX;
-    let second_arg = rand::thread_rng().gen_range(1..=u8::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeAdd8,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_checked_sub_8_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX);
-    let second_arg = rand::thread_rng().gen_range(0..=first_arg);
-    let result = first_arg - second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedSub8,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_checked_sub_8_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX - 1);
-    let second_arg = rand::thread_rng().gen_range(first_arg + 1..=u8::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedSub8,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_safe_sub_8_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX);
-    let second_arg = rand::thread_rng().gen_range(0..=first_arg);
-    let result = first_arg - second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeSub8,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_safe_sub_8_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX - 1);
-    let second_arg = rand::thread_rng().gen_range(first_arg + 1..=u8::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeSub8,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_checked_mul_8_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..2_u8.pow(8 / 2));
-    let second_arg = rand::thread_rng().gen_range(0..2_u8.pow(8 / 2));
-    let result = first_arg * second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedMul8,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_checked_mul_8_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u8::MAX;
-    let second_arg = rand::thread_rng().gen_range(2..=u8::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedMul8,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_safe_mul_8_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..2_u8.pow(8 / 2));
-    let second_arg = rand::thread_rng().gen_range(0..2_u8.pow(8 / 2));
-    let result = first_arg * second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeMul8,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_safe_mul_8_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = u8::MAX;
-    let second_arg = rand::thread_rng().gen_range(2..=u8::MAX);
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeMul8,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_checked_div_8_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX);
-    let second_arg = rand::thread_rng().gen_range(1..=u8::MAX);
-    let result = first_arg / second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedDiv8,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_checked_div_8_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX);
-    let second_arg = 0;
-    let result = 0;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::CheckedDiv8,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_safe_div_8_not_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX);
-    let second_arg = rand::thread_rng().gen_range(1..=u8::MAX);
-    let result = first_arg / second_arg;
-
-    fund_script(&context)?;
-    spend_script(
-        &context,
-        FunctionToTest::SafeDiv8,
-        IfTestOverflow::NotOverflow,
-        first_arg,
-        second_arg,
-        result,
-    )?;
-
-    Ok(())
-}
-
-#[simplex::test]
-fn u8_test_safe_div_8_overflow(context: simplex::TestContext) -> anyhow::Result<()> {
-    let first_arg = rand::thread_rng().gen_range(0..=u8::MAX);
-    let second_arg = 0;
-    let result = 0;
-
-    fund_script(&context)?;
-
-    let txid_result = spend_script(
-        &context,
-        FunctionToTest::SafeDiv8,
-        IfTestOverflow::Overflow,
-        first_arg,
-        second_arg,
-        result,
-    );
-
-    assert!(
-        txid_result.is_err(),
-        "Expected this test to fail but it succeeded"
-    );
-
-    let err: String = txid_result.unwrap_err().to_string();
-    assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
-
-    Ok(())
+    // Stamps the 16 `#[simplex::test]` entry points for u8. Logic lives in common::uint.
+    uint_tests!(u8);
 }