diff --git a/simf/lib/u8/convert.simf b/simf/lib/u8/convert.simf new file mode 100644 index 0000000..fee231c --- /dev/null +++ b/simf/lib/u8/convert.simf @@ -0,0 +1,49 @@ +/// Widening uint conversions + +/// Converts u8 to u16 +pub fn u8_to_u16(a: u8) -> u16 { + jet::left_pad_low_8_16(a) +} + +/// Converts u8 to u32 +pub fn u8_to_u32(a: u8) -> u32 { + jet::left_pad_low_8_32(a) +} + +/// Converts u8 to u64 +pub fn u8_to_u64(a: u8) -> u64 { + jet::left_pad_low_8_64(a) +} + +/// Converts u8 to u128 +pub fn u8_to_u128(a: u8) -> u128 { + let a_u64: u64 = u8_to_u64(a); + + <(u64, u64)>::into((0, a_u64)) +} + +/// Converts u8 to u256 +pub fn u8_to_u256(a: u8) -> u256 { + let a_u128: u128 = u8_to_u128(a); + + <(u128, u128)>::into((0, a_u128)) +} + +/// Splitting uint conversions + +/// Splits u8 into eight u1 +pub fn split_u8_to_u1(a: u8) -> (u1, u1, u1, u1, u1, u1, u1, u1) { + ::into(a) +} + +/// Narrowing uint conversions + +/// Converts u8 into u1. +/// Panics if the value does not fit in u1 +pub fn safe_u8_to_u1(a: u8) -> u1 { + let u1_max: u8 = jet::left_pad_low_1_8(jet::high_1()); + + assert!(jet::le_8(a, u1_max)); + + jet::rightmost_8_1(a) +} diff --git a/simf/lib/u8.simf b/simf/lib/u8/math.simf similarity index 100% rename from simf/lib/u8.simf rename to simf/lib/u8/math.simf diff --git a/simf/u8_convert_test.simf b/simf/u8_convert_test.simf new file mode 100644 index 0000000..7589160 --- /dev/null +++ b/simf/u8_convert_test.simf @@ -0,0 +1,114 @@ +use crate::lib::u8::convert::{ + u8_to_u16, + u8_to_u32, + u8_to_u64, + u8_to_u128, + u8_to_u256, + split_u8_to_u1, + safe_u8_to_u1 +}; +// use crate::lib::u256::{split_256_into_64}; TODO: uncomment when u256 functions are merged +use crate::lib::u128::eq_128; +use crate::lib::asserts::assert_eq_1; +use crate::helper::if_test_this_function; + +fn main() { + let fn_idx: u8 = witness::FUNCTION_INDEX; + + let a: u8 = 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); + + assert!(jet::eq_16(u8_to_u16(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(1, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let (_, expected): (u32, u32) = ::into(expected); + + assert!(jet::eq_32(u8_to_u32(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(2, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + + assert!(jet::eq_64(u8_to_u64(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(3, fn_idx) { + true => { + let (_, expected): (u128, u128) = ::into(expected); + + assert!(eq_128(u8_to_u128(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(4, fn_idx) { + true => { + assert!(jet::eq_256(u8_to_u256(a), expected)); + }, + false => {}, + }; + + match if_test_this_function(5, fn_idx) { + true => { + let ( + a7, + a6, + a5, + a4, + a3, + a2, + a1, + a0 + ): (u1, u1, u1, u1, u1, u1, u1, u1) = split_u8_to_u1(a); + + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u8 = jet::rightmost_64_8(expected); + let ( + expected7, + expected6, + expected5, + expected4, + expected3, + expected2, + expected1, + expected0 + ): (u1, u1, u1, u1, u1, u1, u1, u1) = ::into(expected); + + assert_eq_1(a7, expected7); + assert_eq_1(a6, expected6); + assert_eq_1(a5, expected5); + assert_eq_1(a4, expected4); + assert_eq_1(a3, expected3); + assert_eq_1(a2, expected2); + assert_eq_1(a1, expected1); + assert_eq_1(a0, expected0); + }, + false => {}, + }; + + match if_test_this_function(6, fn_idx) { + true => { + let (_, _, _, expected): (u64, u64, u64, u64) = ::into(expected); + let expected: u1 = jet::rightmost_64_1(expected); + + assert_eq_1(safe_u8_to_u1(a), expected); + }, + false => {}, + }; +} diff --git a/simf/u8_test.simf b/simf/u8_math_test.simf similarity index 68% rename from simf/u8_test.simf rename to simf/u8_math_test.simf index 37e8d32..3bd2eef 100644 --- a/simf/u8_test.simf +++ b/simf/u8_math_test.simf @@ -1,4 +1,15 @@ -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::u8::math::{ + 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::binary::not; use crate::helper::if_test_this_function; @@ -8,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_8(result), Some(e: u8) => assert_eq_8(unwrap(result), e), + None => assert_none_8(result), } } @@ -30,22 +41,22 @@ fn main() { let expected: Option = 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 => (), }; + 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 => (), }; + 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 => (), }; + 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 => (), }; + 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_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 => (), }; + 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 => {}, }; } diff --git a/tests/u8_convert_test.rs b/tests/u8_convert_test.rs new file mode 100644 index 0000000..6331249 --- /dev/null +++ b/tests/u8_convert_test.rs @@ -0,0 +1,170 @@ +mod common; + +use primitive_types::U256; +use rand::Rng; + +use common::core::{Expect, run}; + +use simplicityhl_std::artifacts::u8_convert_test::U8ConvertTestProgram; +use simplicityhl_std::artifacts::u8_convert_test::derived_u8_convert_test::{ + U8ConvertTestArguments, U8ConvertTestWitness, +}; + +enum FunctionToTest { + U8ToU16, + U8ToU32, + U8ToU64, + U8ToU128, + U8ToU256, + SplitU8ToU1, + SafeU8ToU1, +} + +#[inline] +fn op(o: FunctionToTest) -> u8 { + o as u8 +} + +fn program() -> U8ConvertTestProgram { + U8ConvertTestProgram::new(U8ConvertTestArguments {}) +} + +fn build_witness(function: u8, a: u8, expected: [u8; 32]) -> U8ConvertTestWitness { + U8ConvertTestWitness { + function_index: function, + first_arg: a, + expected, + } +} + +mod u8_convert_test { + use super::*; + + #[simplex::test] + fn u8_convert_test_u8_to_u16(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u8::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U8ToU16), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u8_convert_test_u8_to_u32(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u8::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U8ToU32), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u8_convert_test_u8_to_u64(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u8::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U8ToU64), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u8_convert_test_u8_to_u128(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u8::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U8ToU128), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u8_convert_test_u8_to_u256(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u8::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::U8ToU256), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u8_convert_test_split_u8_to_u1(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=u8::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SplitU8ToU1), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u8_convert_test_safe_u8_to_u1(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(0..=1); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU8ToU1), + a, + U256::from(a).to_big_endian(), + ), + Expect::Ok, + ) + } + + #[simplex::test] + fn u8_convert_test_safe_u8_to_u1_overflow(context: simplex::TestContext) -> anyhow::Result<()> { + let a = rand::thread_rng().gen_range(2..=u8::MAX); + + run( + &context, + program(), + build_witness( + op(FunctionToTest::SafeU8ToU1), + a, + U256::from(a).to_big_endian(), + ), + Expect::AssertFailed, + ) + } +} diff --git a/tests/u8_test.rs b/tests/u8_math_tests.rs similarity index 59% rename from tests/u8_test.rs rename to tests/u8_math_tests.rs index 90bfaff..2d5c120 100644 --- a/tests/u8_test.rs +++ b/tests/u8_math_tests.rs @@ -2,13 +2,15 @@ mod common; use common::uint::TestUint; -use simplicityhl_std::artifacts::u8_test::U8TestProgram; -use simplicityhl_std::artifacts::u8_test::derived_u8_test::{U8TestArguments, U8TestWitness}; +use simplicityhl_std::artifacts::u8_math_test::U8MathTestProgram; +use simplicityhl_std::artifacts::u8_math_test::derived_u8_math_test::{ + U8MathTestArguments, U8MathTestWitness, +}; // The only per-width code for the common operations. impl TestUint for u8 { - type Program = U8TestProgram; - type Witness = U8TestWitness; + type Program = U8MathTestProgram; + type Witness = U8MathTestWitness; const ZERO: u8 = 0; const ONE: u8 = 1; @@ -16,12 +18,12 @@ impl TestUint for u8 { const HALF_MAX: u8 = u8::MAX / 2; const MUL_BOUND: u8 = 1 << 4; // 2^(8/2) - fn program() -> U8TestProgram { - U8TestProgram::new(U8TestArguments {}) + fn program() -> U8MathTestProgram { + U8MathTestProgram::new(U8MathTestArguments {}) } - fn witness(op: u8, a: u8, b: u8, expected: Option) -> U8TestWitness { - U8TestWitness { + fn witness(op: u8, a: u8, b: u8, expected: Option) -> U8MathTestWitness { + U8MathTestWitness { function_index: op, first_arg: a, second_arg: b, @@ -30,7 +32,7 @@ impl TestUint for u8 { } } -mod u8_tests { +mod u8_math_tests { use super::*; // Stamps the 16 `#[simplex::test]` entry points for u8. Logic lives in common::uint.