diff --git a/test_suite/tests/test_annotations.rs b/test_suite/tests/test_annotations.rs
index 6864bf96..9aa32872 100644
--- a/test_suite/tests/test_annotations.rs
+++ b/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)]
diff --git a/test_suite/tests/test_enum_internally_tagged.rs b/test_suite/tests/test_enum_internally_tagged.rs
new file mode 100644
index 00000000..b4d428c4
--- /dev/null
+++ b/test_suite/tests/test_enum_internally_tagged.rs
@@ -0,0 +1,1478 @@
+#![deny(trivial_numeric_casts)]
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::enum_variant_names,
+    clippy::redundant_field_names,
+    clippy::too_many_lines
+)]
+
+mod bytes;
+
+use serde_derive::{Deserialize, Serialize};
+use serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};
+use std::collections::BTreeMap;
+use std::iter::FromIterator;
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct Unit;
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct Newtype(BTreeMap<String, String>);
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct Struct {
+    f: u8,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+enum Enum {
+    Unit,
+    Newtype(u8),
+    Tuple(u8, u8),
+    Struct { f: u8 },
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "tag")]
+enum InternallyTagged {
+    Unit,
+    NewtypeUnit(()),
+    NewtypeUnitStruct(Unit),
+    NewtypeNewtype(Newtype),
+    NewtypeMap(BTreeMap<String, String>),
+    NewtypeStruct(Struct),
+    NewtypeEnum(Enum),
+    Struct { a: u8 },
+    StructEnum { enum_: Enum },
+}
+
+#[test]
+fn unit() {
+    assert_tokens(
+        &InternallyTagged::Unit,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 1,
+            },
+            Token::Str("tag"),
+            Token::Str("Unit"),
+            Token::StructEnd,
+        ],
+    );
+    assert_de_tokens(
+        &InternallyTagged::Unit,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 1,
+            },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("Unit"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Unit,
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("tag"),
+            Token::Str("Unit"),
+            Token::MapEnd,
+        ],
+    );
+    assert_de_tokens(
+        &InternallyTagged::Unit,
+        &[
+            Token::Map { len: Some(1) },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("Unit"),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Unit,
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Str("Unit"), // tag
+            Token::SeqEnd,
+        ],
+    );
+    assert_de_tokens(
+        &InternallyTagged::Unit,
+        &[
+            Token::Seq { len: Some(1) },
+            Token::BorrowedStr("Unit"), // tag
+            Token::SeqEnd,
+        ],
+    );
+}
+
+#[test]
+fn newtype_unit() {
+    let value = InternallyTagged::NewtypeUnit(());
+
+    assert_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("tag"),
+            Token::Str("NewtypeUnit"),
+            Token::MapEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(1) },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("NewtypeUnit"),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 1,
+            },
+            Token::Str("tag"),
+            Token::Str("NewtypeUnit"),
+            Token::StructEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 1,
+            },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("NewtypeUnit"),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[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::Map { len: Some(1) },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("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::Struct {
+                name: "InternallyTagged",
+                len: 1,
+            },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("NewtypeUnitStruct"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Seq { len: Some(1) },
+            Token::Str("NewtypeUnitStruct"), // tag
+            Token::SeqEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Seq { len: Some(1) },
+            Token::BorrowedStr("NewtypeUnitStruct"), // tag
+            Token::SeqEnd,
+        ],
+    );
+}
+
+#[test]
+fn newtype_newtype() {
+    assert_tokens(
+        &InternallyTagged::NewtypeNewtype(Newtype(BTreeMap::new())),
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("tag"),
+            Token::Str("NewtypeNewtype"),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn newtype_map() {
+    let value = InternallyTagged::NewtypeMap(BTreeMap::new());
+
+    // Special case: empty map
+    assert_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("tag"),
+            Token::Str("NewtypeMap"),
+            Token::MapEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(1) },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("NewtypeMap"),
+            Token::MapEnd,
+        ],
+    );
+
+    let value = InternallyTagged::NewtypeMap(BTreeMap::from_iter([(
+        "field".to_string(),
+        "value".to_string(),
+    )]));
+
+    // Special case: tag field ("tag") is the first field
+    assert_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("NewtypeMap"),
+            Token::Str("field"),
+            Token::Str("value"),
+            Token::MapEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(2) },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("NewtypeMap"),
+            Token::BorrowedStr("field"),
+            Token::BorrowedStr("value"),
+            Token::MapEnd,
+        ],
+    );
+
+    // General case: tag field ("tag") is not the first field
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("field"),
+            Token::Str("value"),
+            Token::Str("tag"),
+            Token::Str("NewtypeMap"),
+            Token::MapEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(2) },
+            Token::BorrowedStr("field"),
+            Token::BorrowedStr("value"),
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("NewtypeMap"),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens_error::<InternallyTagged>(
+        &[
+            Token::Seq { len: Some(2) },
+            Token::Str("NewtypeMap"), // tag
+            Token::Map { len: Some(0) },
+            Token::MapEnd,
+            Token::SeqEnd,
+        ],
+        "invalid type: sequence, expected a map",
+    );
+}
+
+#[test]
+fn newtype_struct() {
+    let value = InternallyTagged::NewtypeStruct(Struct { f: 6 });
+
+    // Special case: tag field ("tag") is the first field
+    assert_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 2,
+            },
+            Token::Str("tag"),
+            Token::Str("NewtypeStruct"),
+            Token::Str("f"),
+            Token::U8(6),
+            Token::StructEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 2,
+            },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("NewtypeStruct"),
+            Token::BorrowedStr("f"),
+            Token::U8(6),
+            Token::StructEnd,
+        ],
+    );
+
+    // General case: tag field ("tag") is not the first field
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 2,
+            },
+            Token::Str("f"),
+            Token::U8(6),
+            Token::Str("tag"),
+            Token::Str("NewtypeStruct"),
+            Token::StructEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "Struct",
+                len: 2,
+            },
+            Token::BorrowedStr("f"),
+            Token::U8(6),
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("NewtypeStruct"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Seq { len: Some(2) },
+            Token::Str("NewtypeStruct"), // tag
+            Token::U8(6),
+            Token::SeqEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Seq { len: Some(2) },
+            Token::BorrowedStr("NewtypeStruct"), // tag
+            Token::U8(6),
+            Token::SeqEnd,
+        ],
+    );
+}
+
+mod newtype_enum {
+    use super::*;
+
+    #[test]
+    fn unit() {
+        let value = InternallyTagged::NewtypeEnum(Enum::Unit);
+
+        // Special case: tag field ("tag") is the first field
+        assert_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("tag"),
+                Token::Str("NewtypeEnum"),
+                Token::Str("Unit"),
+                Token::Unit,
+                Token::MapEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::BorrowedStr("Unit"),
+                Token::Unit,
+                Token::MapEnd,
+            ],
+        );
+
+        // General case: tag field ("tag") is not the first field
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("Unit"),
+                Token::Unit,
+                Token::Str("tag"),
+                Token::Str("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("Unit"),
+                Token::Unit,
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+    }
+
+    #[test]
+    fn newtype() {
+        let value = InternallyTagged::NewtypeEnum(Enum::Newtype(1));
+
+        // Special case: tag field ("tag") is the first field
+        assert_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("tag"),
+                Token::Str("NewtypeEnum"),
+                Token::Str("Newtype"),
+                Token::U8(1),
+                Token::MapEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::BorrowedStr("Newtype"),
+                Token::U8(1),
+                Token::MapEnd,
+            ],
+        );
+
+        // General case: tag field ("tag") is not the first field
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("Newtype"),
+                Token::U8(1),
+                Token::Str("tag"),
+                Token::Str("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("Newtype"),
+                Token::U8(1),
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+    }
+
+    #[test]
+    fn tuple() {
+        let value = InternallyTagged::NewtypeEnum(Enum::Tuple(1, 1));
+
+        // Special case: tag field ("tag") is the first field
+        assert_tokens(
+            &value,
+            &[
+                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,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::BorrowedStr("Tuple"),
+                Token::TupleStruct {
+                    name: "Tuple",
+                    len: 2,
+                },
+                Token::U8(1),
+                Token::U8(1),
+                Token::TupleStructEnd,
+                Token::MapEnd,
+            ],
+        );
+
+        // Special case: tag field ("tag") is not the first field
+        // Reaches crate::private::de::content::VariantDeserializer::tuple_variant
+        // Content::Seq case
+        // via ContentDeserializer::deserialize_enum
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("Tuple"),
+                Token::TupleStruct {
+                    name: "Tuple",
+                    len: 2,
+                },
+                Token::U8(1),
+                Token::U8(1),
+                Token::TupleStructEnd,
+                Token::Str("tag"),
+                Token::Str("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("Tuple"),
+                Token::TupleStruct {
+                    name: "Tuple",
+                    len: 2,
+                },
+                Token::U8(1),
+                Token::U8(1),
+                Token::TupleStructEnd,
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+    }
+
+    #[test]
+    fn struct_() {
+        let value = InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 });
+
+        // Special case: tag field ("tag") is the first field
+        assert_tokens(
+            &value,
+            &[
+                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,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::BorrowedStr("Struct"),
+                Token::Struct {
+                    name: "Struct",
+                    len: 1,
+                },
+                Token::BorrowedStr("f"),
+                Token::U8(1),
+                Token::StructEnd,
+                Token::MapEnd,
+            ],
+        );
+
+        // General case: tag field ("tag") is not the first field
+        // Reaches crate::private::de::content::VariantDeserializer::struct_variant
+        // Content::Map case
+        // via ContentDeserializer::deserialize_enum
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("Struct"),
+                Token::Struct {
+                    name: "Struct",
+                    len: 1,
+                },
+                Token::Str("f"),
+                Token::U8(1),
+                Token::StructEnd,
+                Token::Str("tag"),
+                Token::Str("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("Struct"),
+                Token::Struct {
+                    name: "Struct",
+                    len: 1,
+                },
+                Token::BorrowedStr("f"),
+                Token::U8(1),
+                Token::StructEnd,
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+
+        // Special case: tag field ("tag") is the first field
+        assert_de_tokens(
+            &value,
+            &[
+                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,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::BorrowedStr("Struct"),
+                Token::Seq { len: Some(1) },
+                Token::U8(1), // f
+                Token::SeqEnd,
+                Token::MapEnd,
+            ],
+        );
+
+        // General case: tag field ("tag") is not the first field
+        // Reaches crate::private::de::content::VariantDeserializer::struct_variant
+        // Content::Seq case
+        // via ContentDeserializer::deserialize_enum
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("Struct"),
+                Token::Seq { len: Some(1) },
+                Token::U8(1), // f
+                Token::SeqEnd,
+                Token::Str("tag"),
+                Token::Str("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("Struct"),
+                Token::Seq { len: Some(1) },
+                Token::U8(1), // f
+                Token::SeqEnd,
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("NewtypeEnum"),
+                Token::MapEnd,
+            ],
+        );
+    }
+}
+
+#[test]
+fn struct_() {
+    let value = InternallyTagged::Struct { a: 1 };
+
+    // Special case: tag field ("tag") is the first field
+    assert_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("tag"),
+            Token::Str("Struct"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::StructEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("Struct"),
+            Token::BorrowedStr("a"),
+            Token::U8(1),
+            Token::StructEnd,
+        ],
+    );
+
+    // General case: tag field ("tag") is not the first field
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("a"),
+            Token::U8(1),
+            Token::Str("tag"),
+            Token::Str("Struct"),
+            Token::StructEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::BorrowedStr("a"),
+            Token::U8(1),
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("Struct"),
+            Token::StructEnd,
+        ],
+    );
+
+    // Special case: tag field ("tag") is the first field
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("Struct"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(2) },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("Struct"),
+            Token::BorrowedStr("a"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+
+    // General case: tag field ("tag") is not the first field
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("a"),
+            Token::U8(1),
+            Token::Str("tag"),
+            Token::Str("Struct"),
+            Token::MapEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: Some(2) },
+            Token::BorrowedStr("a"),
+            Token::U8(1),
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("Struct"),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Seq { len: Some(2) },
+            Token::Str("Struct"), // tag
+            Token::U8(1),
+            Token::SeqEnd,
+        ],
+    );
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Seq { len: Some(2) },
+            Token::BorrowedStr("Struct"), // tag
+            Token::U8(1),
+            Token::SeqEnd,
+        ],
+    );
+}
+
+mod struct_enum {
+    use super::*;
+
+    #[test]
+    fn unit() {
+        assert_de_tokens(
+            &Enum::Unit,
+            &[
+                Token::Enum { name: "Enum" },
+                Token::BorrowedStr("Unit"),
+                Token::Unit,
+            ],
+        );
+
+        let value = InternallyTagged::StructEnum { enum_: Enum::Unit };
+
+        // Special case: tag field ("tag") is the first field
+        assert_tokens(
+            &value,
+            &[
+                Token::Struct {
+                    name: "InternallyTagged",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("StructEnum"),
+                Token::Str("enum_"),
+                Token::Enum { name: "Enum" },
+                Token::Str("Unit"),
+                Token::Unit,
+                Token::StructEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Struct {
+                    name: "InternallyTagged",
+                    len: 2,
+                },
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("StructEnum"),
+                Token::BorrowedStr("enum_"),
+                Token::Enum { name: "Enum" },
+                Token::BorrowedStr("Unit"),
+                Token::Unit,
+                Token::StructEnd,
+            ],
+        );
+
+        // General case: tag field ("tag") is not the first field
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Struct {
+                    name: "InternallyTagged",
+                    len: 2,
+                },
+                Token::Str("enum_"),
+                Token::Enum { name: "Enum" },
+                Token::Str("Unit"),
+                Token::Unit,
+                Token::Str("tag"),
+                Token::Str("StructEnum"),
+                Token::StructEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Struct {
+                    name: "InternallyTagged",
+                    len: 2,
+                },
+                Token::BorrowedStr("enum_"),
+                Token::Enum { name: "Enum" },
+                Token::BorrowedStr("Unit"),
+                Token::Unit,
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("StructEnum"),
+                Token::StructEnd,
+            ],
+        );
+
+        // Special case: tag field ("tag") is the first field
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("tag"),
+                Token::Str("StructEnum"),
+                Token::Str("enum_"),
+                Token::Enum { name: "Enum" },
+                Token::Str("Unit"),
+                Token::Unit,
+                Token::MapEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("StructEnum"),
+                Token::BorrowedStr("enum_"),
+                Token::Enum { name: "Enum" },
+                Token::BorrowedStr("Unit"),
+                Token::Unit,
+                Token::MapEnd,
+            ],
+        );
+
+        // General case: tag field ("tag") is not the first field
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("enum_"),
+                Token::Enum { name: "Enum" },
+                Token::Str("Unit"),
+                Token::Unit,
+                Token::Str("tag"),
+                Token::Str("StructEnum"),
+                Token::MapEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Map { len: Some(2) },
+                Token::BorrowedStr("enum_"),
+                Token::Enum { name: "Enum" },
+                Token::BorrowedStr("Unit"),
+                Token::Unit,
+                Token::BorrowedStr("tag"),
+                Token::BorrowedStr("StructEnum"),
+                Token::MapEnd,
+            ],
+        );
+
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Seq { len: Some(2) },
+                Token::Str("StructEnum"),     // tag
+                Token::Enum { name: "Enum" }, // enum_
+                Token::Str("Unit"),
+                Token::Unit,
+                Token::SeqEnd,
+            ],
+        );
+        assert_de_tokens(
+            &value,
+            &[
+                Token::Seq { len: Some(2) },
+                Token::BorrowedStr("StructEnum"), // tag
+                Token::Enum { name: "Enum" },     // enum_
+                Token::BorrowedStr("Unit"),
+                Token::Unit,
+                Token::SeqEnd,
+            ],
+        );
+    }
+}
+
+#[test]
+fn wrong_tag() {
+    assert_de_tokens_error::<InternallyTagged>(
+        &[Token::Map { len: Some(0) }, Token::MapEnd],
+        "missing field `tag`",
+    );
+
+    assert_de_tokens_error::<InternallyTagged>(
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("tag"),
+            Token::Str("Z"),
+            Token::MapEnd,
+        ],
+        "unknown variant `Z`, expected one of \
+        `Unit`, \
+        `NewtypeUnit`, \
+        `NewtypeUnitStruct`, \
+        `NewtypeNewtype`, \
+        `NewtypeMap`, \
+        `NewtypeStruct`, \
+        `NewtypeEnum`, \
+        `Struct`, \
+        `StructEnum`",
+    );
+}
+
+#[test]
+fn untagged_variant() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "tag")]
+    enum InternallyTagged {
+        Tagged {
+            a: u8,
+        },
+        #[serde(untagged)]
+        Untagged {
+            tag: String,
+            b: u8,
+        },
+    }
+
+    assert_de_tokens(
+        &InternallyTagged::Tagged { a: 1 },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("Tagged"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Tagged { a: 1 },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("tag"),
+            Token::Str("Tagged"),
+            Token::Str("a"),
+            Token::U8(1),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Untagged {
+            tag: "Foo".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Map { len: Some(2) },
+            Token::Str("tag"),
+            Token::Str("Foo"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Untagged {
+            tag: "Foo".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("tag"),
+            Token::Str("Foo"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_tokens(
+        &InternallyTagged::Untagged {
+            tag: "Tagged".to_owned(),
+            b: 2,
+        },
+        &[
+            Token::Struct {
+                name: "InternallyTagged",
+                len: 2,
+            },
+            Token::Str("tag"),
+            Token::Str("Tagged"),
+            Token::Str("b"),
+            Token::U8(2),
+            Token::StructEnd,
+        ],
+    );
+}
+
+mod string_and_bytes {
+    use super::*;
+
+    #[derive(Debug, PartialEq, Deserialize)]
+    #[serde(tag = "tag")]
+    enum InternallyTagged {
+        String {
+            string: String,
+        },
+        Bytes {
+            #[serde(with = "bytes")]
+            bytes: Vec<u8>,
+        },
+    }
+
+    #[test]
+    fn string_from_string() {
+        assert_de_tokens(
+            &InternallyTagged::String {
+                string: "\0".to_owned(),
+            },
+            &[
+                Token::Struct {
+                    name: "String",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("String"),
+                Token::Str("string"),
+                Token::Str("\0"),
+                Token::StructEnd,
+            ],
+        );
+
+        assert_de_tokens(
+            &InternallyTagged::String {
+                string: "\0".to_owned(),
+            },
+            &[
+                Token::Struct {
+                    name: "String",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("String"),
+                Token::Str("string"),
+                Token::String("\0"),
+                Token::StructEnd,
+            ],
+        );
+    }
+
+    #[test]
+    fn string_from_bytes() {
+        assert_de_tokens(
+            &InternallyTagged::String {
+                string: "\0".to_owned(),
+            },
+            &[
+                Token::Struct {
+                    name: "String",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("String"),
+                Token::Str("string"),
+                Token::Bytes(b"\0"),
+                Token::StructEnd,
+            ],
+        );
+
+        assert_de_tokens(
+            &InternallyTagged::String {
+                string: "\0".to_owned(),
+            },
+            &[
+                Token::Struct {
+                    name: "String",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("String"),
+                Token::Str("string"),
+                Token::ByteBuf(b"\0"),
+                Token::StructEnd,
+            ],
+        );
+    }
+
+    #[test]
+    fn bytes_from_string() {
+        assert_de_tokens(
+            &InternallyTagged::Bytes { bytes: vec![0] },
+            &[
+                Token::Struct {
+                    name: "Bytes",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("Bytes"),
+                Token::Str("bytes"),
+                Token::Str("\0"),
+                Token::StructEnd,
+            ],
+        );
+
+        assert_de_tokens(
+            &InternallyTagged::Bytes { bytes: vec![0] },
+            &[
+                Token::Struct {
+                    name: "Bytes",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("Bytes"),
+                Token::Str("bytes"),
+                Token::String("\0"),
+                Token::StructEnd,
+            ],
+        );
+    }
+
+    #[test]
+    fn bytes_from_bytes() {
+        assert_de_tokens(
+            &InternallyTagged::Bytes { bytes: vec![0] },
+            &[
+                Token::Struct {
+                    name: "Bytes",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("Bytes"),
+                Token::Str("bytes"),
+                Token::Bytes(b"\0"),
+                Token::StructEnd,
+            ],
+        );
+
+        assert_de_tokens(
+            &InternallyTagged::Bytes { bytes: vec![0] },
+            &[
+                Token::Struct {
+                    name: "Bytes",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("Bytes"),
+                Token::Str("bytes"),
+                Token::ByteBuf(b"\0"),
+                Token::StructEnd,
+            ],
+        );
+    }
+
+    #[test]
+    fn bytes_from_seq() {
+        assert_de_tokens(
+            &InternallyTagged::Bytes { bytes: vec![0] },
+            &[
+                Token::Struct {
+                    name: "Bytes",
+                    len: 2,
+                },
+                Token::Str("tag"),
+                Token::Str("Bytes"),
+                Token::Str("bytes"),
+                Token::Seq { len: Some(1) },
+                Token::U8(0),
+                Token::SeqEnd,
+                Token::StructEnd,
+            ],
+        );
+    }
+}
+
+#[test]
+fn borrow() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "tag")]
+    enum Input<'a> {
+        Package { name: &'a str },
+    }
+
+    assert_tokens(
+        &Input::Package { name: "borrowed" },
+        &[
+            Token::Struct {
+                name: "Input",
+                len: 2,
+            },
+            Token::BorrowedStr("tag"),
+            Token::BorrowedStr("Package"),
+            Token::BorrowedStr("name"),
+            Token::BorrowedStr("borrowed"),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn with_skipped_conflict() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "tag")]
+    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("tag"),
+            Token::Str("C"),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn containing_flatten() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "tag")]
+    enum Data {
+        A {
+            a: i32,
+            #[serde(flatten)]
+            flat: Flat,
+        },
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Flat {
+        b: i32,
+    }
+
+    let data = Data::A {
+        a: 0,
+        flat: Flat { b: 0 },
+    };
+
+    assert_tokens(
+        &data,
+        &[
+            Token::Map { len: None },
+            Token::Str("tag"),
+            Token::Str("A"),
+            Token::Str("a"),
+            Token::I32(0),
+            Token::Str("b"),
+            Token::I32(0),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn unit_variant_with_unknown_fields() {
+    let value = InternallyTagged::Unit;
+
+    assert_de_tokens(
+        &value,
+        &[
+            Token::Map { len: None },
+            Token::Str("tag"),
+            Token::Str("Unit"),
+            Token::Str("b"),
+            Token::I32(0),
+            Token::MapEnd,
+        ],
+    );
+
+    // Unknown elements are not allowed in sequences
+    assert_de_tokens_error::<InternallyTagged>(
+        &[
+            Token::Seq { len: None },
+            Token::Str("Unit"), // tag
+            Token::I32(0),
+            Token::SeqEnd,
+        ],
+        "invalid length 1, expected 0 elements in sequence",
+    );
+}
+
+#[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",
+    );
+}
diff --git a/test_suite/tests/test_macros.rs b/test_suite/tests/test_macros.rs
index 7bd7a94e..72137ddd 100644
--- a/test_suite/tests/test_macros.rs
+++ b/test_suite/tests/test_macros.rs
@@ -679,485 +679,6 @@ fn test_untagged_enum() {
     );
 }
 
-#[test]
-fn test_internally_tagged_enum() {
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    struct Newtype(BTreeMap<String, String>);
-
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    struct Struct {
-        f: u8,
-    }
-
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "type")]
-    enum InternallyTagged {
-        A { a: u8 },
-        B,
-        C(BTreeMap<String, String>),
-        D(Newtype),
-        E(Struct),
-    }
-
-    assert_tokens(
-        &InternallyTagged::A { a: 1 },
-        &[
-            Token::Struct {
-                name: "InternallyTagged",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("A"),
-            Token::Str("a"),
-            Token::U8(1),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::A { a: 1 },
-        &[
-            Token::Seq { len: Some(2) },
-            Token::Str("A"),
-            Token::U8(1),
-            Token::SeqEnd,
-        ],
-    );
-
-    assert_tokens(
-        &InternallyTagged::B,
-        &[
-            Token::Struct {
-                name: "InternallyTagged",
-                len: 1,
-            },
-            Token::Str("type"),
-            Token::Str("B"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::B,
-        &[Token::Seq { len: Some(1) }, Token::Str("B"), Token::SeqEnd],
-    );
-
-    assert_tokens(
-        &InternallyTagged::C(BTreeMap::new()),
-        &[
-            Token::Map { len: Some(1) },
-            Token::Str("type"),
-            Token::Str("C"),
-            Token::MapEnd,
-        ],
-    );
-
-    assert_de_tokens_error::<InternallyTagged>(
-        &[
-            Token::Seq { len: Some(2) },
-            Token::Str("C"),
-            Token::Map { len: Some(0) },
-            Token::MapEnd,
-            Token::SeqEnd,
-        ],
-        "invalid type: sequence, expected a map",
-    );
-
-    assert_tokens(
-        &InternallyTagged::D(Newtype(BTreeMap::new())),
-        &[
-            Token::Map { len: Some(1) },
-            Token::Str("type"),
-            Token::Str("D"),
-            Token::MapEnd,
-        ],
-    );
-
-    assert_tokens(
-        &InternallyTagged::E(Struct { f: 6 }),
-        &[
-            Token::Struct {
-                name: "Struct",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("E"),
-            Token::Str("f"),
-            Token::U8(6),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::E(Struct { f: 6 }),
-        &[
-            Token::Seq { len: Some(2) },
-            Token::Str("E"),
-            Token::U8(6),
-            Token::SeqEnd,
-        ],
-    );
-
-    assert_de_tokens_error::<InternallyTagged>(
-        &[Token::Map { len: Some(0) }, Token::MapEnd],
-        "missing field `type`",
-    );
-
-    assert_de_tokens_error::<InternallyTagged>(
-        &[
-            Token::Map { len: Some(1) },
-            Token::Str("type"),
-            Token::Str("Z"),
-            Token::MapEnd,
-        ],
-        "unknown variant `Z`, expected one of `A`, `B`, `C`, `D`, `E`",
-    );
-}
-
-#[test]
-fn test_internally_tagged_enum_with_untagged_variant() {
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "kind")]
-    enum InternallyTagged {
-        Tagged {
-            a: u8,
-        },
-        #[serde(untagged)]
-        Untagged {
-            kind: String,
-            b: u8,
-        },
-    }
-
-    assert_de_tokens(
-        &InternallyTagged::Tagged { a: 1 },
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("kind"),
-            Token::Str("Tagged"),
-            Token::Str("a"),
-            Token::U8(1),
-            Token::MapEnd,
-        ],
-    );
-
-    assert_tokens(
-        &InternallyTagged::Tagged { a: 1 },
-        &[
-            Token::Struct {
-                name: "InternallyTagged",
-                len: 2,
-            },
-            Token::Str("kind"),
-            Token::Str("Tagged"),
-            Token::Str("a"),
-            Token::U8(1),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::Untagged {
-            kind: "Foo".to_owned(),
-            b: 2,
-        },
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("kind"),
-            Token::Str("Foo"),
-            Token::Str("b"),
-            Token::U8(2),
-            Token::MapEnd,
-        ],
-    );
-
-    assert_tokens(
-        &InternallyTagged::Untagged {
-            kind: "Foo".to_owned(),
-            b: 2,
-        },
-        &[
-            Token::Struct {
-                name: "InternallyTagged",
-                len: 2,
-            },
-            Token::Str("kind"),
-            Token::Str("Foo"),
-            Token::Str("b"),
-            Token::U8(2),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_tokens(
-        &InternallyTagged::Untagged {
-            kind: "Tagged".to_owned(),
-            b: 2,
-        },
-        &[
-            Token::Struct {
-                name: "InternallyTagged",
-                len: 2,
-            },
-            Token::Str("kind"),
-            Token::Str("Tagged"),
-            Token::Str("b"),
-            Token::U8(2),
-            Token::StructEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_internally_tagged_bytes() {
-    #[derive(Debug, PartialEq, Deserialize)]
-    #[serde(tag = "type")]
-    enum InternallyTagged {
-        String {
-            string: String,
-        },
-        Bytes {
-            #[serde(with = "bytes")]
-            bytes: Vec<u8>,
-        },
-    }
-
-    assert_de_tokens(
-        &InternallyTagged::String {
-            string: "\0".to_owned(),
-        },
-        &[
-            Token::Struct {
-                name: "String",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("String"),
-            Token::Str("string"),
-            Token::Str("\0"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::String {
-            string: "\0".to_owned(),
-        },
-        &[
-            Token::Struct {
-                name: "String",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("String"),
-            Token::Str("string"),
-            Token::String("\0"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::String {
-            string: "\0".to_owned(),
-        },
-        &[
-            Token::Struct {
-                name: "String",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("String"),
-            Token::Str("string"),
-            Token::Bytes(b"\0"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::String {
-            string: "\0".to_owned(),
-        },
-        &[
-            Token::Struct {
-                name: "String",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("String"),
-            Token::Str("string"),
-            Token::ByteBuf(b"\0"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::Bytes { bytes: vec![0] },
-        &[
-            Token::Struct {
-                name: "Bytes",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("Bytes"),
-            Token::Str("bytes"),
-            Token::Str("\0"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::Bytes { bytes: vec![0] },
-        &[
-            Token::Struct {
-                name: "Bytes",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("Bytes"),
-            Token::Str("bytes"),
-            Token::String("\0"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::Bytes { bytes: vec![0] },
-        &[
-            Token::Struct {
-                name: "Bytes",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("Bytes"),
-            Token::Str("bytes"),
-            Token::Bytes(b"\0"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::Bytes { bytes: vec![0] },
-        &[
-            Token::Struct {
-                name: "Bytes",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("Bytes"),
-            Token::Str("bytes"),
-            Token::ByteBuf(b"\0"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &InternallyTagged::Bytes { bytes: vec![0] },
-        &[
-            Token::Struct {
-                name: "Bytes",
-                len: 2,
-            },
-            Token::Str("type"),
-            Token::Str("Bytes"),
-            Token::Str("bytes"),
-            Token::Seq { len: Some(1) },
-            Token::U8(0),
-            Token::SeqEnd,
-            Token::StructEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_internally_tagged_struct_variant_containing_unit_variant() {
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    pub enum Level {
-        Info,
-    }
-
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "action")]
-    pub enum Message {
-        Log { level: Level },
-    }
-
-    assert_de_tokens(
-        &Level::Info,
-        &[
-            Token::Enum { name: "Level" },
-            Token::BorrowedStr("Info"),
-            Token::Unit,
-        ],
-    );
-
-    assert_de_tokens(
-        &Message::Log { level: Level::Info },
-        &[
-            Token::Struct {
-                name: "Message",
-                len: 2,
-            },
-            Token::Str("action"),
-            Token::Str("Log"),
-            Token::Str("level"),
-            Token::Enum { name: "Level" },
-            Token::BorrowedStr("Info"),
-            Token::Unit,
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &Message::Log { level: Level::Info },
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("action"),
-            Token::Str("Log"),
-            Token::Str("level"),
-            Token::Enum { name: "Level" },
-            Token::BorrowedStr("Info"),
-            Token::Unit,
-            Token::MapEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &Message::Log { level: Level::Info },
-        &[
-            Token::Seq { len: Some(2) },
-            Token::Str("Log"),
-            Token::Enum { name: "Level" },
-            Token::BorrowedStr("Info"),
-            Token::Unit,
-            Token::SeqEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_internally_tagged_borrow() {
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "type")]
-    pub enum Input<'a> {
-        Package { name: &'a str },
-    }
-
-    assert_tokens(
-        &Input::Package { name: "borrowed" },
-        &[
-            Token::Struct {
-                name: "Input",
-                len: 2,
-            },
-            Token::BorrowedStr("type"),
-            Token::BorrowedStr("Package"),
-            Token::BorrowedStr("name"),
-            Token::BorrowedStr("borrowed"),
-            Token::StructEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_adjacently_tagged_enum() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -1552,106 +1073,6 @@ fn test_adjacently_tagged_enum_deny_unknown_fields() {
     );
 }
 
-#[test]
-fn test_enum_in_internally_tagged_enum() {
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "type")]
-    enum Outer {
-        Inner(Inner),
-    }
-
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    enum Inner {
-        Unit,
-        Newtype(u8),
-        Tuple(u8, u8),
-        Struct { f: u8 },
-    }
-
-    assert_tokens(
-        &Outer::Inner(Inner::Unit),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("type"),
-            Token::Str("Inner"),
-            Token::Str("Unit"),
-            Token::Unit,
-            Token::MapEnd,
-        ],
-    );
-
-    assert_tokens(
-        &Outer::Inner(Inner::Newtype(1)),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("type"),
-            Token::Str("Inner"),
-            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(
-        &Outer::Inner(Inner::Tuple(1, 1)),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("type"),
-            Token::Str("Inner"),
-            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(
-        &Outer::Inner(Inner::Struct { f: 1 }),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("type"),
-            Token::Str("Inner"),
-            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(
-        &Outer::Inner(Inner::Struct { f: 1 }),
-        &[
-            Token::Map { len: Some(2) },
-            Token::Str("type"),
-            Token::Str("Inner"),
-            Token::Str("Struct"),
-            Token::Seq { len: Some(1) },
-            Token::U8(1), // f
-            Token::SeqEnd,
-            Token::MapEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_internally_tagged_struct() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -2186,50 +1607,6 @@ fn test_untagged_newtype_variant_containing_unit_struct_not_map() {
     );
 }
 
-#[test]
-fn test_internally_tagged_newtype_variant_containing_unit_struct() {
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    struct Info;
-
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "topic")]
-    enum Message {
-        Info(Info),
-    }
-
-    assert_tokens(
-        &Message::Info(Info),
-        &[
-            Token::Map { len: Some(1) },
-            Token::Str("topic"),
-            Token::Str("Info"),
-            Token::MapEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &Message::Info(Info),
-        &[
-            Token::Struct {
-                name: "Message",
-                len: 1,
-            },
-            Token::Str("topic"),
-            Token::Str("Info"),
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &Message::Info(Info),
-        &[
-            Token::Seq { len: Some(1) },
-            Token::Str("Info"),
-            Token::SeqEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_packed_struct_can_derive_serialize() {
     #[derive(Copy, Clone, Serialize)]