From bf90608525c93161f19c90f115314afa48d06ccf Mon Sep 17 00:00:00 2001 From: aritkulova Date: Fri, 10 Jul 2026 18:10:55 +0300 Subject: [PATCH 1/4] added gt and ge operators --- simf/lib/u16.simf | 10 ++++++ simf/lib/u32.simf | 10 ++++++ simf/lib/u64.simf | 10 ++++++ simf/lib/u8.simf | 10 ++++++ simf/u16_test.simf | 16 +++++++++- simf/u32_test.simf | 16 +++++++++- simf/u64_test.simf | 15 ++++++++- simf/u8_test.simf | 16 +++++++++- tests/common/uint.rs | 75 ++++++++++++++++++++++++++++++++++++++++++++ 9 files changed, 174 insertions(+), 4 deletions(-) diff --git a/simf/lib/u16.simf b/simf/lib/u16.simf index 4b1da2a..e146253 100644 --- a/simf/lib/u16.simf +++ b/simf/lib/u16.simf @@ -57,3 +57,13 @@ pub fn checked_div_16(a: u16, b: u16) -> Option { pub fn safe_div_16(a: u16, b: u16) -> u16 { unwrap(checked_div_16(a, b)) } + +/// Check if an integer is greater than another integer +pub fn gt_16(a: u16, b: u16) -> bool { + jet::lt_16(b, a) +} + +/// Check if an integer is greater than or equal to another integer +pub fn ge_16(a: u16, b: u16) -> bool { + jet::le_16(b, a) +} diff --git a/simf/lib/u32.simf b/simf/lib/u32.simf index 909fc56..4fac035 100644 --- a/simf/lib/u32.simf +++ b/simf/lib/u32.simf @@ -57,3 +57,13 @@ pub fn checked_div_32(a: u32, b: u32) -> Option { pub fn safe_div_32(a: u32, b: u32) -> u32 { unwrap(checked_div_32(a, b)) } + +/// Check if an integer is greater than another integer +pub fn gt_32(a: u32, b: u32) -> bool { + jet::lt_32(b, a) +} + +/// Check if an integer is greater than or equal to another integer +pub fn ge_32(a: u32, b: u32) -> bool { + jet::le_32(b, a) +} diff --git a/simf/lib/u64.simf b/simf/lib/u64.simf index 913dbdc..b4517e3 100644 --- a/simf/lib/u64.simf +++ b/simf/lib/u64.simf @@ -57,3 +57,13 @@ pub fn checked_div_64(a: u64, b: u64) -> Option { pub fn safe_div_64(a: u64, b: u64) -> u64 { unwrap(checked_div_64(a, b)) } + +/// Check if an integer is greater than another integer +pub fn gt_64(a: u64, b: u64) -> bool { + jet::lt_64(b, a) +} + +/// Check if an integer is greater than or equal to another integer +pub fn ge_64(a: u64, b: u64) -> bool { + jet::le_64(b, a) +} diff --git a/simf/lib/u8.simf b/simf/lib/u8.simf index d3b87f7..9d50464 100644 --- a/simf/lib/u8.simf +++ b/simf/lib/u8.simf @@ -57,3 +57,13 @@ pub fn checked_div_8(a: u8, b: u8) -> Option { pub fn safe_div_8(a: u8, b: u8) -> u8 { unwrap(checked_div_8(a, b)) } + +/// Check if an integer is greater than another integer +pub fn gt_8(a: u8, b: u8) -> bool { + jet::lt_8(b, a) +} + +/// Check if an integer is greater than or equal to another integer +pub fn ge_8(a: u8, b: u8) -> bool { + jet::le_8(b, a) +} diff --git a/simf/u16_test.simf b/simf/u16_test.simf index 3a57f73..1370b29 100644 --- a/simf/u16_test.simf +++ b/simf/u16_test.simf @@ -1,5 +1,6 @@ -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::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, gt_16, ge_16}; use crate::lib::asserts::{assert_none_16, assert_eq_16}; +use crate::lib::logical_operations::not; use crate::helper::if_test_this_function; /// Asserts a `checked_*` result equals the expected Option. @@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option, expected: Option) { } } +/// Asserts a result equals the expected bool value. +/// `None` encodes `false`, and `Some(_)` encodes `true`. +pub fn assert_bool(result: bool, expected: Option) { + match expected { + Some(_: u16) => assert!(result), + None => assert!(not(result)), + } +} + fn main() { let fn_idx: u8 = witness::FUNCTION_INDEX; @@ -34,4 +44,8 @@ fn main() { // 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 => (), }; + + // gt, ge + match if_test_this_function(8, fn_idx) { true => { assert_bool(gt_16(a, b), expected); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_bool(ge_16(a, b), expected); }, false => (), }; } diff --git a/simf/u32_test.simf b/simf/u32_test.simf index 6222ee8..7cd0574 100644 --- a/simf/u32_test.simf +++ b/simf/u32_test.simf @@ -1,5 +1,6 @@ -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::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, gt_32, ge_32}; use crate::lib::asserts::{assert_none_32, assert_eq_32}; +use crate::lib::logical_operations::not; use crate::helper::if_test_this_function; /// Asserts a `checked_*` result equals the expected Option. @@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option, expected: Option) { } } +/// Asserts a result equals the expected bool value. +/// `None` encodes `false`, and `Some(_)` encodes `true`. +pub fn assert_bool(result: bool, expected: Option) { + match expected { + Some(_: u32) => assert!(result), + None => assert!(not(result)), + } +} + fn main() { let fn_idx: u8 = witness::FUNCTION_INDEX; @@ -34,4 +44,8 @@ fn main() { // 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 => (), }; + + // gt, ge + match if_test_this_function(8, fn_idx) { true => { assert_bool(gt_32(a, b), expected); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_bool(ge_32(a, b), expected); }, false => (), }; } diff --git a/simf/u64_test.simf b/simf/u64_test.simf index 955d2c3..407d949 100644 --- a/simf/u64_test.simf +++ b/simf/u64_test.simf @@ -1,5 +1,6 @@ -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::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, gt_64, ge_64}; use crate::lib::asserts::{assert_none_64, assert_eq_64}; +use crate::lib::logical_operations::not; use crate::helper::if_test_this_function; /// Asserts a `checked_*` result equals the expected Option. @@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option, expected: Option) { } } +/// Asserts a result equals the expected bool value. +/// `None` encodes `false`, and `Some(_)` encodes `true`. +pub fn assert_bool(result: bool, expected: Option) { + match expected { + Some(_: u64) => assert!(result), + None => assert!(not(result)), + } +} + fn main() { let fn_idx: u8 = witness::FUNCTION_INDEX; @@ -34,4 +44,7 @@ fn main() { 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 => (), }; + // gt, ge + match if_test_this_function(8, fn_idx) { true => { assert_bool(gt_64(a, b), expected); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_bool(ge_64(a, b), expected); }, false => (), }; } diff --git a/simf/u8_test.simf b/simf/u8_test.simf index dfd7b25..a3f3840 100644 --- a/simf/u8_test.simf +++ b/simf/u8_test.simf @@ -1,5 +1,6 @@ -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::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, gt_8, ge_8}; use crate::lib::asserts::{assert_none_8, assert_eq_8}; +use crate::lib::logical_operations::not; use crate::helper::if_test_this_function; /// Asserts a `checked_*` result equals the expected Option. @@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option, expected: Option) { } } +/// Asserts a result equals the expected bool value. +/// `None` encodes `false`, and `Some(_)` encodes `true`. +pub fn assert_bool(result: bool, expected: Option) { + match expected { + Some(_: u8) => assert!(result), + None => assert!(not(result)), + } +} + fn main() { let fn_idx: u8 = witness::FUNCTION_INDEX; @@ -34,4 +44,8 @@ fn main() { // 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 => (), }; + + // gt, ge + match if_test_this_function(8, fn_idx) { true => { assert_bool(gt_8(a, b), expected); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_bool(ge_8(a, b), expected); }, false => (), }; } diff --git a/tests/common/uint.rs b/tests/common/uint.rs index cf4b9b4..f46230e 100644 --- a/tests/common/uint.rs +++ b/tests/common/uint.rs @@ -23,6 +23,8 @@ pub enum CommonOp { SafeMul, CheckedDiv, SafeDiv, + Gt, + Ge, } /// Width-specific operations number their dispatch indices from here. @@ -237,6 +239,76 @@ pub fn safe_div_by_zero(context: simplex::TestContext) -> anyhow::R ) } +pub fn gt_greater(context: simplex::TestContext) -> anyhow::Result<()> { + let b = rand::thread_rng().gen_range(T::ZERO..T::MAX); + let a = rand::thread_rng().gen_range(b + T::ONE..=T::MAX); + + run( + &context, + T::program(), + T::witness(op(CommonOp::Gt), a, b, Some(T::ZERO)), + Expect::Ok, + ) +} + +pub fn gt_equal(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(T::ZERO..T::MAX); + + run( + &context, + T::program(), + T::witness(op(CommonOp::Gt), a, a, None), + Expect::Ok, + ) +} + +pub fn gt_less(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(T::ZERO..T::MAX); + let b = rand::thread_rng().gen_range(a + T::ONE..=T::MAX); + + run( + &context, + T::program(), + T::witness(op(CommonOp::Gt), a, b, None), + Expect::Ok, + ) +} + +pub fn ge_greater(context: simplex::TestContext) -> anyhow::Result<()> { + let b = rand::thread_rng().gen_range(T::ZERO..T::MAX); + let a = rand::thread_rng().gen_range(b + T::ONE..=T::MAX); + + run( + &context, + T::program(), + T::witness(op(CommonOp::Ge), a, b, Some(T::ZERO)), + Expect::Ok, + ) +} + +pub fn ge_equal(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(T::ZERO..T::MAX); + + run( + &context, + T::program(), + T::witness(op(CommonOp::Ge), a, a, Some(T::ZERO)), + Expect::Ok, + ) +} + +pub fn ge_less(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(T::ZERO..T::MAX); + let b = rand::thread_rng().gen_range(a + T::ONE..=T::MAX); + + run( + &context, + T::program(), + T::witness(op(CommonOp::Ge), a, b, None), + Expect::Ok, + ) +} + /// Stamps the `#[simplex::test]` entry points for one width. /// /// It contains NO test logic. It only maps each scenario name to a concrete @@ -278,6 +350,9 @@ macro_rules! uint_tests { safe_mul_fitting safe_mul_overflow checked_div_fitting checked_div_by_zero safe_div_fitting safe_div_by_zero + gt_greater gt_equal + gt_less ge_greater + ge_equal ge_less ); }; (@stub $t:ty; $($name:ident)+) => { From 30209adff9f08d0dac0388c0c2ff19f2f9208e23 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Mon, 13 Jul 2026 14:13:36 +0300 Subject: [PATCH 2/4] removed unnecessary pub modifier --- simf/u16_test.simf | 2 +- simf/u32_test.simf | 2 +- simf/u64_test.simf | 2 +- simf/u8_test.simf | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/simf/u16_test.simf b/simf/u16_test.simf index 1370b29..9cc082d 100644 --- a/simf/u16_test.simf +++ b/simf/u16_test.simf @@ -15,7 +15,7 @@ fn assert_eq_opt(result: Option, expected: Option) { /// Asserts a result equals the expected bool value. /// `None` encodes `false`, and `Some(_)` encodes `true`. -pub fn assert_bool(result: bool, expected: Option) { +fn assert_bool(result: bool, expected: Option) { match expected { Some(_: u16) => assert!(result), None => assert!(not(result)), diff --git a/simf/u32_test.simf b/simf/u32_test.simf index 7cd0574..7ef077b 100644 --- a/simf/u32_test.simf +++ b/simf/u32_test.simf @@ -15,7 +15,7 @@ fn assert_eq_opt(result: Option, expected: Option) { /// Asserts a result equals the expected bool value. /// `None` encodes `false`, and `Some(_)` encodes `true`. -pub fn assert_bool(result: bool, expected: Option) { +fn assert_bool(result: bool, expected: Option) { match expected { Some(_: u32) => assert!(result), None => assert!(not(result)), diff --git a/simf/u64_test.simf b/simf/u64_test.simf index 407d949..14125aa 100644 --- a/simf/u64_test.simf +++ b/simf/u64_test.simf @@ -15,7 +15,7 @@ fn assert_eq_opt(result: Option, expected: Option) { /// Asserts a result equals the expected bool value. /// `None` encodes `false`, and `Some(_)` encodes `true`. -pub fn assert_bool(result: bool, expected: Option) { +fn assert_bool(result: bool, expected: Option) { match expected { Some(_: u64) => assert!(result), None => assert!(not(result)), diff --git a/simf/u8_test.simf b/simf/u8_test.simf index a3f3840..f0bb74c 100644 --- a/simf/u8_test.simf +++ b/simf/u8_test.simf @@ -15,7 +15,7 @@ fn assert_eq_opt(result: Option, expected: Option) { /// Asserts a result equals the expected bool value. /// `None` encodes `false`, and `Some(_)` encodes `true`. -pub fn assert_bool(result: bool, expected: Option) { +fn assert_bool(result: bool, expected: Option) { match expected { Some(_: u8) => assert!(result), None => assert!(not(result)), From 42a8c9566fec9c7f584cfdd2d6313502d158372d Mon Sep 17 00:00:00 2001 From: aritkulova Date: Tue, 14 Jul 2026 14:44:39 +0300 Subject: [PATCH 3/4] renamed assert_bool to prevent future collisions --- simf/u16_test.simf | 6 +++--- simf/u32_test.simf | 6 +++--- simf/u64_test.simf | 6 +++--- simf/u8_test.simf | 6 +++--- 4 files changed, 12 insertions(+), 12 deletions(-) diff --git a/simf/u16_test.simf b/simf/u16_test.simf index 9cc082d..63d03e4 100644 --- a/simf/u16_test.simf +++ b/simf/u16_test.simf @@ -15,7 +15,7 @@ fn assert_eq_opt(result: Option, expected: Option) { /// Asserts a result equals the expected bool value. /// `None` encodes `false`, and `Some(_)` encodes `true`. -fn assert_bool(result: bool, expected: Option) { +fn assert_bool_by_opt(result: bool, expected: Option) { match expected { Some(_: u16) => assert!(result), None => assert!(not(result)), @@ -46,6 +46,6 @@ fn main() { match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_16(safe_div_16(a, b), unwrap(expected))); }, false => (), }; // gt, ge - match if_test_this_function(8, fn_idx) { true => { assert_bool(gt_16(a, b), expected); }, false => (), }; - match if_test_this_function(9, fn_idx) { true => { assert_bool(ge_16(a, b), expected); }, false => (), }; + match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_16(a, b), expected); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_16(a, b), expected); }, false => (), }; } diff --git a/simf/u32_test.simf b/simf/u32_test.simf index 7ef077b..41e4f22 100644 --- a/simf/u32_test.simf +++ b/simf/u32_test.simf @@ -15,7 +15,7 @@ fn assert_eq_opt(result: Option, expected: Option) { /// Asserts a result equals the expected bool value. /// `None` encodes `false`, and `Some(_)` encodes `true`. -fn assert_bool(result: bool, expected: Option) { +fn assert_bool_by_opt(result: bool, expected: Option) { match expected { Some(_: u32) => assert!(result), None => assert!(not(result)), @@ -46,6 +46,6 @@ fn main() { match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_32(safe_div_32(a, b), unwrap(expected))); }, false => (), }; // gt, ge - match if_test_this_function(8, fn_idx) { true => { assert_bool(gt_32(a, b), expected); }, false => (), }; - match if_test_this_function(9, fn_idx) { true => { assert_bool(ge_32(a, b), expected); }, false => (), }; + match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_32(a, b), expected); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_32(a, b), expected); }, false => (), }; } diff --git a/simf/u64_test.simf b/simf/u64_test.simf index 14125aa..d9ed4f6 100644 --- a/simf/u64_test.simf +++ b/simf/u64_test.simf @@ -15,7 +15,7 @@ fn assert_eq_opt(result: Option, expected: Option) { /// Asserts a result equals the expected bool value. /// `None` encodes `false`, and `Some(_)` encodes `true`. -fn assert_bool(result: bool, expected: Option) { +fn assert_bool_by_opt(result: bool, expected: Option) { match expected { Some(_: u64) => assert!(result), None => assert!(not(result)), @@ -45,6 +45,6 @@ fn main() { match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_64(safe_div_64(a, b), unwrap(expected))); }, false => (), }; // gt, ge - match if_test_this_function(8, fn_idx) { true => { assert_bool(gt_64(a, b), expected); }, false => (), }; - match if_test_this_function(9, fn_idx) { true => { assert_bool(ge_64(a, b), expected); }, false => (), }; + match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_64(a, b), expected); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_64(a, b), expected); }, false => (), }; } diff --git a/simf/u8_test.simf b/simf/u8_test.simf index f0bb74c..d77ee87 100644 --- a/simf/u8_test.simf +++ b/simf/u8_test.simf @@ -15,7 +15,7 @@ fn assert_eq_opt(result: Option, expected: Option) { /// Asserts a result equals the expected bool value. /// `None` encodes `false`, and `Some(_)` encodes `true`. -fn assert_bool(result: bool, expected: Option) { +fn assert_bool_by_opt(result: bool, expected: Option) { match expected { Some(_: u8) => assert!(result), None => assert!(not(result)), @@ -46,6 +46,6 @@ fn main() { match if_test_this_function(7, fn_idx) { true => { assert!(jet::eq_8(safe_div_8(a, b), unwrap(expected))); }, false => (), }; // gt, ge - match if_test_this_function(8, fn_idx) { true => { assert_bool(gt_8(a, b), expected); }, false => (), }; - match if_test_this_function(9, fn_idx) { true => { assert_bool(ge_8(a, b), expected); }, false => (), }; + match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_8(a, b), expected); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_8(a, b), expected); }, false => (), }; } From c9cedfd79dfa5953460609dcc5ac058b4f5c2233 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Tue, 14 Jul 2026 18:16:13 +0300 Subject: [PATCH 4/4] added gt and ge operators for u128 --- simf/lib/u128.simf | 10 ++++++++++ simf/u128_test.simf | 16 +++++++++++++++- 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/simf/lib/u128.simf b/simf/lib/u128.simf index 2743b79..4c80745 100644 --- a/simf/lib/u128.simf +++ b/simf/lib/u128.simf @@ -119,6 +119,16 @@ pub fn le_128(a: u128, b: u128) -> bool { } } +/// Check if an integer is greater than another integer +pub fn gt_128(a: u128, b: u128) -> bool { + lt_128(b, a) +} + +/// Check if an integer is greater than or equal to another integer +pub fn ge_128(a: u128, b: u128) -> bool { + le_128(b, a) +} + /// Adds two integers and returns the carry pub fn add_128(a: u128, b: u128) -> (bool, u128) { let (a_high, a_low): (u64, u64) = ::into(a); diff --git a/simf/u128_test.simf b/simf/u128_test.simf index 61de977..08c71f7 100644 --- a/simf/u128_test.simf +++ b/simf/u128_test.simf @@ -1,5 +1,6 @@ -use crate::lib::u128::{ checked_add_128, safe_add_128, checked_sub_128, safe_sub_128, checked_mul_128, safe_mul_128, checked_div_128, safe_div_128, eq_128 }; +use crate::lib::u128::{ checked_add_128, safe_add_128, checked_sub_128, safe_sub_128, checked_mul_128, safe_mul_128, checked_div_128, safe_div_128, eq_128, gt_128, ge_128 }; use crate::lib::asserts::{assert_none_128, assert_eq_128}; +use crate::lib::logical_operations::not; use crate::helper::if_test_this_function; /// Asserts a `checked_*` result equals the expected Option. @@ -12,6 +13,15 @@ fn assert_eq_opt(result: Option, expected: Option) { } } +/// Asserts a result equals the expected bool value. +/// `None` encodes `false`, and `Some(_)` encodes `true`. +fn assert_bool_by_opt(result: bool, expected: Option) { + match expected { + Some(_: u128) => assert!(result), + None => assert!(not(result)), + } +} + fn main() { let fn_idx: u8 = witness::FUNCTION_INDEX; @@ -36,4 +46,8 @@ fn main() { // div match if_test_this_function(6, fn_idx) { true => { assert_eq_opt(checked_div_128(a, b), expected); }, false => (), }; match if_test_this_function(7, fn_idx) { true => { assert!(eq_128(safe_div_128(a, b), unwrap(expected))); }, false => (), }; + + // gt, ge + match if_test_this_function(8, fn_idx) { true => { assert_bool_by_opt(gt_128(a, b), expected); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_bool_by_opt(ge_128(a, b), expected); }, false => (), }; }