From 24b937185ba166eaea40d2eb65b40b22f062dc89 Mon Sep 17 00:00:00 2001
From: LesterEvSe <evgenii.nikolaevichfgh@gmail.com>
Date: Mon, 29 Jun 2026 18:50:28 +0300
Subject: [PATCH] feat: recode `uint` operations for clarity

---
 ...ations_mock.simf => logical_ops_test.simf} |   0
 simf/u16_mock.simf                            | 140 ------
 simf/u16_test.simf                            |  37 ++
 simf/u32_mock.simf                            | 140 ------
 simf/u32_test.simf                            |  34 ++
 simf/u64_mock.simf                            | 140 ------
 simf/u64_test.simf                            |  34 ++
 simf/u8_mock.simf                             | 140 ------
 simf/u8_test.simf                             |  37 ++
 tests/common/mod.rs                           |  77 +++
 tests/common/uint.rs                          | 267 ++++++++++
 tests/helper.rs                               |  20 +-
 tests/logical_operations_test.rs              |  65 ---
 tests/logical_ops_test.rs                     |  14 +
 tests/u16_test.rs                             | 442 ++---------------
 tests/u32_test.rs                             | 459 ++----------------
 tests/u64_test.rs                             | 442 ++---------------
 tests/u8_test.rs                              | 443 ++---------------
 18 files changed, 631 insertions(+), 2300 deletions(-)
 rename simf/{logical_operations_mock.simf => logical_ops_test.simf} (100%)
 delete mode 100644 simf/u16_mock.simf
 create mode 100644 simf/u16_test.simf
 delete mode 100644 simf/u32_mock.simf
 create mode 100644 simf/u32_test.simf
 delete mode 100644 simf/u64_mock.simf
 create mode 100644 simf/u64_test.simf
 delete mode 100644 simf/u8_mock.simf
 create mode 100644 simf/u8_test.simf
 create mode 100644 tests/common/mod.rs
 create mode 100644 tests/common/uint.rs
 delete mode 100644 tests/logical_operations_test.rs
 create mode 100644 tests/logical_ops_test.rs

diff --git a/simf/logical_operations_mock.simf b/simf/logical_ops_test.simf
similarity index 100%
rename from simf/logical_operations_mock.simf
rename to simf/logical_ops_test.simf
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/common/mod.rs b/tests/common/mod.rs
new file mode 100644
index 0000000..b654011
--- /dev/null
+++ b/tests/common/mod.rs
@@ -0,0 +1,77 @@
+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)
+// ---------------------------------------------------------------------------
+
+pub enum Expect {
+    Ok,
+    PrunedFail, // safe_* overflow, div-by-zero, etc.
+}
+
+/// 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 {
+        Expect::Ok => {
+            result?;
+        }
+        Expect::PrunedFail => {
+            assert!(
+                result.is_err(),
+                "expected a pruned-branch failure, but it succeeded"
+            );
+            let err = result.unwrap_err().to_string();
+            assert!(err.contains("Failed to prune program: Execution reached a pruned branch"));
+        }
+    }
+    Ok(())
+}
diff --git a/tests/common/uint.rs b/tests/common/uint.rs
new file mode 100644
index 0000000..84d0252
--- /dev/null
+++ b/tests/common/uint.rs
@@ -0,0 +1,267 @@
+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` (discriminants 0..7).
+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::PrunedFail,
+    )
+}
+
+// ---- 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::PrunedFail,
+    )
+}
+
+// ---- 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::PrunedFail,
+    )
+}
+
+// ---- 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::PrunedFail,
+    )
+}
+
+/// 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
index b714244..e294f72 100644
--- a/tests/helper.rs
+++ b/tests/helper.rs
@@ -15,18 +15,18 @@ pub fn generate_uints_in_one_range(if_same: bool, min_val: u128, max_val: 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");
-        }
+        return (some_u, some_u);
+    }
 
-        let mut other_u = rand::thread_rng().gen_range(min_val..=max_val);
+    if min_val == max_val {
+        panic!("Can not generate different values when range is one number");
+    }
 
-        while other_u == some_u {
-            other_u = rand::thread_rng().gen_range(min_val..=max_val);
-        }
+    let mut other_u = rand::thread_rng().gen_range(min_val..=max_val);
 
-        (some_u, other_u)
+    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..3b76d49
--- /dev/null
+++ b/tests/logical_ops_test.rs
@@ -0,0 +1,14 @@
+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,
+};
+
+#[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..1f6e6ad 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_test {
+    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);
 }