From bafef68c56b89c3e55856320ac28fccb7fb98016 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Garillot?= <francois@garillot.net>
Date: Fri, 11 Jan 2019 12:57:34 -0800
Subject: [PATCH] Bumps rand to 0.6.3 & associated updates

---
 Cargo.toml |  5 +++--
 src/key.rs | 41 ++++++++++++++++++++++++++++++++---------
 src/lib.rs |  4 ++--
 3 files changed, 37 insertions(+), 13 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index b9cc39c..20bf1b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,11 +31,12 @@ default = []
 fuzztarget = []
 
 [dev-dependencies]
-rand = "0.4"
+rand = "0.6"
+rand_core = "0.4"
 serde_test = "1.0"
 
 [dependencies.rand]
-version = "0.4"
+version = "0.6"
 optional = true
 
 [dependencies.serde]
diff --git a/src/key.rs b/src/key.rs
index 896eaf9..2d90c2e 100644
--- a/src/key.rs
+++ b/src/key.rs
@@ -393,7 +393,8 @@ mod test {
     use super::{PublicKey, SecretKey};
     use super::super::constants;
 
-    use rand::{Rng, thread_rng};
+    use rand::{Error, ErrorKind, RngCore, thread_rng};
+    use rand_core::impls;
     use std::iter;
     use std::str::FromStr;
 
@@ -462,8 +463,9 @@ mod test {
     fn test_out_of_range() {
 
         struct BadRng(u8);
-        impl Rng for BadRng {
+        impl RngCore for BadRng {
             fn next_u32(&mut self) -> u32 { unimplemented!() }
+            fn next_u64(&mut self) -> u64 { unimplemented!() }
             // This will set a secret key to a little over the
             // group order, then decrement with repeated calls
             // until it returns a valid key
@@ -478,6 +480,9 @@ mod test {
                 data[31] = self.0;
                 self.0 -= 1;
             }
+            fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+                Ok(self.fill_bytes(dest))
+            }
         }
 
         let s = Secp256k1::new();
@@ -518,18 +523,28 @@ mod test {
     #[test]
     fn test_debug_output() {
         struct DumbRng(u32);
-        impl Rng for DumbRng {
+        impl RngCore for DumbRng {
             fn next_u32(&mut self) -> u32 {
                 self.0 = self.0.wrapping_add(1);
                 self.0
             }
+            fn next_u64(&mut self) -> u64 {
+                self.next_u32() as u64
+            }
+            fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), Error> {
+                Err(Error::new(ErrorKind::Unavailable, "not implemented"))
+            }
+
+            fn fill_bytes(&mut self, dest: &mut [u8]) {
+                impls::fill_bytes_via_next(self, dest);
+            }
         }
 
         let s = Secp256k1::new();
         let (sk, _) = s.generate_keypair(&mut DumbRng(0));
 
         assert_eq!(&format!("{:?}", sk),
-                   "SecretKey(0200000001000000040000000300000006000000050000000800000007000000)");
+                   "SecretKey(0100000000000000020000000000000003000000000000000400000000000000)");
     }
 
     #[test]
@@ -588,19 +603,29 @@ mod test {
     #[test]
     fn test_pubkey_serialize() {
         struct DumbRng(u32);
-        impl Rng for DumbRng {
+        impl RngCore for DumbRng {
             fn next_u32(&mut self) -> u32 {
                 self.0 = self.0.wrapping_add(1);
                 self.0
             }
+            fn next_u64(&mut self) -> u64 {
+                self.next_u32() as u64
+            }
+            fn try_fill_bytes(&mut self, _dest: &mut [u8]) -> Result<(), Error> {
+                Err(Error::new(ErrorKind::Unavailable, "not implemented"))
+            }
+
+            fn fill_bytes(&mut self, dest: &mut [u8]) {
+                impls::fill_bytes_via_next(self, dest);
+            }
         }
 
         let s = Secp256k1::new();
         let (_, pk1) = s.generate_keypair(&mut DumbRng(0));
         assert_eq!(&pk1.serialize_uncompressed()[..],
-                   &[4, 149, 16, 196, 140, 38, 92, 239, 179, 65, 59, 224, 230, 183, 91, 238, 240, 46, 186, 252, 175, 102, 52, 249, 98, 178, 123, 72, 50, 171, 196, 254, 236, 1, 189, 143, 242, 227, 16, 87, 247, 183, 162, 68, 237, 140, 92, 205, 151, 129, 166, 58, 111, 96, 123, 64, 180, 147, 51, 12, 209, 89, 236, 213, 206][..]);
+                   &[4, 124, 121, 49, 14, 253, 63, 197, 50, 39, 194, 107, 17, 193, 219, 108, 154, 126, 9, 181, 248, 2, 12, 149, 233, 198, 71, 149, 134, 250, 184, 154, 229, 185, 28, 165, 110, 27, 3, 162, 126, 238, 167, 157, 242, 221, 76, 251, 237, 34, 231, 72, 39, 245, 3, 191, 64, 111, 170, 117, 103, 82, 28, 102, 163][..]);
         assert_eq!(&pk1.serialize()[..],
-                   &[2, 149, 16, 196, 140, 38, 92, 239, 179, 65, 59, 224, 230, 183, 91, 238, 240, 46, 186, 252, 175, 102, 52, 249, 98, 178, 123, 72, 50, 171, 196, 254, 236][..]);
+                   &[3, 124, 121, 49, 14, 253, 63, 197, 50, 39, 194, 107, 17, 193, 219, 108, 154, 126, 9, 181, 248, 2, 12, 149, 233, 198, 71, 149, 134, 250, 184, 154, 229][..]);
     }
 
     #[test]
@@ -732,5 +757,3 @@ mod test {
         assert_tokens(&pk, &[Token::BorrowedBytes(&PK_BYTES[..])]);
     }
 }
-
-
diff --git a/src/lib.rs b/src/lib.rs
index 866b3cf..3bf2b49 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -136,6 +136,7 @@
 #![cfg_attr(all(test, feature = "unstable"), feature(test))]
 #[cfg(all(test, feature = "unstable"))] extern crate test;
 #[cfg(any(test, feature = "rand"))] pub extern crate rand;
+#[cfg(any(test))] extern crate rand_core;
 #[cfg(feature = "serde")] pub extern crate serde;
 #[cfg(all(test, feature = "serde"))] extern crate serde_test;
 
@@ -778,7 +779,7 @@ fn from_hex(hex: &str, target: &mut [u8]) -> Result<usize, ()> {
 
 #[cfg(test)]
 mod tests {
-    use rand::{Rng, thread_rng};
+    use rand::{RngCore, thread_rng};
     use std::str::FromStr;
 
     use key::{SecretKey, PublicKey};
@@ -1227,4 +1228,3 @@ mod benches {
         });
     }
 }
-