Convert functions for u1

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(<u1>::into(unwrap(a_u1)), <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 => (), };
 }

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(<bool>::into(a), <bool>::into(b));
+}
+
 /// Asserts that provided `Option<u1>` value is a `None`
 pub fn assert_none_1(val: Option<u1>) {
     assert!(is_none::<u1>(val));

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 {
+    <u1>::into(a)
+}

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) = <u256>::into(expected);
+            let (_, _, _, expected): (u16, u16, u16, u16) = <u64>::into(expected);
+            let (_, expected): (u8, u8) = <u16>::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) = <u256>::into(expected);
+            let (_, _, _, expected): (u16, u16, u16, u16) = <u64>::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) = <u256>::into(expected);
+            let (_, expected): (u32, u32) = <u64>::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) = <u256>::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) = <u256>::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 => {},
+    };
+}

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<()> {

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,
+        )
+    }
+}