Move all other internally tagged enum tests into a dedicated file

Moved all except flattened tests:
- test_internally_tagged_enum_with_skipped_conflict    => with_skipped_conflict
- test_internally_tagged_enum_new_type_with_unit       => newtype_variant_containing_unit
- test_internally_tagged_unit_enum_with_unknown_fields => unit_variant_with_unknown_fields
- test_expecting_message_internally_tagged_enum        => expecting_message
- flatten::enum_::internally_tagged::straightforward   => containing_flatten

Author: Mingun

test_suite/tests/test_annotations.rs

@@ -1607,58 +1607,6 @@ fn test_collect_other() {
     );
 }
 
-#[test]
-fn test_internally_tagged_enum_with_skipped_conflict() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    #[serde(tag = "t")]
-    enum Data {
-        A,
-        #[serde(skip)]
-        #[allow(dead_code)]
-        B {
-            t: String,
-        },
-        C {
-            #[serde(default, skip)]
-            t: String,
-        },
-    }
-
-    let data = Data::C { t: String::new() };
-
-    assert_tokens(
-        &data,
-        &[
-            Token::Struct {
-                name: "Data",
-                len: 1,
-            },
-            Token::Str("t"),
-            Token::Str("C"),
-            Token::StructEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_internally_tagged_enum_new_type_with_unit() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    #[serde(tag = "t")]
-    enum Data {
-        A(()),
-    }
-
-    assert_tokens(
-        &Data::A(()),
-        &[
-            Token::Map { len: Some(1) },
-            Token::Str("t"),
-            Token::Str("A"),
-            Token::MapEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_adjacently_tagged_enum_bytes() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -1968,29 +1916,6 @@ fn test_transparent_tuple_struct() {
     assert_tokens(&Transparent(false, 1, false, PhantomData), &[Token::U32(1)]);
 }
 
-#[test]
-fn test_internally_tagged_unit_enum_with_unknown_fields() {
-    #[derive(Deserialize, PartialEq, Debug)]
-    #[serde(tag = "t")]
-    enum Data {
-        A,
-    }
-
-    let data = Data::A;
-
-    assert_de_tokens(
-        &data,
-        &[
-            Token::Map { len: None },
-            Token::Str("t"),
-            Token::Str("A"),
-            Token::Str("b"),
-            Token::I32(0),
-            Token::MapEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_expecting_message() {
     #[derive(Deserialize, PartialEq, Debug)]
@@ -2055,27 +1980,6 @@ fn test_expecting_message_externally_tagged_enum() {
     );
 }
 
-#[test]
-fn test_expecting_message_internally_tagged_enum() {
-    #[derive(Deserialize)]
-    #[serde(tag = "tag")]
-    #[serde(expecting = "something strange...")]
-    enum Enum {
-        InternallyTagged,
-    }
-
-    assert_de_tokens_error::<Enum>(
-        &[Token::Str("InternallyTagged")],
-        r#"invalid type: string "InternallyTagged", expected something strange..."#,
-    );
-
-    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
-    assert_de_tokens_error::<Enum>(
-        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
-        "invalid type: unit value, expected variant identifier",
-    );
-}
-
 #[test]
 fn test_expecting_message_adjacently_tagged_enum() {
     #[derive(Deserialize)]
@@ -3123,43 +3027,6 @@ mod flatten {
         mod internally_tagged {
             use super::*;
 
-            #[test]
-            fn straightforward() {
-                #[derive(Serialize, Deserialize, PartialEq, Debug)]
-                #[serde(tag = "t")]
-                enum Data {
-                    A {
-                        a: i32,
-                        #[serde(flatten)]
-                        flat: Flat,
-                    },
-                }
-
-                #[derive(Serialize, Deserialize, PartialEq, Debug)]
-                struct Flat {
-                    b: i32,
-                }
-
-                let data = Data::A {
-                    a: 0,
-                    flat: Flat { b: 0 },
-                };
-
-                assert_tokens(
-                    &data,
-                    &[
-                        Token::Map { len: None },
-                        Token::Str("t"),
-                        Token::Str("A"),
-                        Token::Str("a"),
-                        Token::I32(0),
-                        Token::Str("b"),
-                        Token::I32(0),
-                        Token::MapEnd,
-                    ],
-                );
-            }
-
             #[test]
             fn structs() {
                 #[derive(Debug, PartialEq, Serialize, Deserialize)]

test_suite/tests/test_enum_internally_tagged.rs

@@ -668,4 +668,137 @@ fn newtype_variant_containing_unit_struct() {
             Token::SeqEnd,
         ],
     );
-}
+}
+
+#[test]
+fn with_skipped_conflict() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t")]
+    enum Data {
+        A,
+        #[serde(skip)]
+        #[allow(dead_code)]
+        B {
+            t: String,
+        },
+        C {
+            #[serde(default, skip)]
+            t: String,
+        },
+    }
+
+    let data = Data::C { t: String::new() };
+
+    assert_tokens(
+        &data,
+        &[
+            Token::Struct {
+                name: "Data",
+                len: 1,
+            },
+            Token::Str("t"),
+            Token::Str("C"),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn containing_flatten() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t")]
+    enum Data {
+        A {
+            a: i32,
+            #[serde(flatten)]
+            flat: Flat,
+        },
+    }
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct Flat {
+        b: i32,
+    }
+
+    let data = Data::A {
+        a: 0,
+        flat: Flat { b: 0 },
+    };
+
+    assert_tokens(
+        &data,
+        &[
+            Token::Map { len: None },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::Str("a"),
+            Token::I32(0),
+            Token::Str("b"),
+            Token::I32(0),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn newtype_variant_containing_unit() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t")]
+    enum Data {
+        A(()),
+    }
+
+    assert_tokens(
+        &Data::A(()),
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn unit_variant_with_unknown_fields() {
+    #[derive(Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t")]
+    enum Data {
+        A,
+    }
+
+    let data = Data::A;
+
+    assert_de_tokens(
+        &data,
+        &[
+            Token::Map { len: None },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::Str("b"),
+            Token::I32(0),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn expecting_message() {
+    #[derive(Deserialize)]
+    #[serde(tag = "tag")]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        InternallyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("InternallyTagged")],
+        r#"invalid type: string "InternallyTagged", expected something strange..."#,
+    );
+
+    // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
+        "invalid type: unit value, expected variant identifier",
+    );
+}