diff --git a/test_suite/tests/test_macros.rs b/test_suite/tests/test_macros.rs
index 4291841a..84f2f444 100644
--- a/test_suite/tests/test_macros.rs
+++ b/test_suite/tests/test_macros.rs
@@ -831,350 +831,510 @@ mod internally_tagged_enum {
             "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,
-        },
+    #[test]
+    fn 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,
+            ],
+        );
     }
 
-    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,
-        ],
-    );
+    mod string_and_bytes {
+        use super::*;
 
-    assert_tokens(
-        &InternallyTagged::Tagged { a: 1 },
-        &[
-            Token::Struct {
-                name: "InternallyTagged",
-                len: 2,
+        #[derive(Debug, PartialEq, Deserialize)]
+        #[serde(tag = "type")]
+        enum InternallyTagged {
+            String {
+                string: String,
             },
-            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,
+            Bytes {
+                #[serde(with = "bytes")]
+                bytes: Vec<u8>,
             },
-            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 string_from_string() {
+            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,
+                ],
+            );
 
-#[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::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("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,
+                ],
+            );
+        }
+
+        #[test]
+        fn bytes_from_string() {
+            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,
+                ],
+            );
+        }
+
+        #[test]
+        fn bytes_from_bytes() {
+            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,
+                ],
+            );
+        }
+
+        #[test]
+        fn bytes_from_seq() {
+            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,
+                ],
+            );
+        }
     }
 
-    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,
-        ],
-    );
+    #[test]
+    fn struct_variant_containing_unit_variant() {
+        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+        pub enum Level {
+            Info,
+        }
 
-    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,
-        ],
-    );
+        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+        #[serde(tag = "action")]
+        pub enum Message {
+            Log { level: Level },
+        }
 
-    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(
+            &Level::Info,
+            &[
+                Token::Enum { name: "Level" },
+                Token::BorrowedStr("Info"),
+                Token::Unit,
+            ],
+        );
 
-    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(
+            &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(
-        &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(
+            &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(
-        &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,
+        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,
+            ],
+        );
     }
 
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "action")]
-    pub enum Message {
-        Log { level: Level },
+    #[test]
+    fn borrow() {
+        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+        #[serde(tag = "type")]
+        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,
+            ],
+        );
     }
 
-    assert_de_tokens(
-        &Level::Info,
-        &[
-            Token::Enum { name: "Level" },
-            Token::BorrowedStr("Info"),
-            Token::Unit,
-        ],
-    );
+    #[test]
+    fn newtype_variant_containing_externally_tagged_enum() {
+        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+        #[serde(tag = "type")]
+        enum Outer {
+            Inner(Inner),
+        }
 
-    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,
-        ],
-    );
+        #[derive(Debug, PartialEq, Serialize, Deserialize)]
+        enum Inner {
+            Unit,
+            Newtype(u8),
+            Tuple(u8, u8),
+            Struct { f: u8 },
+        }
 
-    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_tokens(
+            &Outer::Inner(Inner::Unit),
+            &[
+                Token::Map { len: Some(2) },
+                Token::Str("type"),
+                Token::Str("Inner"),
+                Token::Str("Unit"),
+                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,
-        ],
-    );
-}
+        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,
+            ],
+        );
 
-#[test]
-fn test_internally_tagged_borrow() {
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "type")]
-    pub enum Input<'a> {
-        Package { name: &'a str },
+        // 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,
+            ],
+        );
     }
 
-    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 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]
@@ -1571,106 +1731,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)]
@@ -2205,50 +2265,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)]