simplex: update ui tests with random value generation

Author: ikripaka

crates/simplex/tests/ui/array_tr_storage.rs

@@ -1,10 +1,13 @@
 use simplex::include_simf;
-use simplex::program::{ArgumentsTrait, WitnessTrait, RandomArguments, RandomWitness};
-
+use simplex::mutantesting::{generate_value_by_ty, generate_value_by_ty_iterative};
 use simplex::program::Program;
+use simplex::program::{ArgumentsTrait, RandomArguments, RandomWitness, WitnessTrait};
 use simplex::provider::SimplicityNetwork;
-use simplex::simplicityhl::elements::Script;
 use simplex::simplicityhl::elements::secp256k1_zkp::XOnlyPublicKey;
+use simplex::simplicityhl::elements::Script;
+use simplex::simplicityhl::{Arguments, WitnessValues};
+use simplex::rand::RngCore;
+
 #[derive(Clone)]
 pub struct ArrayTrStorageProgram {
     program: Program,
@@ -66,9 +69,10 @@ impl AsMut<Program> for ArrayTrStorageProgram {
 include_simf!("../../../../crates/simplex/tests/ui_simfs/array_tr_storage.simf");
 
 fn main() -> Result<(), String> {
-    test_e2e_behaviour()?;
-    test_default()?;
-    test_e2e_random_behaviour()?;
+    let _ = test_e2e_behaviour()?;
+    let _ = test_default()?;
+    let _ = test_e2e_random_behaviour()?;
+    let _ = test_e2e_random_value_generation_behaviour()?;
 
     Ok(())
 }
@@ -101,39 +105,101 @@ fn test_default() -> Result<(), String> {
     Ok(())
 }
 
-fn test_e2e_random_behaviour() -> Result<(), String>{
+fn test_e2e_random_behaviour() -> Result<(), String> {
     for seed in 0..32 {
         use simplex::rand::{rngs::StdRng, SeedableRng};
 
         let mut rng = StdRng::seed_from_u64(seed);
 
-        let original_witness =
-            derived_array_tr_storage::ArrayTrStorageWitness::generate_witness_raw(&mut rng);
+        let original_witness = derived_array_tr_storage::ArrayTrStorageWitness::generate_witness_raw(&mut rng);
 
         let witness_values = original_witness.build_witness();
-        let recovered_witness =
-            derived_array_tr_storage::ArrayTrStorageWitness::from_witness(&witness_values)?;
+        let recovered_witness = derived_array_tr_storage::ArrayTrStorageWitness::from_witness(&witness_values)?;
         assert_eq!(original_witness, recovered_witness);
 
         rng = StdRng::seed_from_u64(seed);
-        let rand_raw_witness_values =
-            derived_array_tr_storage::ArrayTrStorageWitness::generate_witness(&mut rng);
+        let rand_raw_witness_values = derived_array_tr_storage::ArrayTrStorageWitness::generate_witness(&mut rng);
         assert_eq!(witness_values, rand_raw_witness_values);
 
         rng = StdRng::seed_from_u64(seed);
-        let original_arguments =
-            derived_array_tr_storage::ArrayTrStorageArguments::generate_arguments_raw(&mut rng);
+        let original_arguments = derived_array_tr_storage::ArrayTrStorageArguments::generate_arguments_raw(&mut rng);
 
         let arguments_values = original_arguments.build_arguments();
-        let recovered_arguments =
-            derived_array_tr_storage::ArrayTrStorageArguments::from_arguments(&arguments_values)?;
+        let recovered_arguments = derived_array_tr_storage::ArrayTrStorageArguments::from_arguments(&arguments_values)?;
         assert_eq!(original_arguments, recovered_arguments);
 
         rng = StdRng::seed_from_u64(seed);
-        let rand_raw_witness_values =
-            derived_array_tr_storage::ArrayTrStorageArguments::generate_arguments(&mut rng);
+        let rand_raw_witness_values = derived_array_tr_storage::ArrayTrStorageArguments::generate_arguments(&mut rng);
         assert_eq!(arguments_values, rand_raw_witness_values);
-    };
+    }
 
     Ok(())
-}
+}
+
+fn test_e2e_random_value_generation_behaviour() -> Result<(), String> {
+    for seed in 0..32 {
+        use simplex::rand::{rngs::StdRng, SeedableRng};
+
+        let mut rng = StdRng::seed_from_u64(seed);
+
+        {
+            let witness_values = derived_array_tr_storage::ArrayTrStorageWitness::generate_witness(&mut rng);
+
+            let witness_values = regenerate_witness_values(&witness_values, &mut rng);
+            let _ = derived_array_tr_storage::ArrayTrStorageWitness::from_witness(&witness_values)?;
+
+            let witness_values = regenerate_witness_values_iterative(&witness_values, &mut rng);
+            let _ = derived_array_tr_storage::ArrayTrStorageWitness::from_witness(&witness_values)?;
+        }
+
+        {
+            let arguments_values = derived_array_tr_storage::ArrayTrStorageArguments::generate_arguments(&mut rng);
+
+            let arguments_values = regenerate_arguments_values(&arguments_values, &mut rng);
+            let _ = derived_array_tr_storage::ArrayTrStorageArguments::from_arguments(&arguments_values)?;
+
+            let arguments_values = regenerate_arguments_values_iterative(&arguments_values, &mut rng);
+            let _ = derived_array_tr_storage::ArrayTrStorageArguments::from_arguments(&arguments_values)?;
+        }
+    }
+    Ok(())
+}
+
+fn regenerate_witness_values(wit: &WitnessValues, rng: &mut dyn RngCore) -> WitnessValues {
+    use std::collections::HashMap;
+    let mut map: HashMap<_,_> = Default::default();
+    for (name, val) in wit.iter() {
+        map.insert(name.clone(), generate_value_by_ty(val.ty(), rng));
+    }
+    WitnessValues::from(map)
+}
+
+fn regenerate_arguments_values(args: &Arguments, rng: &mut dyn RngCore) -> Arguments {
+    use std::collections::HashMap;
+
+    let mut map: HashMap<_,_> = Default::default();
+    for (name, val) in args.iter() {
+        map.insert(name.clone(), generate_value_by_ty(val.ty(), rng));
+    }
+    Arguments::from(map)
+}
+
+fn regenerate_witness_values_iterative(wit: &WitnessValues, rng: &mut dyn RngCore) -> WitnessValues {
+    use std::collections::HashMap;
+
+    let mut map: HashMap<_,_> = Default::default();
+    for (name, val) in wit.iter() {
+        map.insert(name.clone(), generate_value_by_ty_iterative(val.ty(), rng));
+    }
+    WitnessValues::from(map)
+}
+
+fn regenerate_arguments_values_iterative(args: &Arguments, rng: &mut dyn RngCore) -> Arguments {
+    use std::collections::HashMap;
+
+    let mut map: HashMap<_,_> = Default::default();
+    for (name, val) in args.iter() {
+        map.insert(name.clone(), generate_value_by_ty_iterative(val.ty(), rng));
+    }
+    Arguments::from(map)
+}

crates/simplex/tests/ui/bytes32_tr_storage.rs

@@ -1,10 +1,13 @@
 use simplex::include_simf;
-use simplex::program::{ArgumentsTrait, RandomArguments, RandomWitness, WitnessTrait};
-
+use simplex::mutantesting::{generate_value_by_ty, generate_value_by_ty_iterative};
 use simplex::program::Program;
+use simplex::program::{ArgumentsTrait, RandomArguments, RandomWitness, WitnessTrait};
 use simplex::provider::SimplicityNetwork;
-use simplex::simplicityhl::elements::Script;
 use simplex::simplicityhl::elements::secp256k1_zkp::XOnlyPublicKey;
+use simplex::simplicityhl::elements::Script;
+use simplex::simplicityhl::{Arguments, WitnessValues};
+use simplex::rand::RngCore;
+
 #[derive(Clone)]
 pub struct Bytes32TrStorageProgram {
     program: Program,
@@ -67,8 +70,9 @@ include_simf!("../../../../crates/simplex/tests/ui_simfs/bytes32_tr_storage.simf
 
 fn main() -> Result<(), String> {
     let _ = test_e2e_behaviour()?;
-    let _ = test_default();
-    let _ = test_e2e_random_behaviour();
+    let _ = test_default()?;
+    let _ = test_e2e_random_behaviour()?;
+    let _ = test_e2e_random_value_generation_behaviour()?;
 
     Ok(())
 }
@@ -77,15 +81,13 @@ fn test_e2e_behaviour() -> Result<(), String> {
     let original_witness = derived_bytes32_tr_storage::Bytes32TrStorageWitness::default();
 
     let witness_values = original_witness.build_witness();
-    let recovered_witness =
-        derived_bytes32_tr_storage::Bytes32TrStorageWitness::from_witness(&witness_values)?;
+    let recovered_witness = derived_bytes32_tr_storage::Bytes32TrStorageWitness::from_witness(&witness_values)?;
     assert_eq!(original_witness, recovered_witness);
 
     let original_arguments = derived_bytes32_tr_storage::Bytes32TrStorageArguments::default();
 
     let arguments_values = original_arguments.build_arguments();
-    let recovered_arguments =
-        derived_bytes32_tr_storage::Bytes32TrStorageArguments::from_arguments(&arguments_values)?;
+    let recovered_arguments = derived_bytes32_tr_storage::Bytes32TrStorageArguments::from_arguments(&arguments_values)?;
     assert_eq!(original_arguments, recovered_arguments);
 
     Ok(())
@@ -109,17 +111,14 @@ fn test_e2e_random_behaviour() -> Result<(), String> {
 
         let mut rng = StdRng::seed_from_u64(seed);
 
-        let original_witness =
-            derived_bytes32_tr_storage::Bytes32TrStorageWitness::generate_witness_raw(&mut rng);
+        let original_witness = derived_bytes32_tr_storage::Bytes32TrStorageWitness::generate_witness_raw(&mut rng);
 
         let witness_values = original_witness.build_witness();
-        let recovered_witness =
-            derived_bytes32_tr_storage::Bytes32TrStorageWitness::from_witness(&witness_values)?;
+        let recovered_witness = derived_bytes32_tr_storage::Bytes32TrStorageWitness::from_witness(&witness_values)?;
         assert_eq!(original_witness, recovered_witness);
 
         rng = StdRng::seed_from_u64(seed);
-        let rand_raw_witness_values =
-            derived_bytes32_tr_storage::Bytes32TrStorageWitness::generate_witness(&mut rng);
+        let rand_raw_witness_values = derived_bytes32_tr_storage::Bytes32TrStorageWitness::generate_witness(&mut rng);
         assert_eq!(witness_values, rand_raw_witness_values);
 
         rng = StdRng::seed_from_u64(seed);
@@ -138,3 +137,71 @@ fn test_e2e_random_behaviour() -> Result<(), String> {
     }
     Ok(())
 }
+
+fn test_e2e_random_value_generation_behaviour() -> Result<(), String> {
+    for seed in 0..32 {
+        use simplex::rand::{rngs::StdRng, SeedableRng};
+
+        let mut rng = StdRng::seed_from_u64(seed);
+
+        {
+            let witness_values = derived_bytes32_tr_storage::Bytes32TrStorageWitness::generate_witness(&mut rng);
+
+            let witness_values = regenerate_witness_values(&witness_values, &mut rng);
+            let _ = derived_bytes32_tr_storage::Bytes32TrStorageWitness::from_witness(&witness_values)?;
+
+            let witness_values = regenerate_witness_values_iterative(&witness_values, &mut rng);
+            let _ = derived_bytes32_tr_storage::Bytes32TrStorageWitness::from_witness(&witness_values)?;
+        }
+
+        {
+            let arguments_values = derived_bytes32_tr_storage::Bytes32TrStorageArguments::generate_arguments(&mut rng);
+
+            let arguments_values = regenerate_arguments_values(&arguments_values, &mut rng);
+            let _ = derived_bytes32_tr_storage::Bytes32TrStorageArguments::from_arguments(&arguments_values)?;
+
+            let arguments_values = regenerate_arguments_values_iterative(&arguments_values, &mut rng);
+            let _ = derived_bytes32_tr_storage::Bytes32TrStorageArguments::from_arguments(&arguments_values)?;
+        }
+    }
+    Ok(())
+}
+
+fn regenerate_witness_values(wit: &WitnessValues, rng: &mut dyn RngCore) -> WitnessValues {
+    use std::collections::HashMap;
+    let mut map: HashMap<_,_> = Default::default();
+    for (name, val) in wit.iter() {
+        map.insert(name.clone(), generate_value_by_ty(val.ty(), rng));
+    }
+    WitnessValues::from(map)
+}
+
+fn regenerate_arguments_values(args: &Arguments, rng: &mut dyn RngCore) -> Arguments {
+    use std::collections::HashMap;
+
+    let mut map: HashMap<_,_> = Default::default();
+    for (name, val) in args.iter() {
+        map.insert(name.clone(), generate_value_by_ty(val.ty(), rng));
+    }
+    Arguments::from(map)
+}
+
+fn regenerate_witness_values_iterative(wit: &WitnessValues, rng: &mut dyn RngCore) -> WitnessValues {
+    use std::collections::HashMap;
+
+    let mut map: HashMap<_,_> = Default::default();
+    for (name, val) in wit.iter() {
+        map.insert(name.clone(), generate_value_by_ty_iterative(val.ty(), rng));
+    }
+    WitnessValues::from(map)
+}
+
+fn regenerate_arguments_values_iterative(args: &Arguments, rng: &mut dyn RngCore) -> Arguments {
+    use std::collections::HashMap;
+
+    let mut map: HashMap<_,_> = Default::default();
+    for (name, val) in args.iter() {
+        map.insert(name.clone(), generate_value_by_ty_iterative(val.ty(), rng));
+    }
+    Arguments::from(map)
+}