Enable test with --no-default-features

Cargo.toml

@@ -49,14 +49,15 @@ rand = { version = "0.6", features = ["wasm-bindgen"] }
 
 [[example]]
 name = "sign_verify_recovery"
-required-features = ["recovery"]
+required-features = ["std", "recovery"]
 
 [[example]]
 name = "sign_verify"
+required-features = ["std"]
 
 [[example]]
 name = "generate_keys"
-required-features = ["rand"]
+required-features = ["std", "rand-std"]
 
 [workspace]
 members = ["secp256k1-sys"]

contrib/test.sh

@@ -1,6 +1,7 @@
 #!/bin/sh -ex
 
-FEATURES="bitcoin_hashes global-context lowmemory rand rand-std recovery serde"
+# TODO: Add "alloc" once we bump MSRV to past 1.29
+FEATURES="bitcoin_hashes global-context lowmemory rand rand-std recovery serde std"
 
 # Use toolchain if explicitly specified
 if [ -n "$TOOLCHAIN" ]
@@ -20,17 +21,16 @@ cargo test --all
 
 if [ "$DO_FEATURE_MATRIX" = true ]; then
     cargo build --all --no-default-features
-    #This doesn't work but probably should --andrew
-    #cargo test --all --no-default-features
+    cargo test --all --no-default-features
 
     # All features
     cargo build --all --no-default-features --features="$FEATURES"
-    cargo test --all --features="$FEATURES"
+    cargo test --all --no-default-features --features="$FEATURES"
     # Single features
     for feature in ${FEATURES}
     do
         cargo build --all --no-default-features --features="$feature"
-        cargo test --all --features="$feature"
+        cargo test --all --no-default-features --features="$feature"
     done
 
     # Other combos 
@@ -45,9 +45,9 @@ if [ "$DO_FEATURE_MATRIX" = true ]; then
     fi
 
     # Examples
-    cargo run --example sign_verify
-    cargo run --example sign_verify_recovery --features=recovery
-    cargo run --example generate_keys --features=rand
+    cargo run --example sign_verify --features=std
+    cargo run --example sign_verify_recovery --features=std,recovery
+    cargo run --example generate_keys --features=std,rand-std
 fi
 
 # Docs

secp256k1-sys/src/types.rs

@@ -1,5 +1,5 @@
 #![allow(non_camel_case_types)]
-use core::{fmt, mem};
+use core::fmt;
 
 pub type c_int = i32;
 pub type c_uchar = u8;
@@ -46,7 +46,7 @@ impl AlignedType {
 }
 
 #[cfg(all(feature = "std", not(rust_secp_no_symbol_renaming)))]
-pub(crate) const ALIGN_TO: usize = mem::align_of::<AlignedType>();
+pub(crate) const ALIGN_TO: usize = ::core::mem::align_of::<AlignedType>();
 
 #[cfg(test)]
 mod tests {

src/context.rs

@@ -9,7 +9,7 @@ use Secp256k1;
 #[cfg_attr(docsrs, doc(cfg(any(feature = "std", feature = "alloc"))))]
 pub use self::alloc_only::*;
 
-#[cfg(feature = "global-context-less-secure")]
+#[cfg(all(feature = "global-context-less-secure", feature = "std"))]
 #[cfg_attr(docsrs, doc(cfg(any(feature = "global-context", feature = "global-context-less-secure"))))]
 /// Module implementing a singleton pattern for a global `Secp256k1` context
 pub mod global {
@@ -35,6 +35,7 @@ pub mod global {
     impl Deref for GlobalContext {
         type Target = Secp256k1<All>;
 
+        #[allow(unused_mut)]    // Unused when "global-context" is not enabled.
         fn deref(&self) -> &Self::Target {
             static ONCE: Once = Once::new();
             static mut CONTEXT: Option<Secp256k1<All>> = None;

src/ecdh.rs

@@ -127,6 +127,7 @@ impl SharedSecret {
     /// `SharedSecret` can be easily created via the `From` impl from arrays.
     /// # Examples
     /// ```
+    /// # #[cfg(any(feature = "alloc", features = "std"))] {
     /// # use secp256k1::ecdh::SharedSecret;
     /// # use secp256k1::{Secp256k1, PublicKey, SecretKey};
     /// # fn sha2(_a: &[u8], _b: &[u8]) -> [u8; 32] {[0u8; 32]}
@@ -139,7 +140,7 @@ impl SharedSecret {
     ///     let hash: [u8; 32] = sha2(&x,&y);
     ///     hash.into()
     /// });
-    ///
+    /// # }
     /// ```
     pub fn new_with_hash<F>(point: &PublicKey, scalar: &SecretKey, mut hash_function: F) -> SharedSecret
         where F: FnMut([u8; 32], [u8; 32]) -> SharedSecret {
@@ -168,6 +169,7 @@ impl SharedSecret {
 }
 
 #[cfg(test)]
+#[allow(unused_imports)]
 mod tests {
     use super::*;
     use rand::thread_rng;
@@ -177,6 +179,7 @@ mod tests {
     use wasm_bindgen_test::wasm_bindgen_test as test;
 
     #[test]
+    #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))]
     fn ecdh() {
         let s = Secp256k1::signing_only();
         let (sk1, pk1) = s.generate_keypair(&mut thread_rng());
@@ -190,6 +193,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))]
     fn ecdh_with_hash() {
         let s = Secp256k1::signing_only();
         let (sk1, pk1) = s.generate_keypair(&mut thread_rng());
@@ -203,6 +207,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))]
     fn ecdh_with_hash_callback() {
         let s = Secp256k1::signing_only();
         let (sk1, pk1) = s.generate_keypair(&mut thread_rng());

src/ecdsa/mod.rs

@@ -431,7 +431,7 @@ impl<C: Verification> Secp256k1<C> {
     /// verify-capable context.
     ///
     /// ```rust
-    /// # #[cfg(feature="rand")] {
+    /// # #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))] {
     /// # use secp256k1::rand::rngs::OsRng;
     /// # use secp256k1::{Secp256k1, Message, Error};
     /// #
@@ -460,7 +460,7 @@ impl<C: Verification> Secp256k1<C> {
     /// verify-capable context.
     ///
     /// ```rust
-    /// # #[cfg(feature="rand")] {
+    /// # #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))] {
     /// # use secp256k1::rand::rngs::OsRng;
     /// # use secp256k1::{Secp256k1, Message, Error};
     /// #

src/ecdsa/recovery.rs

@@ -201,6 +201,7 @@ impl<C: Verification> Secp256k1<C> {
 
 
 #[cfg(test)]
+#[allow(unused_imports)]
 mod tests {
     use super::*;
     use rand::{RngCore, thread_rng};
@@ -210,6 +211,7 @@ mod tests {
     use wasm_bindgen_test::wasm_bindgen_test as test;
 
     #[test]
+    #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))]
     fn capabilities() {
         let sign = Secp256k1::signing_only();
         let vrfy = Secp256k1::verification_only();
@@ -243,6 +245,7 @@ mod tests {
 
     #[test]
     #[cfg(not(fuzzing))]  // fixed sig vectors can't work with fuzz-sigs
+    #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))]
     fn sign() {
         let mut s = Secp256k1::new();
         s.randomize(&mut thread_rng());
@@ -266,6 +269,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))]
     fn sign_and_verify_fail() {
         let mut s = Secp256k1::new();
         s.randomize(&mut thread_rng());
@@ -289,6 +293,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))]
     fn sign_with_recovery() {
         let mut s = Secp256k1::new();
         s.randomize(&mut thread_rng());
@@ -305,6 +310,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(all(feature="rand-std", any(feature = "alloc", feature = "std")))]
     fn bad_recovery() {
         let mut s = Secp256k1::new();
         s.randomize(&mut thread_rng());