Split test newtype_enum into four tests for each variant

(review this commit with "ignore whitespace changes" option on)

serde/src/private/de.rs

@@ -2153,6 +2153,10 @@ mod content {
         fn unit_variant(self) -> Result<(), E> {
             match self.value {
                 Some(value) => de::Deserialize::deserialize(ContentRefDeserializer::new(value)),
+                // Covered by tests/test_annotations.rs
+                //      test_partially_untagged_adjacently_tagged_enum
+                // Covered by tests/test_enum_untagged.rs
+                //      newtype_enum::unit
                 None => Ok(()),
             }
         }
@@ -2162,6 +2166,11 @@ mod content {
             T: de::DeserializeSeed<'de>,
         {
             match self.value {
+                // Covered by tests/test_annotations.rs
+                //      test_partially_untagged_enum_desugared
+                //      test_partially_untagged_enum_generic
+                // Covered by tests/test_enum_untagged.rs
+                //      newtype_enum::newtype
                 Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
                 None => Err(de::Error::invalid_type(
                     de::Unexpected::UnitVariant,
@@ -2175,6 +2184,11 @@ mod content {
             V: de::Visitor<'de>,
         {
             match self.value {
+                // Covered by tests/test_annotations.rs
+                //      test_partially_untagged_enum
+                //      test_partially_untagged_enum_desugared
+                // Covered by tests/test_enum_untagged.rs
+                //      newtype_enum::tuple2
                 Some(Content::Seq(v)) => {
                     de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
                 }
@@ -2198,6 +2212,8 @@ mod content {
             V: de::Visitor<'de>,
         {
             match self.value {
+                // Covered by tests/test_enum_untagged.rs
+                //      newtype_enum::struct_from_map
                 Some(Content::Map(v)) => {
                     de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
                 }

test_suite/tests/test_enum_untagged.rs

@@ -134,8 +134,9 @@ fn newtype_struct() {
     assert_de_tokens(&value, &[Token::U32(5)]);
 }
 
-#[test]
+mod newtype_enum {
-fn newtype_enum() {
+    use super::*;
+
     #[derive(Debug, PartialEq, Serialize, Deserialize)]
     #[serde(untagged)]
     enum Outer {
@@ -146,56 +147,73 @@ fn newtype_enum() {
     enum Inner {
         Unit,
         Newtype(u8),
-        Tuple(u8, u8),
+        Tuple2(u8, u8),
         Struct { f: u8 },
     }
 
-    assert_tokens(
+    // Reaches crate::private::de::content::VariantRefDeserializer::unit_variant
-        &Outer::Inner(Inner::Unit),
+    #[test]
-        &[Token::UnitVariant {
+    fn unit() {
-            name: "Inner",
+        assert_tokens(
-            variant: "Unit",
+            &Outer::Inner(Inner::Unit),
-        }],
+            &[Token::UnitVariant {
-    );
-
-    assert_tokens(
-        &Outer::Inner(Inner::Newtype(1)),
-        &[
-            Token::NewtypeVariant {
                 name: "Inner",
-                variant: "Newtype",
+                variant: "Unit",
-            },
+            }],
-            Token::U8(1),
+        );
-        ],
+    }
-    );
 
-    assert_tokens(
+    // Reaches crate::private::de::content::VariantRefDeserializer::newtype_variant_seed
-        &Outer::Inner(Inner::Tuple(1, 1)),
+    #[test]
-        &[
+    fn newtype() {
-            Token::TupleVariant {
+        assert_tokens(
-                name: "Inner",
+            &Outer::Inner(Inner::Newtype(1)),
-                variant: "Tuple",
+            &[
-                len: 2,
+                Token::NewtypeVariant {
-            },
+                    name: "Inner",
-            Token::U8(1),
+                    variant: "Newtype",
-            Token::U8(1),
+                },
-            Token::TupleVariantEnd,
+                Token::U8(1),
-        ],
+            ],
-    );
+        );
+    }
 
-    assert_tokens(
+    // Reaches crate::private::de::content::VariantRefDeserializer::tuple_variant
-        &Outer::Inner(Inner::Struct { f: 1 }),
+    #[test]
-        &[
+    fn tuple2() {
-            Token::StructVariant {
+        assert_tokens(
-                name: "Inner",
+            &Outer::Inner(Inner::Tuple2(1, 1)),
-                variant: "Struct",
+            &[
-                len: 1,
+                Token::TupleVariant {
-            },
+                    name: "Inner",
-            Token::Str("f"),
+                    variant: "Tuple2",
-            Token::U8(1),
+                    len: 2,
-            Token::StructVariantEnd,
+                },
-        ],
+                Token::U8(1),
-    );
+                Token::U8(1),
+                Token::TupleVariantEnd,
+            ],
+        );
+    }
+
+    // Reaches crate::private::de::content::VariantRefDeserializer::struct_variant
+    // Content::Map case
+    #[test]
+    fn struct_from_map() {
+        assert_tokens(
+            &Outer::Inner(Inner::Struct { f: 1 }),
+            &[
+                Token::StructVariant {
+                    name: "Inner",
+                    variant: "Struct",
+                    len: 1,
+                },
+                Token::Str("f"),
+                Token::U8(1),
+                Token::StructVariantEnd,
+            ],
+        );
+    }
 }
 
 // Reaches crate::private::de::content::ContentRefDeserializer::deserialize_option