Enable running tests without an allocator

Currently we always run tests with "std" enabled. It is currently not
possible to run the tests without an allocator but there is no reason
that we should not be able to run allocation free tests without an
allocator, doing so is better because it tests our claim that the lib
can be used without an allocator.

Author: tcharding

src/hash160.rs

@@ -104,20 +104,20 @@ impl HashTrait for Hash {
 
 #[cfg(test)]
 mod tests {
-    use hash160;
-    use hex::{FromHex, ToHex};
-    use Hash;
-    use HashEngine;
-
-    #[derive(Clone)]
-    struct Test {
-        input: Vec<u8>,
-        output: Vec<u8>,
-        output_str: &'static str,
-    }
-
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn test() {
+        use {hash160, Hash, HashEngine};
+        use hex::{FromHex, ToHex};
+
+        #[derive(Clone)]
+        #[cfg(any(feature = "std", feature = "alloc"))]
+        struct Test {
+            input: Vec<u8>,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
         let tests = vec![
             // Uncompressed pubkey obtained from Bitcoin key; data from validateaddress
             Test {
@@ -161,8 +161,8 @@ mod tests {
     #[cfg(feature = "serde")]
     #[test]
     fn ripemd_serde() {
-
         use serde_test::{Configure, Token, assert_tokens};
+        use {hash160, Hash};
 
         static HASH_BYTES: [u8; 20] = [
             0x13, 0x20, 0x72, 0xdf,

src/hex.rs

@@ -274,6 +274,7 @@ mod tests {
     use core::fmt;
 
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn hex_roundtrip() {
         let expected = "0123456789abcdef";
         let expected_up = "0123456789ABCDEF";
@@ -361,6 +362,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn hex_error() {
         let oddlen = "0123456789abcdef0";
         let badchar1 = "Z123456789abcdef";

src/hmac.rs

@@ -239,19 +239,18 @@ impl<'de, T: HashTrait + Deserialize<'de>> Deserialize<'de> for Hmac<T> {
 
 #[cfg(test)]
 mod tests {
-    use sha256;
-    #[cfg(feature = "serde")] use sha512;
-    use {Hash, HashEngine, Hmac, HmacEngine};
-
-    #[derive(Clone)]
-    struct Test {
-        key: Vec<u8>,
-        input: Vec<u8>,
-        output: Vec<u8>,
-    }
-
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn test() {
+        use {sha256, HashEngine, HmacEngine, Hash, Hmac};
+
+        #[derive(Clone)]
+        struct Test {
+            key: Vec<u8>,
+            input: Vec<u8>,
+            output: Vec<u8>,
+        }
+
         let tests = vec![
             // Test vectors copied from libsecp256k1
             // Sadly the RFC2104 test vectors all use MD5 as their underlying hash function,
@@ -369,6 +368,7 @@ mod tests {
     #[test]
     fn hmac_sha512_serde() {
         use serde_test::{Configure, Token, assert_tokens};
+        use {sha512, Hash, Hmac};
 
         static HASH_BYTES: [u8; 64] = [
             0x8b, 0x41, 0xe1, 0xb7, 0x8a, 0xd1, 0x15, 0x21,

src/ripemd160.rs

@@ -459,20 +459,20 @@ impl HashEngine {
 
 #[cfg(test)]
 mod tests {
-    use ripemd160;
-    use hex::{FromHex, ToHex};
-    use Hash;
-    use HashEngine;
-
-    #[derive(Clone)]
-    struct Test {
-        input: &'static str,
-        output: Vec<u8>,
-        output_str: &'static str,
-    }
-
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn test() {
+        use ripemd160;
+        use {Hash, HashEngine};
+        use hex::{FromHex, ToHex};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
         let tests = vec![
             // Test messages from FIPS 180-1
             Test {
@@ -545,6 +545,7 @@ mod tests {
     #[test]
     fn ripemd_serde() {
         use serde_test::{Configure, Token, assert_tokens};
+        use {ripemd160, Hash};
 
         static HASH_BYTES: [u8; 20] = [
             0x13, 0x20, 0x72, 0xdf,

src/sha1.rs

@@ -197,20 +197,20 @@ impl HashEngine {
 
 #[cfg(test)]
 mod tests {
-    use sha1;
-    use hex::{FromHex, ToHex};
-    use Hash;
-    use HashEngine;
-
-    #[derive(Clone)]
-    struct Test {
-        input: &'static str,
-        output: Vec<u8>,
-        output_str: &'static str,
-    }
-
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn test() {
+        use {sha1, Hash, HashEngine};
+        use hex::{FromHex, ToHex};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
+
         let tests = vec![
             // Examples from wikipedia
             Test {
@@ -270,6 +270,7 @@ mod tests {
     #[test]
     fn sha1_serde() {
         use serde_test::{Configure, Token, assert_tokens};
+        use {sha1, Hash};
 
         static HASH_BYTES: [u8; 20] = [
             0x13, 0x20, 0x72, 0xdf,

src/sha256.rs

@@ -373,18 +373,20 @@ impl HashEngine {
 #[cfg(test)]
 mod tests {
     use sha256;
-    use hex::{FromHex, ToHex};
     use {Hash, HashEngine};
 
-    #[derive(Clone)]
-    struct Test {
-        input: &'static str,
-        output: Vec<u8>,
-        output_str: &'static str,
-    }
-
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn test() {
+        use hex::{FromHex, ToHex};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
         let tests = vec![
             // Examples from wikipedia
             Test {

src/sha256d.rs

@@ -100,20 +100,19 @@ impl HashTrait for Hash {
 
 #[cfg(test)]
 mod tests {
-    use sha256d;
-    use hex::{FromHex, ToHex};
-    use Hash;
-    use HashEngine;
-
-    #[derive(Clone)]
-    struct Test {
-        input: &'static str,
-        output: Vec<u8>,
-        output_str: &'static str,
-    }
-
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn test() {
+        use {sha256d, Hash, HashEngine};
+        use hex::{FromHex, ToHex};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
         let tests = vec![
             // Test vector copied out of rust-bitcoin
             Test {
@@ -150,6 +149,7 @@ mod tests {
     #[test]
     fn sha256_serde() {
         use serde_test::{Configure, Token, assert_tokens};
+        use {sha256d, Hash};
 
         static HASH_BYTES: [u8; 32] = [
             0xef, 0x53, 0x7f, 0x25, 0xc8, 0x95, 0xbf, 0xa7,

src/sha256t.rs

@@ -246,6 +246,7 @@ impl<'de, T: Tag> ::serde::Deserialize<'de> for Hash<T> {
 #[cfg(test)]
 mod tests {
     use ::{Hash, sha256, sha256t};
+    #[cfg(any(feature = "std", feature = "alloc"))]
     use ::hex::ToHex;
 
     const TEST_MIDSTATE: [u8; 32] = [
@@ -266,11 +267,13 @@ mod tests {
     }
 
     /// A hash tagged with `$name`.
+    #[cfg(any(feature = "std", feature = "alloc"))]
     pub type TestHash = sha256t::Hash<TestHashTag>;
 
     sha256t_hash_newtype!(NewTypeHash, NewTypeTag, TEST_MIDSTATE, 64, doc="test hash", true);
 
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn test_sha256t() {
         assert_eq!(
             TestHash::hash(&[0]).to_hex(),

src/sha512.rs

@@ -348,20 +348,19 @@ impl HashEngine {
 
 #[cfg(test)]
 mod tests {
-    use sha512;
-    use hex::{FromHex, ToHex};
-    use Hash;
-    use HashEngine;
-
-    #[derive(Clone)]
-    struct Test {
-        input: &'static str,
-        output: Vec<u8>,
-        output_str: &'static str,
-    }
-
     #[test]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn test() {
+        use {sha512, Hash, HashEngine};
+        use hex::{FromHex, ToHex};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
         let tests = vec![
             // Test vectors computed with `sha512sum`
             Test {
@@ -430,6 +429,7 @@ mod tests {
     #[test]
     fn sha512_serde() {
         use serde_test::{Configure, Token, assert_tokens};
+        use {sha512, Hash};
 
         static HASH_BYTES: [u8; 64] = [
             0x8b, 0x41, 0xe1, 0xb7, 0x8a, 0xd1, 0x15, 0x21,