openpgp: Add tests for SKESK5::decrypt.

  - Previously the AEAD-based SKESK5 code was not being exercised
    by the test suite due to a combination of being in a doctest
    and being guarded by #[cfg(test)].

  - Add a separate test case that additionally utilizes
    `AEADAlgorithm::const_default`.

1 files changed, 60 insertions, 0 deletions

diff --git a/openpgp/src/serialize/stream.rs b/openpgp/src/serialize/stream.rs
index 6c7d0958..49057cc1 100644
--- a/openpgp/src/serialize/stream.rs
+++ b/openpgp/src/serialize/stream.rs
@@ -3844,4 +3844,64 @@ mod test {
 
         Ok(())
     }
+
+    // Example copied from `Encryptor::aead_algo` and slightly
+    // adjusted since the doctest from `Encryptor::aead_algo` does not
+    // run.  Additionally this test case utilizes
+    // `AEADAlgorithm::const_default` to detect which algorithm to
+    // use.
+    #[test]
+    fn experimental_aead_encryptor() -> Result<()> {
+        use std::io::Write;
+        use crate::types::AEADAlgorithm;
+        use crate::policy::StandardPolicy;
+        use crate::serialize::stream::{
+            Message, Encryptor, LiteralWriter,
+        };
+        use crate::parse::stream::{
+            DecryptorBuilder, VerificationHelper,
+            DecryptionHelper, MessageStructure,
+        };
+
+        let mut sink = vec![];
+        let message = Message::new(&mut sink);
+        let message =
+          Encryptor::with_passwords(message, Some("совершенно секретно"))
+              .aead_algo(AEADAlgorithm::const_default())
+              .build()?;
+        let mut message = LiteralWriter::new(message).build()?;
+        message.write_all(b"Hello world.")?;
+        message.finalize()?;
+
+        struct Helper;
+
+        impl VerificationHelper for Helper {
+            fn get_certs(&mut self, _ids: &[crate::KeyHandle]) -> Result<Vec<Cert>> where {
+                Ok(Vec::new())
+            }
+
+            fn check(&mut self, _structure: MessageStructure) -> Result<()> {
+                Ok(())
+            }
+        }
+
+        impl DecryptionHelper for Helper {
+            fn decrypt<D>(&mut self, _: &[PKESK], skesks: &[SKESK],
+                          _sym_algo: Option<SymmetricAlgorithm>,
+                          mut decrypt: D) -> Result<Option<crate::Fingerprint>>
+            where D: FnMut(SymmetricAlgorithm, &SessionKey) -> bool
+            {
+                skesks[0].decrypt(&"совершенно секретно".into())
+                    .map(|(algo, session_key)| decrypt(algo, &session_key))?;
+                Ok(None)
+            }
+        }
+
+        let p = &StandardPolicy::new();
+        let mut v = DecryptorBuilder::from_bytes(&sink)?.with_policy(p, None, Helper)?;
+        let mut content = vec![];
+        v.read_to_end(&mut content)?;
+        assert_eq!(content, b"Hello world.");
+        Ok(())
+    }
 }