Merge remote-tracking branch 'origin/upstream' am: cc55ae95c7 am: e8337555de am: 291c682d47

Original change: undetermined

Change-Id: I70c95e81d0d13869ffc13860f8f844cf851af46a
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

1 files changed, 99 insertions, 0 deletions

diff --git a/tests/cov.rs b/tests/cov.rs
new file mode 100644
index 0000000..374f950
--- /dev/null
+++ b/tests/cov.rs
@@ -0,0 +1,99 @@
+//! Generic and coverage tests
+use asn1_rs::*;
+use std::io;
+
+#[test]
+fn new_embedded_pdv() {
+    fn create_pdv(identification: PdvIdentification) -> EmbeddedPdv {
+        let pdv = EmbeddedPdv {
+            identification,
+            data_value_descriptor: None,
+            data_value: &[0x00, 0xff],
+        };
+        assert!(pdv.data_value_descriptor.is_none());
+        assert_eq!(pdv.data_value.len(), 2);
+        pdv
+    }
+    let identification = PdvIdentification::ContextNegotiation {
+        presentation_context_id: Integer::from(42_u8),
+        presentation_syntax: oid! { 1.2.3.4.5 },
+    };
+    let pdv1 = create_pdv(identification);
+    let identification = PdvIdentification::Syntaxes {
+        s_abstract: oid! { 1.2.3 },
+        s_transfer: oid! { 1.2.3.4.5 },
+    };
+    let pdv2 = create_pdv(identification);
+    assert!(pdv1 != pdv2);
+    let identification = PdvIdentification::Syntaxes {
+        s_abstract: oid! { 1.2.3 },
+        s_transfer: oid! { 1.2.3.4.5 },
+    };
+    let pdv3 = create_pdv(identification);
+    assert!(pdv3 == pdv2);
+}
+
+#[test]
+fn methods_error() {
+    let e = Error::invalid_value(Tag(0), "msg".to_string());
+    assert_eq!(
+        e,
+        Error::InvalidValue {
+            tag: Tag(0),
+            msg: "msg".to_string(),
+        }
+    );
+    //
+    let e = Error::unexpected_tag(None, Tag(0));
+    assert_eq!(
+        e,
+        Error::UnexpectedTag {
+            expected: None,
+            actual: Tag(0),
+        }
+    );
+    //
+    let e = Error::unexpected_class(None, Class::Application);
+    assert_eq!(
+        e,
+        Error::UnexpectedClass {
+            expected: None,
+            actual: Class::Application
+        }
+    );
+    //
+    use nom::error::ParseError;
+    let e = Error::from_error_kind(&[], nom::error::ErrorKind::Fail);
+    let e = <asn1_rs::Error as ParseError<_>>::append(&[], nom::error::ErrorKind::Eof, e);
+    let s = format!("{}", e);
+    assert!(s.starts_with("nom error:"));
+    //
+    let e1 = Error::from(nom::Err::Error(Error::BerTypeError));
+    let e2 = Error::from(nom::Err::Incomplete(nom::Needed::new(2)));
+    assert!(e1 != e2);
+    //
+    let e = SerializeError::from(Error::BerTypeError);
+    let s = format!("{}", e);
+    assert!(s.starts_with("ASN.1 error:"));
+    //
+    let e = SerializeError::InvalidClass { class: 4 };
+    let s = format!("{}", e);
+    assert!(s.starts_with("Invalid Class"));
+    //
+    let e = SerializeError::from(io::Error::new(io::ErrorKind::Other, "msg"));
+    let s = format!("{}", e);
+    assert!(s.starts_with("I/O error:"));
+}
+
+#[test]
+fn methods_tag() {
+    let t = Tag::from(2);
+    assert_eq!(t, Tag::Integer);
+    //
+    let err = t.invalid_value("test");
+    if let Error::InvalidValue { tag, .. } = err {
+        assert_eq!(tag, Tag::Integer);
+    } else {
+        unreachable!();
+    }
+}