Update rand and env_logger dependencies (#461)

* Update rand and env_logger dependencies

Just noticed that they're a bit behind, no other reason to update than
for update's sake here though.

* Make wasm-mutate tests more robust

Tweak some assertions to keep pumping the mutator with a different rng
to eventually find the right mutation, otherwise tweak some test
expectations.

* Fix wasm-mutate integration test

Author: alexcrichton

Cargo.toml

@@ -17,7 +17,7 @@ members = ['fuzz', 'crates/wasm-encoder', 'crates/fuzz-stats', 'crates/wasm-muta
 
 [dependencies]
 anyhow = "1.0"
-env_logger = "0.8"
+env_logger = "0.9"
 log = "0.4"
 clap = { version = "3.0", features = ['derive'] }
 tempfile = "3.2.0"

crates/wasm-mutate-stats/Cargo.toml

@@ -8,12 +8,12 @@ publish = false
 anyhow = "1.0"
 arbitrary = "1.0"
 num_cpus = "1.13"
-rand = { version = "0.7.3", features = ["small_rng"] }
+rand = { version = "0.8.0", features = ["small_rng"] }
 wasm-mutate = { path = '../wasm-mutate' }
 wasmprinter = { path = '../wasmprinter' }
 wasmparser = { path = "../wasmparser" }
 wasmtime = "0.32.0"
-env_logger = "0.8"
+env_logger = "0.9"
 itertools = "0.10.0"
 clap = "3.0"
 log = "0.4"

crates/wasm-mutate/Cargo.toml

@@ -11,12 +11,12 @@ clap = { optional = true, version = "3.0", features = ['derive'] }
 thiserror = "1.0.28"
 wasmparser = { version = "0.82.0", path = "../wasmparser" }
 wasm-encoder = { version = "0.9.0", path = "../wasm-encoder"}
-rand = { version = "0.7.3", features = ["small_rng"] }
+rand = { version = "0.8.0", features = ["small_rng"] }
 log = "0.4.14"
 egg = "0.6.0"
 
 [dev-dependencies]
 anyhow = "1"
 wat = { path = "../wat" }
 wasmprinter = { path = "../wasmprinter" }
-env_logger = "0.8"
+env_logger = "0.9"

crates/wasm-mutate/src/lib.rs

@@ -42,7 +42,7 @@ macro_rules! define_mutators {
             let m = $first;
 
             if m.can_mutate($self) {
-                match m.mutate($self) {
+                match m.clone().mutate($self) {
                     Ok(iter) => {
                         return Ok(Box::new(iter.into_iter().map(|r| r.map(|m| m.finish()))))
                     }
@@ -57,7 +57,7 @@ macro_rules! define_mutators {
                 let m = $rest;
 
                 if m.can_mutate($self) {
-                    match m.mutate($self) {
+                    match m.clone().mutate($self) {
                         Ok(iter) => {
                             return Ok(Box::new(iter.into_iter().map(|r| r.map(|m| m.finish()))))
                         }
@@ -73,7 +73,7 @@ macro_rules! define_mutators {
                 let m = $head;
 
                 if m.can_mutate($self) {
-                    match m.mutate($self) {
+                    match m.clone().mutate($self) {
                         Ok(iter) => {
                             return Ok(Box::new(iter.into_iter().map(|r| r.map(|m| m.finish()))))
                         }
@@ -91,7 +91,7 @@ macro_rules! define_mutators {
     ( $self: ident , ($first: expr , $( $tail: expr ,)* ) ) => {
         {
             let count = define_mutators!(@count $first , $($tail ,)*);
-            let discriminator:u32 = $self.rng().gen_range(0, count);
+            let discriminator:u32 = $self.rng().gen_range(0..count);
             define_mutators!(@expand $self, discriminator , 0 , $first , $($tail ,)*  . , );
         }
     };
@@ -316,8 +316,8 @@ impl<'wasm> WasmMutate<'wasm> {
         // subslice of data with a random slice of other data.
         //
         // First up start/end indices are picked.
-        let a = self.rng().gen_range(0, data.len() + 1);
-        let b = self.rng().gen_range(0, data.len() + 1);
+        let a = self.rng().gen_range(0..=data.len());
+        let b = self.rng().gen_range(0..=data.len());
         let start = a.min(b);
         let end = a.max(b);
 
@@ -331,7 +331,7 @@ impl<'wasm> WasmMutate<'wasm> {
         };
         let len = self
             .rng()
-            .gen_range(0, end - start + max_size.saturating_sub(data.len()) + 1);
+            .gen_range(0..=end - start + max_size.saturating_sub(data.len()));
 
         // With parameters chosen the `Vec::splice` method is used to replace
         // the data in the input.

crates/wasm-mutate/src/mutators.rs

@@ -89,9 +89,7 @@ pub trait Mutator {
     fn mutate<'a>(
         self,
         config: &'a mut WasmMutate,
-    ) -> Result<Box<dyn Iterator<Item = Result<Module>> + 'a>>
-    where
-        Self: Copy;
+    ) -> Result<Box<dyn Iterator<Item = Result<Module>> + 'a>>;
 
     /// What is this mutator's name?
     ///
@@ -107,7 +105,7 @@ pub type OperatorAndByteOffset<'a> = (Operator<'a>, usize);
 #[cfg(test)]
 fn match_mutation<T>(original: &str, mutator: T, expected: &str)
 where
-    T: Mutator + Copy,
+    T: Mutator + Clone,
 {
     WasmMutate::default().match_mutation(original, mutator, expected)
 }
@@ -116,11 +114,13 @@ impl WasmMutate<'_> {
     #[cfg(test)]
     fn match_mutation<T>(&mut self, original: &str, mutator: T, expected: &str)
     where
-        T: Mutator + Copy,
+        T: Mutator + Clone,
     {
         use crate::ErrorKind;
         use wasmparser::WasmFeatures;
 
+        drop(env_logger::try_init());
+
         let original = &wat::parse_str(original).unwrap();
 
         let expected = &wat::parse_str(expected).unwrap();
@@ -134,13 +134,16 @@ impl WasmMutate<'_> {
         assert!(can_mutate);
 
         let attempts = 100;
+        let mut last_mutation = None;
 
         for _ in 0..attempts {
             let mutation = match mutator
+                .clone()
                 .mutate(&mut config)
-                .and_then(|mut mutation| mutation.next().unwrap())
+                .map(|mut mutation| mutation.next())
             {
-                Ok(mutation) => mutation,
+                Ok(Some(mutation)) => mutation.unwrap(),
+                Ok(None) => continue,
                 Err(e) if matches!(e.kind(), ErrorKind::NoMutationsApplicable) => continue,
                 Err(e) => panic!("mutation error: {}", e),
             };
@@ -157,13 +160,27 @@ impl WasmMutate<'_> {
             // If it fails, it is probably an invalid
             // reformatting expected
             let text = wasmprinter::print_bytes(mutation_bytes).unwrap();
-            assert_eq!(text.trim(), expected_text.trim());
-            return;
+            if text.trim() == expected_text.trim() {
+                return;
+            }
+            log::debug!("skipping mutation {}", text);
+            last_mutation = Some(text);
         }
 
-        panic!(
-            "never found any applicable mutations after {} attempts",
-            attempts
-        );
+        match last_mutation {
+            Some(mutation) => {
+                panic!(
+                    "after {} attempts the last mutation:\n{:?}\n\n\
+                     did not match the expected mutation\n{:?}",
+                    attempts, mutation, expected_text
+                );
+            }
+            None => {
+                panic!(
+                    "never found any applicable mutations after {} attempts",
+                    attempts
+                );
+            }
+        }
     }
 }

crates/wasm-mutate/src/mutators/codemotion.rs

@@ -66,7 +66,7 @@ impl CodemotionMutator {
 
         let mut sectionreader = CodeSectionReader::new(original_code_section.data, 0)?;
         let function_count = sectionreader.get_count();
-        let function_to_mutate = config.rng().gen_range(0, function_count);
+        let function_to_mutate = config.rng().gen_range(0..function_count);
 
         // This split strategy will avoid very often mutating the first function
         // and very rarely mutating the last function
@@ -169,44 +169,12 @@ impl Mutator for CodemotionMutator {
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        info::ModuleInfo,
-        mutators::{codemotion::CodemotionMutator, Mutator},
-        WasmMutate,
-    };
-    use rand::{rngs::SmallRng, SeedableRng};
+    use crate::{mutators::codemotion::CodemotionMutator, WasmMutate};
 
     fn test_motion_mutator(original: &str, expected: &str, seed: u64) {
-        let _ = env_logger::try_init();
-
-        let mut wasmmutate = WasmMutate::default();
-        let original = &wat::parse_str(original).unwrap();
-
-        let mutator = CodemotionMutator; // the string is empty
-
-        let rnd = SmallRng::seed_from_u64(seed);
-        let info = ModuleInfo::new(original).unwrap();
-        wasmmutate.info = Some(info);
-        wasmmutate.rng = Some(rnd);
-
-        let can_mutate = mutator.can_mutate(&wasmmutate);
-
-        assert_eq!(can_mutate, true);
-
-        let mutated = mutator
-            .mutate(&mut wasmmutate)
-            .unwrap()
-            .next()
-            .unwrap()
-            .unwrap();
-
-        let mut validator = wasmparser::Validator::new();
-        let mutated_bytes = &mutated.finish();
-        let text = wasmprinter::print_bytes(mutated_bytes).unwrap();
-        crate::validate(&mut validator, mutated_bytes);
-        let expected_bytes = &wat::parse_str(expected).unwrap();
-        let expectedtext = wasmprinter::print_bytes(expected_bytes).unwrap();
-        assert_eq!(expectedtext, text);
+        let mut config = WasmMutate::default();
+        config.seed(seed);
+        config.match_mutation(original, CodemotionMutator, expected);
     }
 
     #[test]
@@ -319,6 +287,8 @@ mod tests {
                 end
                 if (result i32)
                     i32.const 50
+                else
+                    unreachable
                 end
             )
         )

crates/wasm-mutate/src/mutators/function_body_unreachable.rs

@@ -23,7 +23,7 @@ impl Mutator for FunctionBodyUnreachable {
         let mut reader = CodeSectionReader::new(code_section.data, 0)?;
 
         let count = reader.get_count();
-        let function_to_mutate = config.rng().gen_range(0, count);
+        let function_to_mutate = config.rng().gen_range(0..count);
 
         (0..count)
             .map(|i| {

crates/wasm-mutate/src/mutators/modify_data.rs

@@ -21,7 +21,7 @@ impl Mutator for ModifyDataMutator {
         let mut reader = DataSectionReader::new(config.info().get_data_section().data, 0)?;
 
         // Select an arbitrary data segment to modify.
-        let data_to_modify = config.rng().gen_range(0, reader.get_count());
+        let data_to_modify = config.rng().gen_range(0..reader.get_count());
 
         // Iterate over all data segments in the old data section and re-add
         // them to the `new_section` one-by-one.