Move and rename tests:

- newtype_variant_containing_unit                   -> newtype_unit
- newtype_variant_containing_unit_struct            -> newtype_unit_struct
- newtype_variant_containing_externally_tagged_enum -> newtype_enum
- struct_variant_containing_unit_variant            -> struct_enum

test_suite/tests/test_enum_internally_tagged.rs

@@ -70,6 +70,58 @@ fn unit() {
     );
 }
 
+#[test]
+fn newtype_unit() {
+    let value = InternallyTagged::NewtypeUnit(());
+
+    assert_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("tag"),
+            Token::Str("NewtypeUnit"),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn newtype_unit_struct() {
+    let value = InternallyTagged::NewtypeUnitStruct(Unit);
+
+    assert_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("tag"),
+            Token::Str("NewtypeUnitStruct"),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 1,
+            },
+            Token::Str("tag"),
+            Token::Str("NewtypeUnitStruct"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Str("NewtypeUnitStruct"), // tag
+            Token::SeqEnd,
+        ],
+    );
+}
+
 #[test]
 fn newtype_newtype() {
     assert_tokens(
@@ -135,6 +187,92 @@ fn newtype_struct() {
     );
 }
 
+#[test]
+fn newtype_enum() {
+    assert_tokens(
+        &InternallyTagged::NewtypeEnum(Enum::Unit),
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("NewtypeEnum"),
+            Token::Str("Unit"),
+            Token::Unit,
+            Token::MapEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::NewtypeEnum(Enum::Newtype(1)),
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("NewtypeEnum"),
+            Token::Str("Newtype"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+
+    // Reaches crate::private::de::content::VariantDeserializer::tuple_variant
+    // Content::Seq case
+    // via ContentDeserializer::deserialize_enum
+    assert_tokens(
+        &InternallyTagged::NewtypeEnum(Enum::Tuple(1, 1)),
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("NewtypeEnum"),
+            Token::Str("Tuple"),
+            Token::TupleStruct {
+                name: "Tuple",
+                len: 2,
+            },
+            Token::U8(1),
+            Token::U8(1),
+            Token::TupleStructEnd,
+            Token::MapEnd,
+        ],
+    );
+
+    // Reaches crate::private::de::content::VariantDeserializer::struct_variant
+    // Content::Map case
+    // via ContentDeserializer::deserialize_enum
+    assert_tokens(
+        &InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }),
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("NewtypeEnum"),
+            Token::Str("Struct"),
+            Token::Struct {
+                name: "Struct",
+                len: 1,
+            },
+            Token::Str("f"),
+            Token::U8(1),
+            Token::StructEnd,
+            Token::MapEnd,
+        ],
+    );
+
+    // Reaches crate::private::de::content::VariantDeserializer::struct_variant
+    // Content::Seq case
+    // via ContentDeserializer::deserialize_enum
+    assert_de_tokens(
+        &InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }),
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("NewtypeEnum"),
+            Token::Str("Struct"),
+            Token::Seq { len: Some(1) },
+            Token::U8(1), // f
+            Token::SeqEnd,
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn struct_() {
     assert_tokens(
@@ -163,6 +301,63 @@ fn struct_() {
     );
 }
 
+#[test]
+fn struct_enum() {
+    assert_de_tokens(
+        &Enum::Unit,
+        &[
+            Token::Enum { name: "Enum" },
+            Token::BorrowedStr("Unit"),
+            Token::Unit,
+        ],
+    );
+
+    let value = InternallyTagged::StructEnum { enum_: Enum::Unit };
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("tag"),
+            Token::Str("StructEnum"),
+            Token::Str("enum_"),
+            Token::Enum { name: "Enum" },
+            Token::BorrowedStr("Unit"),
+            Token::Unit,
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("StructEnum"),
+            Token::Str("enum_"),
+            Token::Enum { name: "Enum" },
+            Token::BorrowedStr("Unit"),
+            Token::Unit,
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Seq { len: Some(2) },
+            Token::Str("StructEnum"),     // tag
+            Token::Enum { name: "Enum" }, // enum_
+            Token::BorrowedStr("Unit"),
+            Token::Unit,
+            Token::SeqEnd,
+        ],
+    );
+}
+
 #[test]
 fn wrong_tag() {
     assert_de_tokens_error::<InternallyTagged>(
@@ -460,63 +655,6 @@ mod string_and_bytes {
     }
 }
 
-#[test]
-fn struct_variant_containing_unit_variant() {
-    assert_de_tokens(
-        &Enum::Unit,
-        &[
-            Token::Enum { name: "Enum" },
-            Token::BorrowedStr("Unit"),
-            Token::Unit,
-        ],
-    );
-
-    let value = InternallyTagged::StructEnum { enum_: Enum::Unit };
-
-    assert_de_tokens(
-        &value,
-        &[
-            Token::Struct {
-                name: "InternallyTagged",
-                len: 2,
-            },
-            Token::Str("tag"),
-            Token::Str("StructEnum"),
-            Token::Str("enum_"),
-            Token::Enum { name: "Enum" },
-            Token::BorrowedStr("Unit"),
-            Token::Unit,
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &value,
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("tag"),
-            Token::Str("StructEnum"),
-            Token::Str("enum_"),
-            Token::Enum { name: "Enum" },
-            Token::BorrowedStr("Unit"),
-            Token::Unit,
-            Token::MapEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &value,
-        &[
-            Token::Seq { len: Some(2) },
-            Token::Str("StructEnum"),     // tag
-            Token::Enum { name: "Enum" }, // enum_
-            Token::BorrowedStr("Unit"),
-            Token::Unit,
-            Token::SeqEnd,
-        ],
-    );
-}
-
 #[test]
 fn borrow() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -541,129 +679,6 @@ fn borrow() {
     );
 }
 
-#[test]
-fn newtype_variant_containing_externally_tagged_enum() {
-    assert_tokens(
-        &InternallyTagged::NewtypeEnum(Enum::Unit),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("tag"),
-            Token::Str("NewtypeEnum"),
-            Token::Str("Unit"),
-            Token::Unit,
-            Token::MapEnd,
-        ],
-    );
-
-    assert_tokens(
-        &InternallyTagged::NewtypeEnum(Enum::Newtype(1)),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("tag"),
-            Token::Str("NewtypeEnum"),
-            Token::Str("Newtype"),
-            Token::U8(1),
-            Token::MapEnd,
-        ],
-    );
-
-    // Reaches crate::private::de::content::VariantDeserializer::tuple_variant
-    // Content::Seq case
-    // via ContentDeserializer::deserialize_enum
-    assert_tokens(
-        &InternallyTagged::NewtypeEnum(Enum::Tuple(1, 1)),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("tag"),
-            Token::Str("NewtypeEnum"),
-            Token::Str("Tuple"),
-            Token::TupleStruct {
-                name: "Tuple",
-                len: 2,
-            },
-            Token::U8(1),
-            Token::U8(1),
-            Token::TupleStructEnd,
-            Token::MapEnd,
-        ],
-    );
-
-    // Reaches crate::private::de::content::VariantDeserializer::struct_variant
-    // Content::Map case
-    // via ContentDeserializer::deserialize_enum
-    assert_tokens(
-        &InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("tag"),
-            Token::Str("NewtypeEnum"),
-            Token::Str("Struct"),
-            Token::Struct {
-                name: "Struct",
-                len: 1,
-            },
-            Token::Str("f"),
-            Token::U8(1),
-            Token::StructEnd,
-            Token::MapEnd,
-        ],
-    );
-
-    // Reaches crate::private::de::content::VariantDeserializer::struct_variant
-    // Content::Seq case
-    // via ContentDeserializer::deserialize_enum
-    assert_de_tokens(
-        &InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("tag"),
-            Token::Str("NewtypeEnum"),
-            Token::Str("Struct"),
-            Token::Seq { len: Some(1) },
-            Token::U8(1), // f
-            Token::SeqEnd,
-            Token::MapEnd,
-        ],
-    );
-}
-
-#[test]
-fn newtype_variant_containing_unit_struct() {
-    let value = InternallyTagged::NewtypeUnitStruct(Unit);
-
-    assert_tokens(
-        &value,
-        &[
-            Token::Map { len: Some(1) },
-            Token::Str("tag"),
-            Token::Str("NewtypeUnitStruct"),
-            Token::MapEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &value,
-        &[
-            Token::Struct {
-                name: "InternallyTagged",
-                len: 1,
-            },
-            Token::Str("tag"),
-            Token::Str("NewtypeUnitStruct"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &value,
-        &[
-            Token::Seq { len: Some(1) },
-            Token::Str("NewtypeUnitStruct"), // tag
-            Token::SeqEnd,
-        ],
-    );
-}
-
 #[test]
 fn with_skipped_conflict() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -734,21 +749,6 @@ fn containing_flatten() {
     );
 }
 
-#[test]
-fn newtype_variant_containing_unit() {
-    let value = InternallyTagged::NewtypeUnit(());
-
-    assert_tokens(
-        &value,
-        &[
-            Token::Map { len: Some(1) },
-            Token::Str("tag"),
-            Token::Str("NewtypeUnit"),
-            Token::MapEnd,
-        ],
-    );
-}
-
 #[test]
 fn unit_variant_with_unknown_fields() {
     let value = InternallyTagged::Unit;