add tests for missing coverage

Signed-off-by: Facundo Tuesca <facundo.tuesca@trailofbits.com>

Author: facutuesca

src/rust/src/declarative_asn1/types.rs

@@ -550,9 +550,12 @@ pub(crate) fn check_size_constraint(
 mod tests {
 
     use asn1::SimpleAsn1Readable;
-    use pyo3::IntoPyObject;
+    use pyo3::{IntoPyObject, PyTypeInfo};
 
-    use super::{is_tag_valid_for_type, AnnotatedType, Annotation, Type};
+    use super::{
+        is_tag_valid_for_type, is_tag_valid_for_variant, AnnotatedType, Annotation, Encoding, Type,
+        Variant,
+    };
 
     #[test]
     // Needed for coverage of `is_tag_valid_for_type(Type::Option(..))`, since
@@ -599,4 +602,41 @@ mod tests {
             ));
         })
     }
+    #[test]
+    // Needed for coverage of
+    // `is_tag_valid_for_variant(..., encoding=Encoding::Implicit)`, since
+    // `is_tag_valid_for_variant` is never called with an implicit encoding.
+    fn test_is_tag_valid_for_implicit_variant() {
+        pyo3::Python::initialize();
+
+        pyo3::Python::attach(|py| {
+            let ann_type = pyo3::Py::new(
+                py,
+                AnnotatedType {
+                    inner: pyo3::Py::new(py, Type::PyInt()).unwrap(),
+                    annotation: Annotation {
+                        default: None,
+                        encoding: None,
+                        size: None,
+                    }
+                    .into_pyobject(py)
+                    .unwrap()
+                    .unbind(),
+                },
+            )
+            .unwrap();
+            let variant = Variant {
+                python_class: pyo3::types::PyInt::type_object(py).unbind(),
+                ann_type,
+                tag_name: None,
+            };
+            let encoding = pyo3::Py::new(py, Encoding::Implicit(3)).ok();
+            assert!(is_tag_valid_for_variant(
+                py,
+                asn1::BigInt::TAG,
+                &variant,
+                &encoding
+            ));
+        })
+    }
 }

tests/hazmat/asn1/test_serialization.py

@@ -488,6 +488,66 @@ class Example:
             ]
         )
 
+    def test_ok_sequence_all_types_default(self) -> None:
+        default_time = datetime.datetime(
+            2019,
+            12,
+            16,
+            3,
+            2,
+            10,
+            tzinfo=datetime.timezone.utc,
+        )
+        default_oid = x509.ObjectIdentifier("1.3.6.1.4.1.343")
+
+        @asn1.sequence
+        @_comparable_dataclass
+        class Example:
+            a: Annotated[int, asn1.Default(3)]
+            b: Annotated[bytes, asn1.Default(b"\x00")]
+            c: Annotated[
+                asn1.PrintableString, asn1.Default(asn1.PrintableString("a"))
+            ]
+            d: Annotated[
+                asn1.UtcTime,
+                asn1.Default(asn1.UtcTime(default_time)),
+            ]
+            e: Annotated[
+                asn1.GeneralizedTime,
+                asn1.Default(asn1.GeneralizedTime(default_time)),
+            ]
+            f: Annotated[typing.List[int], asn1.Default([1])]
+            g: Annotated[
+                asn1.BitString,
+                asn1.Default(
+                    asn1.BitString(data=b"", padding_bits=0),
+                ),
+            ]
+            h: Annotated[asn1.IA5String, asn1.Default(asn1.IA5String("a"))]
+            i: Annotated[
+                x509.ObjectIdentifier,
+                asn1.Default(default_oid),
+            ]
+
+        assert_roundtrips(
+            [
+                (
+                    Example(
+                        a=3,
+                        b=b"\x00",
+                        c=asn1.PrintableString("a"),
+                        d=asn1.UtcTime(default_time),
+                        e=asn1.GeneralizedTime(default_time),
+                        f=[1],
+                        g=asn1.BitString(data=b"", padding_bits=0),
+                        h=asn1.IA5String("a"),
+                        i=default_oid,
+                    ),
+                    b"\x30\x00",
+                )
+            ]
+        )
+
     def test_ok_sequence_with_default_annotations(self) -> None:
         @asn1.sequence
         @_comparable_dataclass