start fixing tests

9 files changed, 147 insertions, 100 deletions

diff --git a/openpgp/src/cert.rs b/openpgp/src/cert.rs
index 8043cc9c..a7f3a03e 100644
--- a/openpgp/src/cert.rs
+++ b/openpgp/src/cert.rs
@@ -884,7 +884,9 @@ impl Cert {
     /// use openpgp::parse::Parse;
     /// use openpgp::policy::StandardPolicy;
     ///
-    /// # fn main() -> Result<()> {
+    /// # use futures::FutureExt;
+    /// # fn main() -> Result<()> { f().now_or_never().unwrap() }
+    /// # async fn f() -> Result<()> {
     /// let p = &StandardPolicy::new();
     ///
     /// let (cert, rev) = CertBuilder::new()
@@ -905,7 +907,7 @@ impl Cert {
     ///     .key().clone().parts_into_secret()?.into_keypair()?;
     /// let rev = cert.revoke(&mut keypair,
     ///                       ReasonForRevocation::KeyCompromised,
-    ///                       b"It was the maid :/")?;
+    ///                       b"It was the maid :/").await?;
     /// let cert = cert.insert_packets(rev)?;
     /// if let RevocationStatus::Revoked(revs) = cert.revocation_status(p, None) {
     ///     assert_eq!(revs.len(), 1);
@@ -938,7 +940,7 @@ impl Cert {
     /// This function exists to facilitate testing, which is why it is
     /// not exported.
     #[cfg(test)]
-    fn set_validity_period_as_of(self, policy: &dyn Policy,
+    async fn set_validity_period_as_of(self, policy: &dyn Policy,
                                  primary_signer: &mut dyn Signer,
                                  expiration: Option<time::Duration>,
                                  now: time::SystemTime)
@@ -947,7 +949,7 @@ impl Cert {
         let primary = self.primary_key().with_policy(policy, now)?;
         let sigs = primary.set_validity_period_as_of(primary_signer,
                                                      expiration,
-                                                     now)?;
+                                                     now).await?;
         self.insert_packets(sigs)
     }
 
@@ -978,7 +980,9 @@ impl Cert {
     /// use openpgp::crypto::KeyPair;
     /// use openpgp::policy::StandardPolicy;
     ///
-    /// # fn main() -> Result<()> {
+    /// # use futures::FutureExt;
+    /// # fn main() -> Result<()> { f().now_or_never().unwrap() }
+    /// # async fn f() -> Result<()> {
     /// let p = &StandardPolicy::new();
     ///
     /// # let t0 = time::SystemTime::now() - time::Duration::from_secs(1);
@@ -993,12 +997,11 @@ impl Cert {
     /// let mut keypair = cert.primary_key()
     ///     .key().clone().parts_into_secret()?.into_keypair()?;
     /// let sigs = cert.set_expiration_time(p, None, &mut keypair,
-    ///                                     Some(time::SystemTime::now()))?;
+    ///                                     Some(time::SystemTime::now())).await?;
     ///
     /// let cert = cert.insert_packets(sigs)?;
     /// assert!(cert.with_policy(p, None)?.alive().is_err());
-    /// # Ok(())
-    /// # }
+    /// # Ok(()) }
     /// ```
     pub async fn set_expiration_time<T>(&self, policy: &dyn Policy, t: T,
                                   primary_signer: &mut dyn Signer,
@@ -3402,6 +3405,7 @@ impl<'a> crate::cert::Preferences<'a> for ValidCert<'a>
 
 #[cfg(test)]
 mod test {
+    use futures::FutureExt;
     use crate::serialize::Serialize;
     use crate::policy::StandardPolicy as P;
     use crate::types::Curve;
@@ -4053,7 +4057,8 @@ mod test {
         // Clear the expiration.
         let as_of1 = now + time::Duration::new(10, 0);
         let cert = cert.set_validity_period_as_of(
-            policy, &mut keypair, None, as_of1).unwrap();
+            policy, &mut keypair, None, as_of1)
+            .now_or_never().unwrap().unwrap();
         {
             // If t < as_of1, we should get the original expiry.
             assert_eq!(cert.primary_key().with_policy(policy, now).unwrap()
@@ -4076,7 +4081,8 @@ mod test {
 
         let as_of2 = as_of1 + time::Duration::new(10, 0);
         let cert = cert.set_validity_period_as_of(
-            policy, &mut keypair, Some(expiry_new), as_of2).unwrap();
+            policy, &mut keypair, Some(expiry_new), as_of2)
+            .now_or_never().unwrap().unwrap();
         {
             // If t < as_of1, we should get the original expiry.
             assert_eq!(cert.primary_key().with_policy(policy, now).unwrap()
@@ -4234,7 +4240,7 @@ mod test {
                 ReasonForRevocation::KeyCompromised,
                 b"It was the maid :/").unwrap()
             .build(&mut keypair, &cert, None)
-            .unwrap();
+            .now_or_never().unwrap().unwrap();
         assert_eq!(sig.typ(), SignatureType::KeyRevocation);
         assert_eq!(sig.issuers().collect::<Vec<_>>(),
                    vec![ &cert.keyid() ]);
@@ -4257,7 +4263,7 @@ mod test {
                 ReasonForRevocation::KeyCompromised,
                 b"It was the maid :/").unwrap()
             .build(&mut keypair, &cert, None)
-            .unwrap();
+            .now_or_never().unwrap().unwrap();
 
         assert_eq!(sig.typ(), SignatureType::KeyRevocation);
         assert_eq!(sig.issuers().collect::<Vec<_>>(),
@@ -4285,7 +4291,7 @@ mod test {
                     ReasonForRevocation::UIDRetired,
                     b"It was the maid :/").unwrap()
                 .build(&mut keypair, &cert, subkey.key(), None)
-                .unwrap()
+                .now_or_never().unwrap().unwrap()
         };
         assert_eq!(sig.typ(), SignatureType::SubkeyRevocation);
         let cert = cert.insert_packets(sig).unwrap();
@@ -4316,7 +4322,7 @@ mod test {
                     ReasonForRevocation::UIDRetired,
                     b"It was the maid :/").unwrap()
                 .build(&mut keypair, &cert, uid.userid(), None)
-                .unwrap()
+                .now_or_never().unwrap().unwrap()
         };
         assert_eq!(sig.typ(), SignatureType::CertificationRevocation);
         let cert = cert.insert_packets(sig).unwrap();
@@ -4366,13 +4372,13 @@ mod test {
                 .set_signature_creation_time(t1).unwrap()
                 .set_key_validity_period(Some(time::Duration::new(10 * 52 * 7 * 24 * 60 * 60, 0))).unwrap()
                 .set_preferred_hash_algorithms(vec![HashAlgorithm::SHA512]).unwrap()
-                .sign_direct_key(&mut pair, &key).unwrap();
+                .sign_direct_key(&mut pair, &key).now_or_never().unwrap().unwrap();
 
             let rev1 = signature::SignatureBuilder::new(SignatureType::KeyRevocation)
                 .set_signature_creation_time(t2).unwrap()
                 .set_reason_for_revocation(ReasonForRevocation::KeySuperseded,
                                            &b""[..]).unwrap()
-                .sign_direct_key(&mut pair, &key).unwrap();
+                .sign_direct_key(&mut pair, &key).now_or_never().unwrap().unwrap();
 
             let bind2 = signature::SignatureBuilder::new(SignatureType::DirectKey)
                 .set_features(&Features::sequoia()).unwrap()
@@ -4380,13 +4386,13 @@ mod test {
                 .set_signature_creation_time(t3).unwrap()
                 .set_key_validity_period(Some(time::Duration::new(10 * 52 * 7 * 24 * 60 * 60, 0))).unwrap()
                 .set_preferred_hash_algorithms(vec![HashAlgorithm::SHA512]).unwrap()
-                .sign_direct_key(&mut pair, &key).unwrap();
+                .sign_direct_key(&mut pair, &key).now_or_never().unwrap().unwrap();
 
             let rev2 = signature::SignatureBuilder::new(SignatureType::KeyRevocation)
                 .set_signature_creation_time(t4).unwrap()
                 .set_reason_for_revocation(ReasonForRevocation::KeyCompromised,
                                            &b""[..]).unwrap()
-                .sign_direct_key(&mut pair, &key).unwrap();
+                .sign_direct_key(&mut pair, &key).now_or_never().unwrap().unwrap();
 
             (bind1, rev1, bind2, rev2)
         };
@@ -5036,7 +5042,7 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
         let sig = uid.certify(&mut pair, &cert,
                               SignatureType::PositiveCertification,
                               None,
-                              t1).unwrap();
+                              t1).now_or_never().unwrap().unwrap();
         cert = cert.insert_packets(
             vec![Packet::from(uid), sig.into()]).unwrap();
 
@@ -5053,7 +5059,7 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
                     .unwrap()
                     .set_preferred_hash_algorithms(vec![HashAlgorithm::SHA512]).unwrap()
                     .set_signature_creation_time(*t).unwrap()
-                    .sign_direct_key(&mut pair, &key).unwrap();
+                    .sign_direct_key(&mut pair, &key).now_or_never().unwrap().unwrap();
 
                 let binding : Packet = binding.into();
 
@@ -5119,7 +5125,7 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
                     &mut alice.primary_key().key().clone().parts_into_secret()
                         .unwrap().into_keypair().unwrap(),
                     &bob,
-                    sig_template).unwrap();
+                    sig_template).now_or_never().unwrap().unwrap();
 
             let bob = bob.insert_packets(alice_certifies_bob.clone()).unwrap();
 
@@ -5229,7 +5235,7 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
         fake_key.set_body("fake key".into());
         let fake_binding = signature::SignatureBuilder::new(
                 SignatureType::Unknown(SignatureType::SubkeyBinding.into()))
-            .sign_standalone(&mut primary_pair)?;
+            .sign_standalone(&mut primary_pair).now_or_never().unwrap()?;
         let cert = cert.insert_packets(vec![Packet::from(fake_key),
                                            fake_binding.clone().into()])?;
         assert_eq!(cert.unknowns().count(), 1);
@@ -5313,7 +5319,8 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
         let builder = signature::SignatureBuilder::new(SignatureType::SubkeyBinding)
             .set_key_flags(&KeyFlags::empty()
                            .set_transport_encryption())?;
-        let binding = subkey_sec.bind(&mut primary_pair, &cert, builder)?;
+        let binding = subkey_sec.bind(&mut primary_pair, &cert, builder)
+            .now_or_never().unwrap()?;
 
         let cert = Cert::try_from(vec![
             primary.clone().into(),
@@ -5357,7 +5364,8 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
         let uid: UserID = "foo@example.org".into();
         let sig = uid.bind(
             &mut primary_pair, &cert,
-            signature::SignatureBuilder::new(SignatureType::PositiveCertification))?;
+            signature::SignatureBuilder::new(SignatureType::PositiveCertification))
+            .now_or_never().unwrap()?;
         let cert = cert.insert_packets(vec![
             Packet::from(uid),
             sig.into(),
@@ -5670,7 +5678,8 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
                         .sign_primary_key_binding(
                             &mut pair,
                             cert.primary_key().key(),
-                            cert.keys().subkeys().nth(0).unwrap().key())?),
+                            cert.keys().subkeys().nth(0).unwrap().key())
+                        .now_or_never().unwrap()?),
                 false)?)?;
         } else {
             panic!("expected a signature");
@@ -5725,7 +5734,8 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
                         .sign_primary_key_binding(
                             &mut pair,
                             cert.primary_key().key(),
-                            cert.keys().subkeys().nth(0).unwrap().key())?),
+                            cert.keys().subkeys().nth(0).unwrap().key())
+                        .now_or_never().unwrap()?),
                 false)?)?;
             sig.unhashed_area_mut().add(Subpacket::new(
                 SubpacketValue::EmbeddedSignature(backsig), false)?)?;
diff --git a/openpgp/src/cert/amalgamation/key.rs b/openpgp/src/cert/amalgamation/key.rs
index b5b75286..741cc601 100644
--- a/openpgp/src/cert/amalgamation/key.rs
+++ b/openpgp/src/cert/amalgamation/key.rs
@@ -1348,7 +1348,7 @@ impl<'a, P> ValidPrimaryKeyAmalgamation<'a, P>
     /// This function exists to facilitate testing, which is why it is
     /// not exported.
     #[cfg(test)]
-    pub(crate) fn set_validity_period_as_of(&self,
+    pub(crate) async fn set_validity_period_as_of(&self,
                                             primary_signer: &mut dyn Signer,
                                             expiration: Option<time::Duration>,
                                             now: time::SystemTime)
@@ -1356,6 +1356,7 @@ impl<'a, P> ValidPrimaryKeyAmalgamation<'a, P>
     {
         ValidErasedKeyAmalgamation::<P>::from(self)
             .set_validity_period_as_of(primary_signer, None, expiration, now)
+            .await
     }
 
     /// Creates signatures that cause the key to expire at the specified time.
@@ -1384,7 +1385,9 @@ impl<'a, P> ValidPrimaryKeyAmalgamation<'a, P>
     /// # use openpgp::cert::prelude::*;
     /// use openpgp::policy::StandardPolicy;
     ///
-    /// # fn main() -> openpgp::Result<()> {
+    /// # use futures::FutureExt;
+    /// # fn main() -> openpgp::Result<()> { f().now_or_never().unwrap() }
+    /// # async fn f() -> openpgp::Result<()> {
     /// let p = &StandardPolicy::new();
     ///
     /// # let t = time::SystemTime::now() - time::Duration::from_secs(10);
@@ -1408,7 +1411,7 @@ impl<'a, P> ValidPrimaryKeyAmalgamation<'a, P>
     /// let mut signer = vc.primary_key()
     ///     .key().clone().parts_into_secret()?.into_keypair()?;
     ///
-    /// let sigs = vc.primary_key().set_expiration_time(&mut signer, Some(t))?;
+    /// let sigs = vc.primary_key().set_expiration_time(&mut signer, Some(t)).await?;
     /// let cert = cert.insert_packets(sigs)?;
     ///
     /// // The primary key isn't expired yet.
@@ -1466,7 +1469,9 @@ impl<'a, P> ValidSubordinateKeyAmalgamation<'a, P>
     /// # use openpgp::cert::prelude::*;
     /// use openpgp::policy::StandardPolicy;
     ///
-    /// # fn main() -> openpgp::Result<()> {
+    /// # use futures::FutureExt;
+    /// # fn main() -> openpgp::Result<()> { f().now_or_never().unwrap() }
+    /// # async fn f() -> openpgp::Result<()> {
     /// let p = &StandardPolicy::new();
     ///
     /// # let t = time::SystemTime::now() - time::Duration::from_secs(10);
@@ -1499,17 +1504,17 @@ impl<'a, P> ValidSubordinateKeyAmalgamation<'a, P>
     ///     if ! ka.for_signing() {
     ///         // Non-signing-capable subkeys are easy to update.
     ///         sigs.append(&mut ka.set_expiration_time(&mut primary_signer,
-    ///                                                 None, Some(t))?);
+    ///                                                 None, Some(t)).await?);
     ///     } else {
     ///         // Signing-capable subkeys need to create a primary
     ///         // key binding signature with the subkey:
     ///         assert!(ka.set_expiration_time(&mut primary_signer,
-    ///                                        None, Some(t)).is_err());
+    ///                                        None, Some(t)).await.is_err());
     ///
     ///         // Here, we need the subkey's signer:
     ///         sigs.append(&mut ka.set_expiration_time(&mut primary_signer,
     ///                                                 Some(&mut signing_subkey_signer),
-    ///                                                 Some(t))?);
+    ///                                                 Some(t)).await?);
     ///     }
     /// }
     /// let cert = cert.insert_packets(sigs)?;
@@ -1705,7 +1710,9 @@ impl<'a, P> ValidErasedKeyAmalgamation<'a, P>
     /// # use openpgp::cert::prelude::*;
     /// use openpgp::policy::StandardPolicy;
     ///
-    /// # fn main() -> openpgp::Result<()> {
+    /// # use futures::FutureExt;
+    /// # fn main() -> openpgp::Result<()> { f().now_or_never().unwrap() }
+    /// # async fn f() -> openpgp::Result<()> {
     /// let p = &StandardPolicy::new();
     ///
     /// # let t = time::SystemTime::now() - time::Duration::from_secs(10);
@@ -1738,17 +1745,17 @@ impl<'a, P> ValidErasedKeyAmalgamation<'a, P>
     ///     if ! ka.for_signing() {
     ///         // Non-signing-capable subkeys are easy to update.
     ///         sigs.append(&mut ka.set_expiration_time(&mut primary_signer,
-    ///                                                 None, Some(t))?);
+    ///                                                 None, Some(t)).await?);
     ///     } else {
     ///         // Signing-capable subkeys need to create a primary
     ///         // key binding signature with the subkey:
     ///         assert!(ka.set_expiration_time(&mut primary_signer,
-    ///                                        None, Some(t)).is_err());
+    ///                                        None, Some(t)).await.is_err());
     ///
     ///         // Here, we need the subkey's signer:
     ///         sigs.append(&mut ka.set_expiration_time(&mut primary_signer,
     ///                                                 Some(&mut signing_subkey_signer),
-    ///                                                 Some(t))?);
+    ///                                                 Some(t)).await?);
     ///     }
     /// }
     /// let cert = cert.insert_packets(sigs)?;
@@ -2207,6 +2214,7 @@ impl<'a, P, R, R2> ValidKeyAmalgamation<'a, P, R, R2>
 
 #[cfg(test)]
 mod test {
+    use futures::FutureExt;
     use crate::policy::StandardPolicy as P;
     use crate::cert::prelude::*;
     use crate::packet::Packet;
@@ -2251,11 +2259,13 @@ mod test {
                 if ! ka.for_signing() {
                     ka.set_expiration_time(&mut primary_signer,
                                            None,
-                                           Some(in_a_year)).unwrap()
+                                           Some(in_a_year))
+                        .now_or_never().unwrap().unwrap()
                 } else {
                     ka.set_expiration_time(&mut primary_signer,
                                            Some(&mut signing_subkey_signer),
-                                           Some(in_a_year)).unwrap()
+                                           Some(in_a_year))
+                        .now_or_never().unwrap().unwrap()
                 }
                     .into_iter()
                     .map(Into::into)
@@ -2332,7 +2342,8 @@ mod test {
             .primary_key().key().clone().parts_into_secret()?
             .into_keypair()?;
         let sigs = vc.primary_key()
-            .set_expiration_time(&mut signer, Some(t))?;
+            .set_expiration_time(&mut signer, Some(t))
+            .now_or_never().unwrap()?;
 
         assert!(sigs.iter().any(|s| {
             s.typ() == SignatureType::DirectKey
diff --git a/openpgp/src/cert/builder.rs b/openpgp/src/cert/builder.rs
index 67c0fec7..e17f2ebe 100644
--- a/openpgp/src/cert/builder.rs
+++ b/openpgp/src/cert/builder.rs
@@ -1116,6 +1116,7 @@ impl CertBuilder {
 
 #[cfg(test)]
 mod tests {
+    use futures::FutureExt;
     use std::str::FromStr;
 
     use super::*;
@@ -1425,7 +1426,8 @@ mod tests {
             .into_keypair()?;
         let sig = signature::SignatureBuilder::new(SignatureType::DirectKey)
             .set_signature_creation_time(then)?
-            .sign_hash(&mut primary_signer, hash)?;
+            .sign_hash(&mut primary_signer, hash)
+            .now_or_never().unwrap()?;
         let cert = cert.insert_packets(sig)?;
 
         assert!(cert.with_policy(p, then)?.primary_userid().is_err());
diff --git a/openpgp/src/message/mod.rs b/openpgp/src/message/mod.rs
index 82dd1695..abf0cfff 100644
--- a/openpgp/src/message/mod.rs
+++ b/openpgp/src/message/mod.rs
@@ -524,6 +524,7 @@ impl ::std::ops::Deref for Message {
 
 #[cfg(test)]
 mod tests {
+    use futures::FutureExt;
     use super::*;
 
     use crate::types::DataFormat::Text;
@@ -893,7 +894,8 @@ mod tests {
             .unwrap().into();
         let mut pair = key.clone().into_keypair().unwrap();
         let sig = crate::packet::signature::SignatureBuilder::new(SignatureType::Binary)
-            .sign_hash(&mut pair, hash.context().unwrap()).unwrap();
+            .sign_hash(&mut pair, hash.context().unwrap())
+            .now_or_never().unwrap().unwrap();
 
         // 0: OnePassSig
         // => bad.
@@ -1005,7 +1007,8 @@ mod tests {
             .unwrap().into();
         let mut pair = key.clone().into_keypair().unwrap();
         let sig = crate::packet::signature::SignatureBuilder::new(SignatureType::Binary)
-            .sign_hash(&mut pair, hash.context().unwrap()).unwrap();
+            .sign_hash(&mut pair, hash.context().unwrap())
+            .now_or_never().unwrap().unwrap();
 
         // 0: Signature
         // => bad.
diff --git a/openpgp/src/packet/signature.rs b/openpgp/src/packet/signature.rs
index 61149a57..75381224 100644
--- a/openpgp/src/packet/signature.rs
+++ b/openpgp/src/packet/signature.rs
@@ -2931,6 +2931,7 @@ impl_arbitrary_with_bound!(Signature4);
 
 #[cfg(test)]
 mod test {
+    use futures::FutureExt;
     use super::*;
     use crate::KeyID;
     use crate::cert::prelude::*;
@@ -3106,7 +3107,7 @@ mod test {
             let hash = hash_algo.context().unwrap();
 
             // Make signature.
-            let mut sig = sig.sign_hash(&mut pair, hash).unwrap();
+            let mut sig = sig.sign_hash(&mut pair, hash).now_or_never().unwrap().unwrap();
 
             // Good signature.
             let mut hash = hash_algo.context().unwrap();
@@ -3131,7 +3132,7 @@ mod test {
         let msg = b"Hello, World";
         let mut pair = key.into_keypair().unwrap();
         let mut sig = SignatureBuilder::new(SignatureType::Binary)
-            .sign_message(&mut pair, msg).unwrap();
+            .sign_message(&mut pair, msg).now_or_never().unwrap().unwrap();
 
         sig.verify_message(pair.public(), msg).unwrap();
     }
@@ -3173,7 +3174,7 @@ mod test {
         hash.update(&msg[..]);
 
         SignatureBuilder::new(SignatureType::Text)
-            .sign_hash(&mut pair, hash).unwrap();
+            .sign_hash(&mut pair, hash).now_or_never().unwrap().unwrap();
     }
 
     #[test]
@@ -3232,12 +3233,12 @@ mod test {
 
         // Build and add an embedded sig.
         let embedded_sig = SignatureBuilder::new(SignatureType::PrimaryKeyBinding)
-            .sign_hash(&mut pair, hash.clone()).unwrap();
+            .sign_hash(&mut pair, hash.clone()).now_or_never().unwrap().unwrap();
         builder.unhashed_area_mut().add(Subpacket::new(
             SubpacketValue::EmbeddedSignature(embedded_sig.into()), false)
                                         .unwrap()).unwrap();
         let sig = builder.sign_hash(&mut pair,
-                                    hash.clone()).unwrap().normalize();
+                                    hash.clone()).now_or_never().unwrap().unwrap().normalize();
         assert_eq!(sig.unhashed_area().iter().count(), 3);
         assert_eq!(*sig.unhashed_area().iter().nth(0).unwrap(),
                    Subpacket::new(SubpacketValue::Issuer(keyid.clone()),
@@ -3257,7 +3258,7 @@ mod test {
 
         let mut sig = SignatureBuilder::new(SignatureType::Standalone)
             .sign_standalone(&mut pair)
-            .unwrap();
+            .now_or_never().unwrap().unwrap();
 
         sig.verify_standalone(pair.public()).unwrap();
     }
@@ -3285,7 +3286,7 @@ mod test {
 
         let mut sig = SignatureBuilder::new(SignatureType::Timestamp)
             .sign_timestamp(&mut pair)
-            .unwrap();
+            .now_or_never().unwrap().unwrap();
 
         sig.verify_timestamp(pair.public()).unwrap();
     }
@@ -3352,7 +3353,8 @@ mod test {
                               false)?
                 .sign_userid_binding(&mut primary_signer,
                                      &alice.primary_key(),
-                                     &alice.userids().nth(0).unwrap()) {
+                                     &alice.userids().nth(0).unwrap())
+                .now_or_never().unwrap() {
                     Ok(v) => v,
                     Err(e) => if i < SIG_BACKDATE_BY {
                         return Err(e); // Not cool.
@@ -3530,7 +3532,8 @@ mod test {
                     SubpacketValue::Issuer(keyid.clone()), false)?)?;
                 Ok(a)
             })?
-            .sign_hash(&mut pair, hash.clone())?;
+            .sign_hash(&mut pair, hash.clone())
+            .now_or_never().unwrap()?;
 
         // Try to displace the issuer information.
         let dummy: crate::KeyID = "AAAA BBBB CCCC DDDD".parse()?;
diff --git a/openpgp/src/packet/signature/subpacket.rs b/openpgp/src/packet/signature/subpacket.rs
index eb0ce810..eddb0789 100644
--- a/openpgp/src/packet/signature/subpacket.rs
+++ b/openpgp/src/packet/signature/subpacket.rs
@@ -6831,6 +6831,7 @@ impl signature::SignatureBuilder {
 
 #[test]
 fn accessors() {
+    use futures::FutureExt;
     use crate::types::Curve;
 
     let pk_algo = PublicKeyAlgorithm::EdDSA;
@@ -6848,7 +6849,7 @@ fn accessors() {
 
     sig = sig.set_signature_creation_time(now).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.signature_creation_time(), Some(now));
 
     let zero_s = time::Duration::new(0, 0);
@@ -6857,7 +6858,7 @@ fn accessors() {
     let ten_minutes = 10 * minute;
     sig = sig.set_signature_validity_period(five_minutes).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.signature_validity_period(), Some(five_minutes));
 
     assert!(sig_.signature_alive(None, zero_s).is_ok());
@@ -6870,7 +6871,7 @@ fn accessors() {
         Ok(a)
     }).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.signature_validity_period(), None);
 
     assert!(sig_.signature_alive(None, zero_s).is_ok());
@@ -6880,37 +6881,37 @@ fn accessors() {
 
     sig = sig.set_exportable_certification(true).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.exportable_certification(), Some(true));
     sig = sig.set_exportable_certification(false).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.exportable_certification(), Some(false));
 
     sig = sig.set_trust_signature(2, 3).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.trust_signature(), Some((2, 3)));
 
     sig = sig.set_regular_expression(b"foobar").unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.regular_expressions().collect::<Vec<&[u8]>>(),
                vec![ &b"foobar"[..] ]);
 
     sig = sig.set_revocable(true).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.revocable(), Some(true));
     sig = sig.set_revocable(false).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.revocable(), Some(false));
 
     key.set_creation_time(now).unwrap();
     sig = sig.set_key_validity_period(Some(five_minutes)).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();
     assert_eq!(sig_.key_validity_period(), Some(five_minutes));
 
     assert!(sig_.key_alive(&key, None).is_ok());
@@ -6920,7 +6921,7 @@ fn accessors() {
 
     sig = sig.set_key_validity_period(None).unwrap();
     let sig_ =
-        sig.clone().sign_hash(&mut keypair, hash.clone()).unwrap();
+        sig.clone().sign_hash(&mut keypair, hash.clone()).now_or_never().unwrap().unwrap();