diff --git a/simf/lib/u64/convert.simf b/simf/lib/u64/convert.simf new file mode 100644 index 0000000..8a7d985 --- /dev/null +++ b/simf/lib/u64/convert.simf @@ -0,0 +1,72 @@ +/// Widening uint conversions + +/// Converts u64 to u128 +pub fn u64_to_u128(a: u64) -> u128 { + <(u64, u64)>::into((0, a)) +} + +/// Converts u64 to u256 +pub fn u64_to_u256(a: u64) -> u256 { + let a_u128: u128 = u64_to_u128(a); + + <(u128, u128)>::into((0, a_u128)) +} + +/// Splitting uint conversions + +/// Splits u64 into eight u8 +pub fn split_u64_into_u8(a: u64) -> (u8, u8, u8, u8, u8, u8, u8, u8) { + ::into(a) +} + +/// Splits u64 into four u16 +pub fn split_u64_into_u16(a: u64) -> (u16, u16, u16, u16) { + ::into(a) +} + +/// Splits u64 into two u32 +pub fn split_u64_into_u32(a: u64) -> (u32, u32) { + ::into(a) +} + +/// Narrowing uint conversions + +/// Converts u64 into u1. +/// Panics if the value does not fit in u1 +pub fn safe_u64_to_u1(a: u64) -> u1 { + let u1_max: u64 = jet::left_pad_low_1_64(jet::high_1()); + + assert!(jet::le_64(a, u1_max)); + + jet::rightmost_64_1(a) +} + +/// Converts u64 into u8. +/// Panics if the value does not fit in u8 +pub fn safe_u64_to_u8(a: u64) -> u8 { + let u8_max: u64 = jet::left_pad_low_8_64(jet::high_8()); + + assert!(jet::le_64(a, u8_max)); + + jet::rightmost_64_8(a) +} + +/// Converts u64 into u16. +/// Panics if the value does not fit in u16 +pub fn safe_u64_to_u16(a: u64) -> u16 { + let u16_max: u64 = jet::left_pad_low_16_64(jet::high_16()); + + assert!(jet::le_64(a, u16_max)); + + jet::rightmost_64_16(a) +} + +/// Converts u64 into u32. +/// Panics if the value does not fit in u32 +pub fn safe_u64_to_u32(a: u64) -> u32 { + let u32_max: u64 = jet::left_pad_low_32_64(jet::high_32()); + + assert!(jet::le_64(a, u32_max)); + + jet::rightmost_64_32(a) +} diff --git a/simf/lib/u64.simf b/simf/lib/u64/math.simf similarity index 94% rename from simf/lib/u64.simf rename to simf/lib/u64/math.simf index f3fd3da..77fc4aa 100644 --- a/simf/lib/u64.simf +++ b/simf/lib/u64/math.simf @@ -67,8 +67,3 @@ pub fn gt_64(a: u64, b: u64) -> bool { pub fn ge_64(a: u64, b: u64) -> bool { jet::le_64(b, a) } - -/// Widen `u64` to a `u256` scalar. -pub fn u64_into_u256(val: u64) -> u256 { - <(u64, u64, u64, u64)>::into((0, 0, 0, val)) -} diff --git a/simf/u64_convert_test.simf b/simf/u64_convert_test.simf new file mode 100644 index 0000000..00d651e --- /dev/null +++ b/simf/u64_convert_test.simf @@ -0,0 +1,154 @@ +use crate::lib::u64::convert::{ + u64_to_u128, + u64_to_u256, + split_u64_into_u8, + split_u64_into_u16, + split_u64_into_u32, + safe_u64_to_u1, + safe_u64_to_u8, + safe_u64_to_u16, + safe_u64_to_u32 +}; +use crate::lib::asserts::{ + assert_eq_1, + assert_eq_8, + assert_eq_16, + assert_eq_32, + assert_eq_128, + assert_eq_256 +}; +use crate::helper::if_test_this_function; + +fn main() { + let fn_idx: u8 = witness::FUNCTION_INDEX; + + let a: u64 = witness::FIRST_ARG; + + let expected: u256 = witness::EXPECTED; + + match if_test_this_function(0, fn_idx) { + true => { + let (_, expected): (u128, u128) = ::into(expected); + + assert_eq_128(u64_to_u128(a), expected); + }, + false => {}, + }; + + match if_test_this_function(1, fn_idx) { + true => { + assert_eq_256(u64_to_u256(a), expected); + }, + false => {}, + }; + + match if_test_this_function(2, fn_idx) { + true => { + let ( + a7, + a6, + a5, + a4, + a3, + a2, + a1, + a0 + ): (u8, u8, u8, u8, u8, u8, u8, u8) = split_u64_into_u8(a); + + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let ( + expected7, + expected6, + expected5, + expected4, + expected3, + expected2, + expected1, + expected0 + ): (u8, u8, u8, u8, u8, u8, u8, u8) = ::into(expected); + + assert_eq_8(a7, expected7); + assert_eq_8(a6, expected6); + assert_eq_8(a5, expected5); + assert_eq_8(a4, expected4); + assert_eq_8(a3, expected3); + assert_eq_8(a2, expected2); + assert_eq_8(a1, expected1); + assert_eq_8(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(3, fn_idx) { + true => { + let (a3, a2, a1, a0): (u16, u16, u16, u16) = split_u64_into_u16(a); + + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let ( + expected3, + expected2, + expected1, + expected0 + ): (u16, u16, u16, u16) = ::into(expected); + + assert_eq_16(a3, expected3); + assert_eq_16(a2, expected2); + assert_eq_16(a1, expected1); + assert_eq_16(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(4, fn_idx) { + true => { + let (a1, a0): (u32, u32) = split_u64_into_u32(a); + + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let (expected1, expected0): (u32, u32) = ::into(expected); + + assert_eq_32(a1, expected1); + assert_eq_32(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(5, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u1 = jet::rightmost_64_1(expected); + + assert_eq_1(safe_u64_to_u1(a), expected); + }, + false => {}, + }; + + match if_test_this_function(6, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u8 = jet::rightmost_64_8(expected); + + assert_eq_8(safe_u64_to_u8(a), expected); + }, + false => {}, + }; + + match if_test_this_function(7, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u16 = jet::rightmost_64_16(expected); + + assert_eq_16(safe_u64_to_u16(a), expected); + }, + false => {}, + }; + + match if_test_this_function(8, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u32 = jet::rightmost_64_32(expected); + + assert_eq_32(safe_u64_to_u32(a), expected); + }, + false => {}, + }; +} diff --git a/simf/u64_test.simf b/simf/u64_math_test.simf similarity index 85% rename from simf/u64_test.simf rename to simf/u64_math_test.simf index 879215f..0866a57 100644 --- a/simf/u64_test.simf +++ b/simf/u64_math_test.simf @@ -1,6 +1,14 @@ -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, u64_into_u256, +use crate::lib::u64::math::{ + 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::binary::not; @@ -11,8 +19,8 @@ use crate::helper::if_test_this_function; /// witness value carries both, removing the need for a separate overflow flag. fn assert_eq_opt(result: Option, expected: Option) { match expected { - None => assert_none_64(result), Some(e: u64) => assert_eq_64(unwrap(result), e), + None => assert_none_64(result), } } @@ -32,9 +40,6 @@ fn main() { let b: u64 = witness::SECOND_ARG; let expected: Option = witness::EXPECTED; - let expected_widen: u256 = witness::EXPECTED_WIDEN; - - // add 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 => (), }; @@ -54,7 +59,4 @@ fn main() { // gt, ge 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 => (), }; - - // Custom - match if_test_this_function(192, fn_idx) { true => { assert!(jet::eq_256(u64_into_u256(a), expected_widen)); }, false => (), }; } diff --git a/tests/u64_convert_test.rs b/tests/u64_convert_test.rs new file mode 100644 index 0000000..1a847f8 --- /dev/null +++ b/tests/u64_convert_test.rs @@ -0,0 +1,260 @@ +mod common; + +use primitive_types::U256; +use rand::Rng; + +use common::core::{Expect, run}; + +use simplicityhl_std::artifacts::u64_convert_test::U64ConvertTestProgram; +use simplicityhl_std::artifacts::u64_convert_test::derived_u64_convert_test::{ + U64ConvertTestArguments, U64ConvertTestWitness, +}; + +enum FunctionToTest { + U64ToU128, + U64ToU256, + SplitU64IntoU8, + SplitU64IntoU16, + SplitU64IntoU32, + SafeU64ToU1, + SafeU64ToU8, + SafeU64ToU16, + SafeU64ToU32, +} + +#[inline] +fn op(o: FunctionToTest) -> u8 { + o as u8 +} + +fn program() -> U64ConvertTestProgram { + U64ConvertTestProgram::new(U64ConvertTestArguments {}) +} + +fn build_witness(function: u8, a: u64, expected: [u8; 32]) -> U64ConvertTestWitness { + U64ConvertTestWitness { + function_index: function, + first_arg: a, + expected, + } +} + +mod u64_convert_test { + use super::*; + + #[simplex::test] + fn u64_convert_test_u64_to_u128(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U64ToU128), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_u64_to_u256(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U64ToU256), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_split_u64_into_u8(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU64IntoU8), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_split_u64_into_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU64IntoU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_split_u64_into_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU64IntoU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u1(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU1), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u1_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(2..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU1), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u8(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u8::MAX as u64); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU8), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u8_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u8::MAX as u64 + 1..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU8), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u16::MAX as u64); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u16_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u16::MAX as u64 + 1..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u32::MAX as u64); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u64_convert_test_safe_u64_to_u32_overflow( + context: simplex::TestContext, + ) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(u32::MAX as u64 + 1..=u64::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU64ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } +} diff --git a/tests/u64_math_test.rs b/tests/u64_math_test.rs new file mode 100644 index 0000000..91214e6 --- /dev/null +++ b/tests/u64_math_test.rs @@ -0,0 +1,40 @@ +mod common; + +use common::uint::TestUint; + +use simplicityhl_std::artifacts::u64_math_test::U64MathTestProgram; +use simplicityhl_std::artifacts::u64_math_test::derived_u64_math_test::{ + U64MathTestArguments, U64MathTestWitness, +}; + +// The only per-width code for the common operations. +impl TestUint for u64 { + type Program = U64MathTestProgram; + type Witness = U64MathTestWitness; + + 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) + + fn program() -> U64MathTestProgram { + U64MathTestProgram::new(U64MathTestArguments {}) + } + + fn witness(op: u8, a: u64, b: u64, expected: Option) -> U64MathTestWitness { + U64MathTestWitness { + function_index: op, + first_arg: a, + second_arg: b, + expected, + } + } +} + +mod u64_math_tests { + use super::*; + + // Stamps the 22 `#[simplex::test]` entry points for u64. Logic lives in common::uint. + uint_tests!(u64); +} diff --git a/tests/u64_test.rs b/tests/u64_test.rs deleted file mode 100644 index bb30a03..0000000 --- a/tests/u64_test.rs +++ /dev/null @@ -1,75 +0,0 @@ -mod common; - -use common::uint::TestUint; - -use simplicityhl_std::artifacts::u64_test::U64TestProgram; -use simplicityhl_std::artifacts::u64_test::derived_u64_test::{U64TestArguments, U64TestWitness}; - -use crate::common::uint::CUSTOM_BASE; - -// The only per-width code for the common operations. -impl TestUint for u64 { - type Program = U64TestProgram; - type Witness = U64TestWitness; - - 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) - - fn program() -> U64TestProgram { - U64TestProgram::new(U64TestArguments {}) - } - - fn witness(op: u8, a: u64, b: u64, expected: Option) -> U64TestWitness { - U64TestWitness { - function_index: op, - first_arg: a, - second_arg: b, - expected, - ..Default::default() - } - } -} - -enum FunctionToTest { - U64Widen, -} - -#[inline] -fn op(o: FunctionToTest) -> u8 { - o as u8 + CUSTOM_BASE -} - -mod u64_tests { - use rand::Rng as _; - - use crate::FunctionToTest::U64Widen; - use crate::common::core::{Expect, run}; - - use super::*; - - // Stamps the 22 `#[simplex::test]` entry points for u64. Logic lives in common::uint. - uint_tests!(u64); - - #[simplex::test] - fn u64_into_u256(context: simplex::TestContext) -> anyhow::Result<()> { - let a = rand::thread_rng().gen_range(0..=u64::MAX); - - let mut expected_widen: [u8; 32] = [0u8; 32]; - expected_widen[24..32].copy_from_slice(&a.to_be_bytes()); - - run( - &context, - ::program(), - U64TestWitness { - function_index: op(U64Widen), - first_arg: a, - expected_widen, - ..Default::default() - }, - Expect::Ok, - ) - } -}