Merge branch 'upgrade-rand' of https://github.com/gilescope/rust-base64 into gilescope-upgrade-rand

Author: marshallpierce

Cargo.toml

@@ -17,9 +17,9 @@ name = "benchmarks"
 harness = false
 
 [dev-dependencies]
-criterion = "0.3.4"
-rand = "0.6.1"
-structopt = "0.3.21"
+criterion = "0.3.5"
+rand = { version = "0.8.4", features = ["small_rng"] }
+structopt = "0.3.23"
 # test fixtures for engine tests
 rstest = "0.11.0"
 rstest_reuse = "0.1.3"

README.md

@@ -121,3 +121,4 @@ cargo +nightly fuzz run decode_random
 ## License
 
 This project is dual-licensed under MIT and Apache 2.0.
+

benches/benchmarks.rs

@@ -11,7 +11,7 @@ use base64::{
 
 use base64::engine::DEFAULT_ENGINE;
 use criterion::{black_box, Bencher, BenchmarkId, Criterion, Throughput};
-use rand::{FromEntropy, Rng};
+use rand::{Rng, SeedableRng};
 use std::io::{self, Read, Write};
 
 fn do_decode_bench(b: &mut Bencher, &size: &usize) {

src/chunked_encoder.rs

@@ -108,7 +108,7 @@ impl<'a> Sink for StringSink<'a> {
 pub mod tests {
     use rand::{
         distributions::{Distribution, Uniform},
-        FromEntropy, Rng,
+        Rng, SeedableRng,
     };
 
     use crate::alphabet::STANDARD;

src/decode.rs

@@ -207,7 +207,7 @@ mod tests {
     use crate::tests::random_engine;
     use rand::{
         distributions::{Distribution, Uniform},
-        FromEntropy, Rng,
+        Rng, SeedableRng,
     };
 
     #[test]
@@ -329,7 +329,6 @@ mod tests {
         let mut decode_buf = Vec::new();
 
         let input_len_range = Uniform::new(0, 1000);
-
         let mut rng = rand::rngs::SmallRng::from_entropy();
 
         for _ in 0..10_000 {

src/encode.rs

@@ -247,7 +247,7 @@ mod tests {
     use crate::tests::random_engine;
     use rand::{
         distributions::{Distribution, Uniform},
-        FromEntropy, Rng,
+        Rng, SeedableRng,
     };
     use std;
     use std::str;

src/engine/tests.rs

@@ -1,7 +1,7 @@
 // rstest_reuse template functions have unused variables
 #![allow(unused_variables)]
 
-use rand::{self, distributions::Distribution, distributions::Uniform, FromEntropy, Rng};
+use rand::{self, distributions::Distribution, distributions::Uniform, Rng, SeedableRng};
 use rstest::rstest;
 use rstest_reuse::{apply, template};
 use std::iter;

src/read/decoder_tests.rs

@@ -94,7 +94,7 @@ fn handles_short_read_from_delegate() {
         b64.clear();
         decoded.clear();
 
-        let size = rng.gen_range(0, 10 * BUF_SIZE);
+        let size = rng.gen_range(0..(10 * BUF_SIZE));
         bytes.extend(iter::repeat(0).take(size));
         bytes.truncate(size);
         rng.fill_bytes(&mut bytes[..size]);
@@ -129,7 +129,7 @@ fn read_in_short_increments() {
         b64.clear();
         decoded.clear();
 
-        let size = rng.gen_range(0, 10 * BUF_SIZE);
+        let size = rng.gen_range(0..(10 * BUF_SIZE));
         bytes.extend(iter::repeat(0).take(size));
         // leave room to play around with larger buffers
         decoded.extend(iter::repeat(0).take(size * 3));
@@ -160,7 +160,7 @@ fn read_in_short_increments_with_short_delegate_reads() {
         b64.clear();
         decoded.clear();
 
-        let size = rng.gen_range(0, 10 * BUF_SIZE);
+        let size = rng.gen_range(0..(10 * BUF_SIZE));
         bytes.extend(iter::repeat(0).take(size));
         // leave room to play around with larger buffers
         decoded.extend(iter::repeat(0).take(size * 3));
@@ -197,7 +197,7 @@ fn reports_invalid_last_symbol_correctly() {
         b64.clear();
         b64_bytes.clear();
 
-        let size = rng.gen_range(1, 10 * BUF_SIZE);
+        let size = rng.gen_range(1..(10 * BUF_SIZE));
         bytes.extend(iter::repeat(0).take(size));
         decoded.extend(iter::repeat(0).take(size));
         rng.fill_bytes(&mut bytes[..]);
@@ -246,7 +246,7 @@ fn reports_invalid_byte_correctly() {
         b64.clear();
         decoded.clear();
 
-        let size = rng.gen_range(1, 10 * BUF_SIZE);
+        let size = rng.gen_range(1..(10 * BUF_SIZE));
         bytes.extend(iter::repeat(0).take(size));
         rng.fill_bytes(&mut bytes[..size]);
         assert_eq!(size, bytes.len());
@@ -255,7 +255,7 @@ fn reports_invalid_byte_correctly() {
 
         encode_engine_string(&bytes[..], &mut b64, &engine);
         // replace one byte, somewhere, with '*', which is invalid
-        let bad_byte_pos = rng.gen_range(0, &b64.len());
+        let bad_byte_pos = rng.gen_range(0..b64.len());
         let mut b64_bytes = b64.bytes().collect::<Vec<u8>>();
         b64_bytes[bad_byte_pos] = b'*';
 
@@ -311,7 +311,7 @@ fn consume_with_short_reads_and_validate<R: Read>(
 
             break;
         }
-        let decode_len = rng.gen_range(1, cmp::max(2, expected_bytes.len() * 2));
+        let decode_len = rng.gen_range(1..cmp::max(2, expected_bytes.len() * 2));
 
         let read = short_reader
             .read(&mut decoded[total_read..total_read + decode_len])
@@ -331,7 +331,7 @@ struct RandomShortRead<'a, 'b, R: io::Read, N: rand::Rng> {
 impl<'a, 'b, R: io::Read, N: rand::Rng> io::Read for RandomShortRead<'a, 'b, R, N> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
         // avoid 0 since it means EOF for non-empty buffers
-        let effective_len = cmp::min(self.rng.gen_range(1, 20), buf.len());
+        let effective_len = cmp::min(self.rng.gen_range(1..20), buf.len());
 
         self.delegate.read(&mut buf[..effective_len])
     }

src/tests.rs

@@ -7,7 +7,7 @@ use crate::engine::{Config, Engine};
 use rand::{
     distributions::{Distribution, Uniform},
     seq::SliceRandom,
-    FromEntropy, Rng,
+    Rng, SeedableRng,
 };
 
 #[test]

src/write/encoder_tests.rs

@@ -347,7 +347,7 @@ fn retrying_writes_that_error_with_interrupted_works() {
         stream_encoded.clear();
         normal_encoded.clear();
 
-        let orig_len: usize = rng.gen_range(100, 20_000);
+        let orig_len: usize = rng.gen_range(100..20_000);
         for _ in 0..orig_len {
             orig_data.push(rng.gen());
         }
@@ -370,7 +370,7 @@ fn retrying_writes_that_error_with_interrupted_works() {
             while bytes_consumed < orig_len {
                 // use short inputs since we want to use `extra` a lot as that's what needs rollback
                 // when errors occur
-                let input_len: usize = cmp::min(rng.gen_range(0, 10), orig_len - bytes_consumed);
+                let input_len: usize = cmp::min(rng.gen_range(0..10), orig_len - bytes_consumed);
 
                 retry_interrupted_write_all(
                     &mut stream_encoder,
@@ -411,7 +411,7 @@ fn writes_that_only_write_part_of_input_and_sometimes_interrupt_produce_correct_
         stream_encoded.clear();
         normal_encoded.clear();
 
-        let orig_len: usize = rng.gen_range(100, 20_000);
+        let orig_len: usize = rng.gen_range(100..20_000);
         for _ in 0..orig_len {
             orig_data.push(rng.gen());
         }
@@ -434,7 +434,7 @@ fn writes_that_only_write_part_of_input_and_sometimes_interrupt_produce_correct_
             let mut bytes_consumed = 0;
             while bytes_consumed < orig_len {
                 // use at most medium-length inputs to exercise retry logic more aggressively
-                let input_len: usize = cmp::min(rng.gen_range(0, 100), orig_len - bytes_consumed);
+                let input_len: usize = cmp::min(rng.gen_range(0..100), orig_len - bytes_consumed);
 
                 let res =
                     stream_encoder.write(&orig_data[bytes_consumed..bytes_consumed + input_len]);
@@ -490,7 +490,7 @@ fn do_encode_random_config_matches_normal_encode(max_input_len: usize) {
         stream_encoded.clear();
         normal_encoded.clear();
 
-        let orig_len: usize = rng.gen_range(100, 20_000);
+        let orig_len: usize = rng.gen_range(100..20_000);
         for _ in 0..orig_len {
             orig_data.push(rng.gen());
         }
@@ -505,7 +505,7 @@ fn do_encode_random_config_matches_normal_encode(max_input_len: usize) {
             let mut bytes_consumed = 0;
             while bytes_consumed < orig_len {
                 let input_len: usize =
-                    cmp::min(rng.gen_range(0, max_input_len), orig_len - bytes_consumed);
+                    cmp::min(rng.gen_range(0..max_input_len), orig_len - bytes_consumed);
 
                 // write a little bit of the data
                 stream_encoder
@@ -535,15 +535,15 @@ struct InterruptingWriter<'a, W: 'a + Write, R: 'a + Rng> {
 
 impl<'a, W: Write, R: Rng> Write for InterruptingWriter<'a, W, R> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        if self.rng.gen_range(0.0, 1.0) <= self.fraction {
+        if self.rng.gen_range(0.0..1.0) <= self.fraction {
             return Err(io::Error::new(io::ErrorKind::Interrupted, "interrupted"));
         }
 
         self.w.write(buf)
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        if self.rng.gen_range(0.0, 1.0) <= self.fraction {
+        if self.rng.gen_range(0.0..1.0) <= self.fraction {
             return Err(io::Error::new(io::ErrorKind::Interrupted, "interrupted"));
         }
 
@@ -563,17 +563,17 @@ struct PartialInterruptingWriter<'a, W: 'a + Write, R: 'a + Rng> {
 
 impl<'a, W: Write, R: Rng> Write for PartialInterruptingWriter<'a, W, R> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        if self.rng.gen_range(0.0, 1.0) > self.no_interrupt_fraction {
+        if self.rng.gen_range(0.0..1.0) > self.no_interrupt_fraction {
             return Err(io::Error::new(io::ErrorKind::Interrupted, "interrupted"));
         }
 
-        if self.rng.gen_range(0.0, 1.0) <= self.full_input_fraction || buf.len() == 0 {
+        if self.rng.gen_range(0.0..1.0) <= self.full_input_fraction || buf.len() == 0 {
             // pass through the buf untouched
             self.w.write(buf)
         } else {
             // only use a prefix of it
             self.w
-                .write(&buf[0..(self.rng.gen_range(0, buf.len() - 1))])
+                .write(&buf[0..(self.rng.gen_range(0..(buf.len() - 1)))])
         }
     }