From 3ed16ddd0ffb1e283c8191658868557a12734382 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Wed, 5 Aug 2026 19:37:04 +0300 Subject: [PATCH 1/2] added assert_eq_bool --- simf/asserts_test.simf | 32 +++++++++++++++++++++++--------- simf/lib/asserts.simf | 5 +++++ tests/asserts_test.rs | 27 +++++++++++++++++++++++++++ 3 files changed, 55 insertions(+), 9 deletions(-) diff --git a/simf/asserts_test.simf b/simf/asserts_test.simf index fafd2f1..36e1708 100644 --- a/simf/asserts_test.simf +++ b/simf/asserts_test.simf @@ -1,6 +1,19 @@ use crate::lib::asserts::{ - assert_eq_1, assert_eq_8, assert_eq_16, assert_eq_32, assert_eq_64,assert_eq_128, assert_eq_256, - assert_none_1, assert_none_8, assert_none_16, assert_none_32, assert_none_64, assert_none_128, assert_none_256 + assert_eq_1, + assert_eq_8, + assert_eq_16, + assert_eq_32, + assert_eq_64, + assert_eq_128, + assert_eq_256, + assert_eq_bool, + assert_none_1, + assert_none_8, + assert_none_16, + assert_none_32, + assert_none_64, + assert_none_128, + assert_none_256 }; use crate::helper::if_test_this_function; @@ -36,13 +49,14 @@ fn main() { match if_test_this_function(4, fn_idx) { true => { assert_eq_64(unwrap(a_u64), unwrap(b_u64)); }, false => (), }; match if_test_this_function(5, fn_idx) { true => { assert_eq_128(unwrap(a_u128), unwrap(b_u128)); }, false => (), }; match if_test_this_function(6, fn_idx) { true => { assert_eq_256(unwrap(a_u256), unwrap(b_u256)); }, false => (), }; + match if_test_this_function(7, fn_idx) { true => { assert_eq_bool(::into(unwrap(a_u1)), ::into(unwrap(b_u1))); }, false => (), }; // Assert None - match if_test_this_function(7, fn_idx) { true => { assert_none_1(a_u1); }, false => (), }; - match if_test_this_function(8, fn_idx) { true => { assert_none_8(a_u8); }, false => (), }; - match if_test_this_function(9, fn_idx) { true => { assert_none_16(a_u16); }, false => (), }; - match if_test_this_function(10, fn_idx) { true => { assert_none_32(a_u32); }, false => (), }; - match if_test_this_function(11, fn_idx) { true => { assert_none_64(a_u64); }, false => (), }; - match if_test_this_function(12, fn_idx) { true => { assert_none_128(a_u128); }, false => (), }; - match if_test_this_function(13, fn_idx) { true => { assert_none_256(a_u256); }, false => (), }; + match if_test_this_function(8, fn_idx) { true => { assert_none_1(a_u1); }, false => (), }; + match if_test_this_function(9, fn_idx) { true => { assert_none_8(a_u8); }, false => (), }; + match if_test_this_function(10, fn_idx) { true => { assert_none_16(a_u16); }, false => (), }; + match if_test_this_function(11, fn_idx) { true => { assert_none_32(a_u32); }, false => (), }; + match if_test_this_function(12, fn_idx) { true => { assert_none_64(a_u64); }, false => (), }; + match if_test_this_function(13, fn_idx) { true => { assert_none_128(a_u128); }, false => (), }; + match if_test_this_function(14, fn_idx) { true => { assert_none_256(a_u256); }, false => (), }; } diff --git a/simf/lib/asserts.simf b/simf/lib/asserts.simf index 60c577c..63c4a9a 100644 --- a/simf/lib/asserts.simf +++ b/simf/lib/asserts.simf @@ -35,6 +35,11 @@ pub fn assert_eq_256(a: u256, b: u256) { assert!(jet::eq_256(a, b)); } +/// Asserts that two bool values are equal +pub fn assert_eq_bool(a: bool, b: bool) { + assert_eq_1(::into(a), ::into(b)); +} + /// Asserts that provided `Option` value is a `None` pub fn assert_none_1(val: Option) { assert!(is_none::(val)); diff --git a/tests/asserts_test.rs b/tests/asserts_test.rs index fad2ee3..e128ce9 100644 --- a/tests/asserts_test.rs +++ b/tests/asserts_test.rs @@ -19,6 +19,7 @@ enum FunctionToTest { AssertEq64, AssertEq128, AssertEq256, + AssertEqBool, AssertNone1, AssertNone8, @@ -113,6 +114,10 @@ fn build_witness(function: FunctionToTest, same: bool, none: bool) -> AssertsTes (witness.first_arg_u256, witness.second_arg_u256) = (Some([a as u8; 32]), Some([b as u8; 32])); } + FunctionToTest::AssertEqBool => { + let (a, b) = generate_uints_in_one_range(same, 0, 1u128); + (witness.first_arg_u1, witness.second_arg_u1) = (Some(a as u8), Some(b as u8)); + } FunctionToTest::AssertNone1 => { if none { witness.first_arg_u1 = None; @@ -315,6 +320,28 @@ mod asserts_test { ) } + #[simplex::test] + fn assert_eq_bool_happy_path(context: simplex::TestContext) -> anyhow::Result<()> { + run_assert( + &context, + FunctionToTest::AssertEqBool, + true, + false, + Expect::Ok, + ) + } + + #[simplex::test] + fn assert_eq_bool_unhappy_path(context: simplex::TestContext) -> anyhow::Result<()> { + run_assert( + &context, + FunctionToTest::AssertEqBool, + false, + false, + Expect::AssertFailed, + ) + } + // ---------- assert_none: happy = None arg, unhappy = Some arg ---------- #[simplex::test] fn assert_none_1_happy_path(context: simplex::TestContext) -> anyhow::Result<()> { From d970c3c4173ff7a0c4ee4ddbc21452e43ecb1d56 Mon Sep 17 00:00:00 2001 From: aritkulova Date: Wed, 5 Aug 2026 19:37:34 +0300 Subject: [PATCH 2/2] added convert functions for u1 --- simf/lib/u1/convert.simf | 42 +++++++++++ simf/u1_convert_test.simf | 84 +++++++++++++++++++++ tests/u1_convert_test.rs | 150 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 276 insertions(+) create mode 100644 simf/lib/u1/convert.simf create mode 100644 simf/u1_convert_test.simf create mode 100644 tests/u1_convert_test.rs diff --git a/simf/lib/u1/convert.simf b/simf/lib/u1/convert.simf new file mode 100644 index 0000000..f01b02e --- /dev/null +++ b/simf/lib/u1/convert.simf @@ -0,0 +1,42 @@ +/// Widening uint conversions + +/// Converts u1 to u8 +pub fn u1_to_u8(a: u1) -> u8 { + jet::left_pad_low_1_8(a) +} + +/// Converts u1 to u16 +pub fn u1_to_u16(a: u1) -> u16 { + jet::left_pad_low_1_16(a) +} + +/// Converts u1 to u32 +pub fn u1_to_u32(a: u1) -> u32 { + jet::left_pad_low_1_32(a) +} + +/// Converts u1 to u64 +pub fn u1_to_u64(a: u1) -> u64 { + jet::left_pad_low_1_64(a) +} + +/// Converts u1 to u128 +pub fn u1_to_u128(a: u1) -> u128 { + let a_u64: u64 = u1_to_u64(a); + + <(u64, u64)>::into((0, a_u64)) +} + +/// Converts u1 to u256 +pub fn u1_to_u256(a: u1) -> u256 { + let a_u128: u128 = u1_to_u128(a); + + <(u128, u128)>::into((0, a_u128)) +} + +/// Type conversions + +/// Converts u1 to bool +pub fn u1_to_bool(a: u1) -> bool { + ::into(a) +} diff --git a/simf/u1_convert_test.simf b/simf/u1_convert_test.simf new file mode 100644 index 0000000..a432dd9 --- /dev/null +++ b/simf/u1_convert_test.simf @@ -0,0 +1,84 @@ +use crate::lib::u1::convert::{ + u1_to_u8, + u1_to_u16, + u1_to_u32, + u1_to_u64, + u1_to_u128, + u1_to_u256, + u1_to_bool +}; +use crate::lib::u128::eq_128; +use crate::lib::asserts::assert_eq_bool; +use crate::helper::if_test_this_function; + +fn main() { + let fn_idx: u8 = witness::FUNCTION_INDEX; + + let a: u1 = witness::FIRST_ARG; + + let expected: u256 = witness::EXPECTED; + + match if_test_this_function(0, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let (_, _, _, expected): (u16, u16, u16, u16) = ::into(expected); + let (_, expected): (u8, u8) = ::into(expected); + + assert!(jet::eq_8(u1_to_u8(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(1, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let (_, _, _, expected): (u16, u16, u16, u16) = ::into(expected); + + assert!(jet::eq_16(u1_to_u16(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(2, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let (_, expected): (u32, u32) = ::into(expected); + + assert!(jet::eq_32(u1_to_u32(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(3, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + + assert!(jet::eq_64(u1_to_u64(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(4, fn_idx) { + true => { + let (_, expected): (u128, u128) = ::into(expected); + + assert!(eq_128(u1_to_u128(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(5, fn_idx) { + true => { + assert!(jet::eq_256(u1_to_u256(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(6, fn_idx) { + true => { + let expected_bool: bool = jet::eq_256(expected, 1); + assert_eq_bool(u1_to_bool(a), expected_bool); + }, + false => {}, + }; +} diff --git a/tests/u1_convert_test.rs b/tests/u1_convert_test.rs new file mode 100644 index 0000000..230acbf --- /dev/null +++ b/tests/u1_convert_test.rs @@ -0,0 +1,150 @@ +mod common; + +use primitive_types::U256; +use rand::Rng; + +use common::core::{Expect, run}; + +use simplicityhl_std::artifacts::u1_convert_test::U1ConvertTestProgram; +use simplicityhl_std::artifacts::u1_convert_test::derived_u1_convert_test::{ + U1ConvertTestArguments, U1ConvertTestWitness, +}; + +enum FunctionToTest { + U1ToU8, + U1ToU16, + U1ToU32, + U1ToU64, + U1ToU128, + U1ToU256, + U1ToBool, +} + +#[inline] +fn op(o: FunctionToTest) -> u8 { + o as u8 +} + +fn program() -> U1ConvertTestProgram { + U1ConvertTestProgram::new(U1ConvertTestArguments {}) +} + +fn build_witness(function: u8, a: u8, expected: [u8; 32]) -> U1ConvertTestWitness { + U1ConvertTestWitness { + function_index: function, + first_arg: a, + expected, + } +} + +mod u1_convert_test { + use super::*; + + #[simplex::test] + fn u1_convert_test_u1_to_u8(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness(op(FunctionToTest::U1ToU8), a, U256::from(a).to_big_endian()), + Expect::Ok, + ) + } + + #[simplex::test] + fn u1_convert_test_u1_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U1ToU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u1_convert_test_u1_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U1ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u1_convert_test_u1_to_u64(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U1ToU64), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u1_convert_test_u1_to_u128(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U1ToU128), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u1_convert_test_u1_to_u256(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U1ToU256), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u1_convert_test_split_u1_to_u1(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U1ToBool), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } +}