Move all adjacently tagged enum tests (except flatten) into a dedicated module

Moved and renamed:
From test_annotatons
- test_adjacently_tagged_enum_bytes               => bytes
- flatten::enum_::adjacently_tagged::straitforward=> struct_with_flatten
- test_expecting_message_adjacently_tagged_enum   => expecting_message
- test_partially_untagged_adjacently_tagged_enum  => partially_untagged

From test_macros
- test_adjacently_tagged_newtype_struct           => newtype_with_newtype
- test_adjacently_tagged_enum
- test_adjacently_tagged_enum_deny_unknown_fields => deny_unknown_fields

test_suite/tests/test_annotations.rs

@@ -1607,59 +1607,6 @@ fn test_collect_other() {
     );
 }
 
-#[test]
-fn test_adjacently_tagged_enum_bytes() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    #[serde(tag = "t", content = "c")]
-    enum Data {
-        A { a: i32 },
-    }
-
-    let data = Data::A { a: 0 };
-
-    assert_tokens(
-        &data,
-        &[
-            Token::Struct {
-                name: "Data",
-                len: 2,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "Data",
-                variant: "A",
-            },
-            Token::Str("c"),
-            Token::Struct { name: "A", len: 1 },
-            Token::Str("a"),
-            Token::I32(0),
-            Token::StructEnd,
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens(
-        &data,
-        &[
-            Token::Struct {
-                name: "Data",
-                len: 2,
-            },
-            Token::Bytes(b"t"),
-            Token::UnitVariant {
-                name: "Data",
-                variant: "A",
-            },
-            Token::Bytes(b"c"),
-            Token::Struct { name: "A", len: 1 },
-            Token::Str("a"),
-            Token::I32(0),
-            Token::StructEnd,
-            Token::StructEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_partially_untagged_enum() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -1846,38 +1793,6 @@ fn test_partially_untagged_internally_tagged_enum() {
     // TODO test error output
 }
 
-#[test]
-fn test_partially_untagged_adjacently_tagged_enum() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    #[serde(tag = "t", content = "c")]
-    enum Data {
-        A(u32),
-        B,
-        #[serde(untagged)]
-        Var(u32),
-    }
-
-    let data = Data::A(7);
-
-    assert_de_tokens(
-        &data,
-        &[
-            Token::Map { len: None },
-            Token::Str("t"),
-            Token::Str("A"),
-            Token::Str("c"),
-            Token::U32(7),
-            Token::MapEnd,
-        ],
-    );
-
-    let data = Data::Var(42);
-
-    assert_de_tokens(&data, &[Token::U32(42)]);
-
-    // TODO test error output
-}
-
 #[test]
 fn test_transparent_struct() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
@@ -1980,32 +1895,6 @@ fn test_expecting_message_externally_tagged_enum() {
     );
 }
 
-#[test]
-fn test_expecting_message_adjacently_tagged_enum() {
-    #[derive(Deserialize)]
-    #[serde(tag = "tag", content = "content")]
-    #[serde(expecting = "something strange...")]
-    enum Enum {
-        AdjacentlyTagged,
-    }
-
-    assert_de_tokens_error::<Enum>(
-        &[Token::Str("AdjacentlyTagged")],
-        r#"invalid type: string "AdjacentlyTagged", expected something strange..."#,
-    );
-
-    assert_de_tokens_error::<Enum>(
-        &[Token::Map { len: None }, Token::Unit],
-        r#"invalid type: unit value, expected "tag", "content", or other ignored fields"#,
-    );
-
-    // 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 of enum Enum",
-    );
-}
-
 #[test]
 fn test_expecting_message_untagged_tagged_enum() {
     #[derive(Deserialize)]
@@ -2891,52 +2780,6 @@ mod flatten {
         mod adjacently_tagged {
             use super::*;
 
-            #[test]
-            fn straightforward() {
-                #[derive(Serialize, Deserialize, PartialEq, Debug)]
-                #[serde(tag = "t", content = "c")]
-                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::Struct {
-                            name: "Data",
-                            len: 2,
-                        },
-                        Token::Str("t"),
-                        Token::UnitVariant {
-                            name: "Data",
-                            variant: "A",
-                        },
-                        Token::Str("c"),
-                        Token::Map { len: None },
-                        Token::Str("a"),
-                        Token::I32(0),
-                        Token::Str("b"),
-                        Token::I32(0),
-                        Token::MapEnd,
-                        Token::StructEnd,
-                    ],
-                );
-            }
-
             #[derive(Debug, PartialEq, Serialize, Deserialize)]
             struct Flatten {
                 outer: u32,

test_suite/tests/test_enum_adjacently_tagged.rs

@@ -0,0 +1,594 @@
+#![deny(trivial_numeric_casts)]
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::enum_variant_names,
+    clippy::redundant_field_names,
+    clippy::too_many_lines
+)]
+
+use serde_derive::{Deserialize, Serialize};
+use serde_test::{
+    assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_tokens, Token,
+};
+
+#[test]
+fn test_adjacently_tagged_enum() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "t", content = "c")]
+    enum AdjacentlyTagged<T> {
+        Unit,
+        Newtype(T),
+        Tuple(u8, u8),
+        Struct { f: u8 },
+    }
+
+    // unit with no content
+    assert_ser_tokens(
+        &AdjacentlyTagged::Unit::<u8>,
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 1,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Unit",
+            },
+            Token::StructEnd,
+        ],
+    );
+
+    // unit with no content
+    assert_de_tokens(
+        &AdjacentlyTagged::Unit::<u8>,
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Unit",
+            },
+            Token::StructEnd,
+        ],
+    );
+
+    // unit with tag first
+    assert_de_tokens(
+        &AdjacentlyTagged::Unit::<u8>,
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Unit",
+            },
+            Token::Str("c"),
+            Token::Unit,
+            Token::StructEnd,
+        ],
+    );
+
+    // unit with content first
+    assert_de_tokens(
+        &AdjacentlyTagged::Unit::<u8>,
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("c"),
+            Token::Unit,
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Unit",
+            },
+            Token::StructEnd,
+        ],
+    );
+
+    // unit with excess content (f, g, h)
+    assert_de_tokens(
+        &AdjacentlyTagged::Unit::<u8>,
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("f"),
+            Token::Unit,
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Unit",
+            },
+            Token::Str("g"),
+            Token::Unit,
+            Token::Str("c"),
+            Token::Unit,
+            Token::Str("h"),
+            Token::Unit,
+            Token::StructEnd,
+        ],
+    );
+
+    // newtype with tag first
+    assert_tokens(
+        &AdjacentlyTagged::Newtype::<u8>(1),
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Newtype",
+            },
+            Token::Str("c"),
+            Token::U8(1),
+            Token::StructEnd,
+        ],
+    );
+
+    // newtype with content first
+    assert_de_tokens(
+        &AdjacentlyTagged::Newtype::<u8>(1),
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("c"),
+            Token::U8(1),
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Newtype",
+            },
+            Token::StructEnd,
+        ],
+    );
+
+    // optional newtype with no content field
+    assert_de_tokens(
+        &AdjacentlyTagged::Newtype::<Option<u8>>(None),
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 1,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Newtype",
+            },
+            Token::StructEnd,
+        ],
+    );
+
+    // tuple with tag first
+    assert_tokens(
+        &AdjacentlyTagged::Tuple::<u8>(1, 1),
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Tuple",
+            },
+            Token::Str("c"),
+            Token::Tuple { len: 2 },
+            Token::U8(1),
+            Token::U8(1),
+            Token::TupleEnd,
+            Token::StructEnd,
+        ],
+    );
+
+    // tuple with content first
+    assert_de_tokens(
+        &AdjacentlyTagged::Tuple::<u8>(1, 1),
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("c"),
+            Token::Tuple { len: 2 },
+            Token::U8(1),
+            Token::U8(1),
+            Token::TupleEnd,
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Tuple",
+            },
+            Token::StructEnd,
+        ],
+    );
+
+    // struct with tag first
+    assert_tokens(
+        &AdjacentlyTagged::Struct::<u8> { f: 1 },
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Struct",
+            },
+            Token::Str("c"),
+            Token::Struct {
+                name: "Struct",
+                len: 1,
+            },
+            Token::Str("f"),
+            Token::U8(1),
+            Token::StructEnd,
+            Token::StructEnd,
+        ],
+    );
+
+    // struct with content first
+    assert_de_tokens(
+        &AdjacentlyTagged::Struct::<u8> { f: 1 },
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("c"),
+            Token::Struct {
+                name: "Struct",
+                len: 1,
+            },
+            Token::Str("f"),
+            Token::U8(1),
+            Token::StructEnd,
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Struct",
+            },
+            Token::StructEnd,
+        ],
+    );
+
+    // integer field keys
+    assert_de_tokens(
+        &AdjacentlyTagged::Newtype::<u8>(1),
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::U64(1), // content field
+            Token::U8(1),
+            Token::U64(0), // tag field
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Newtype",
+            },
+            Token::StructEnd,
+        ],
+    );
+
+    // byte-array field keys
+    assert_de_tokens(
+        &AdjacentlyTagged::Newtype::<u8>(1),
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Bytes(b"c"),
+            Token::U8(1),
+            Token::Bytes(b"t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Newtype",
+            },
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn bytes() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t", content = "c")]
+    enum Data {
+        A { a: i32 },
+    }
+
+    let data = Data::A { a: 0 };
+
+    assert_tokens(
+        &data,
+        &[
+            Token::Struct {
+                name: "Data",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "Data",
+                variant: "A",
+            },
+            Token::Str("c"),
+            Token::Struct { name: "A", len: 1 },
+            Token::Str("a"),
+            Token::I32(0),
+            Token::StructEnd,
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &data,
+        &[
+            Token::Struct {
+                name: "Data",
+                len: 2,
+            },
+            Token::Bytes(b"t"),
+            Token::UnitVariant {
+                name: "Data",
+                variant: "A",
+            },
+            Token::Bytes(b"c"),
+            Token::Struct { name: "A", len: 1 },
+            Token::Str("a"),
+            Token::I32(0),
+            Token::StructEnd,
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn struct_with_flatten() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t", content = "c")]
+    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::Struct {
+                name: "Data",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "Data",
+                variant: "A",
+            },
+            Token::Str("c"),
+            Token::Map { len: None },
+            Token::Str("a"),
+            Token::I32(0),
+            Token::Str("b"),
+            Token::I32(0),
+            Token::MapEnd,
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn expecting_message() {
+    #[derive(Deserialize)]
+    #[serde(tag = "tag", content = "content")]
+    #[serde(expecting = "something strange...")]
+    enum Enum {
+        AdjacentlyTagged,
+    }
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Str("AdjacentlyTagged")],
+        r#"invalid type: string "AdjacentlyTagged", expected something strange..."#,
+    );
+
+    assert_de_tokens_error::<Enum>(
+        &[Token::Map { len: None }, Token::Unit],
+        r#"invalid type: unit value, expected "tag", "content", or other ignored fields"#,
+    );
+
+    // 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 of enum Enum",
+    );
+}
+
+#[test]
+fn partially_untagged() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    #[serde(tag = "t", content = "c")]
+    enum Data {
+        A(u32),
+        B,
+        #[serde(untagged)]
+        Var(u32),
+    }
+
+    let data = Data::A(7);
+
+    assert_de_tokens(
+        &data,
+        &[
+            Token::Map { len: None },
+            Token::Str("t"),
+            Token::Str("A"),
+            Token::Str("c"),
+            Token::U32(7),
+            Token::MapEnd,
+        ],
+    );
+
+    let data = Data::Var(42);
+
+    assert_de_tokens(&data, &[Token::U32(42)]);
+
+    // TODO test error output
+}
+
+#[test]
+fn newtype_with_newtype() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct GenericNewTypeStruct<T>(T);
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "t", content = "c")]
+    enum E {
+        Newtype(GenericNewTypeStruct<u32>),
+        Null,
+    }
+
+    assert_de_tokens(
+        &E::Newtype(GenericNewTypeStruct(5u32)),
+        &[
+            Token::Struct { name: "E", len: 2 },
+            Token::Str("c"),
+            Token::NewtypeStruct {
+                name: "GenericNewTypeStruct",
+            },
+            Token::U32(5),
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "E",
+                variant: "Newtype",
+            },
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn deny_unknown_fields() {
+    #[derive(Debug, PartialEq, Deserialize)]
+    #[serde(tag = "t", content = "c", deny_unknown_fields)]
+    enum AdjacentlyTagged {
+        Unit,
+    }
+
+    assert_de_tokens(
+        &AdjacentlyTagged::Unit,
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Unit",
+            },
+            Token::Str("c"),
+            Token::Unit,
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens_error::<AdjacentlyTagged>(
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("t"),
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Unit",
+            },
+            Token::Str("c"),
+            Token::Unit,
+            Token::Str("h"),
+        ],
+        r#"invalid value: string "h", expected "t" or "c""#,
+    );
+
+    assert_de_tokens_error::<AdjacentlyTagged>(
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("h"),
+        ],
+        r#"invalid value: string "h", expected "t" or "c""#,
+    );
+
+    assert_de_tokens_error::<AdjacentlyTagged>(
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Str("c"),
+            Token::Unit,
+            Token::Str("h"),
+        ],
+        r#"invalid value: string "h", expected "t" or "c""#,
+    );
+
+    assert_de_tokens_error::<AdjacentlyTagged>(
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::U64(0), // tag field
+            Token::UnitVariant {
+                name: "AdjacentlyTagged",
+                variant: "Unit",
+            },
+            Token::U64(3),
+        ],
+        r#"invalid value: integer `3`, expected "t" or "c""#,
+    );
+
+    assert_de_tokens_error::<AdjacentlyTagged>(
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 2,
+            },
+            Token::Bytes(b"c"),
+            Token::Unit,
+            Token::Bytes(b"h"),
+        ],
+        r#"invalid value: byte array, expected "t" or "c""#,
+    );
+}

test_suite/tests/test_macros.rs

@@ -453,34 +453,6 @@ fn test_untagged_newtype_struct() {
     );
 }
 
-#[test]
-fn test_adjacently_tagged_newtype_struct() {
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "t", content = "c")]
-    enum E {
-        Newtype(GenericNewTypeStruct<u32>),
-        Null,
-    }
-
-    assert_de_tokens(
-        &E::Newtype(GenericNewTypeStruct(5u32)),
-        &[
-            Token::Struct { name: "E", len: 2 },
-            Token::Str("c"),
-            Token::NewtypeStruct {
-                name: "GenericNewTypeStruct",
-            },
-            Token::U32(5),
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "E",
-                variant: "Newtype",
-            },
-            Token::StructEnd,
-        ],
-    );
-}
-
 #[test]
 fn test_generic_tuple_struct() {
     assert_tokens(
@@ -679,400 +651,6 @@ fn test_untagged_enum() {
     );
 }
 
-#[test]
-fn test_adjacently_tagged_enum() {
-    #[derive(Debug, PartialEq, Serialize, Deserialize)]
-    #[serde(tag = "t", content = "c")]
-    enum AdjacentlyTagged<T> {
-        Unit,
-        Newtype(T),
-        Tuple(u8, u8),
-        Struct { f: u8 },
-    }
-
-    // unit with no content
-    assert_ser_tokens(
-        &AdjacentlyTagged::Unit::<u8>,
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 1,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Unit",
-            },
-            Token::StructEnd,
-        ],
-    );
-
-    // unit with no content
-    assert_de_tokens(
-        &AdjacentlyTagged::Unit::<u8>,
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Unit",
-            },
-            Token::StructEnd,
-        ],
-    );
-
-    // unit with tag first
-    assert_de_tokens(
-        &AdjacentlyTagged::Unit::<u8>,
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Unit",
-            },
-            Token::Str("c"),
-            Token::Unit,
-            Token::StructEnd,
-        ],
-    );
-
-    // unit with content first
-    assert_de_tokens(
-        &AdjacentlyTagged::Unit::<u8>,
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("c"),
-            Token::Unit,
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Unit",
-            },
-            Token::StructEnd,
-        ],
-    );
-
-    // unit with excess content (f, g, h)
-    assert_de_tokens(
-        &AdjacentlyTagged::Unit::<u8>,
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("f"),
-            Token::Unit,
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Unit",
-            },
-            Token::Str("g"),
-            Token::Unit,
-            Token::Str("c"),
-            Token::Unit,
-            Token::Str("h"),
-            Token::Unit,
-            Token::StructEnd,
-        ],
-    );
-
-    // newtype with tag first
-    assert_tokens(
-        &AdjacentlyTagged::Newtype::<u8>(1),
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Newtype",
-            },
-            Token::Str("c"),
-            Token::U8(1),
-            Token::StructEnd,
-        ],
-    );
-
-    // newtype with content first
-    assert_de_tokens(
-        &AdjacentlyTagged::Newtype::<u8>(1),
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("c"),
-            Token::U8(1),
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Newtype",
-            },
-            Token::StructEnd,
-        ],
-    );
-
-    // optional newtype with no content field
-    assert_de_tokens(
-        &AdjacentlyTagged::Newtype::<Option<u8>>(None),
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 1,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Newtype",
-            },
-            Token::StructEnd,
-        ],
-    );
-
-    // tuple with tag first
-    assert_tokens(
-        &AdjacentlyTagged::Tuple::<u8>(1, 1),
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Tuple",
-            },
-            Token::Str("c"),
-            Token::Tuple { len: 2 },
-            Token::U8(1),
-            Token::U8(1),
-            Token::TupleEnd,
-            Token::StructEnd,
-        ],
-    );
-
-    // tuple with content first
-    assert_de_tokens(
-        &AdjacentlyTagged::Tuple::<u8>(1, 1),
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("c"),
-            Token::Tuple { len: 2 },
-            Token::U8(1),
-            Token::U8(1),
-            Token::TupleEnd,
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Tuple",
-            },
-            Token::StructEnd,
-        ],
-    );
-
-    // struct with tag first
-    assert_tokens(
-        &AdjacentlyTagged::Struct::<u8> { f: 1 },
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Struct",
-            },
-            Token::Str("c"),
-            Token::Struct {
-                name: "Struct",
-                len: 1,
-            },
-            Token::Str("f"),
-            Token::U8(1),
-            Token::StructEnd,
-            Token::StructEnd,
-        ],
-    );
-
-    // struct with content first
-    assert_de_tokens(
-        &AdjacentlyTagged::Struct::<u8> { f: 1 },
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("c"),
-            Token::Struct {
-                name: "Struct",
-                len: 1,
-            },
-            Token::Str("f"),
-            Token::U8(1),
-            Token::StructEnd,
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Struct",
-            },
-            Token::StructEnd,
-        ],
-    );
-
-    // integer field keys
-    assert_de_tokens(
-        &AdjacentlyTagged::Newtype::<u8>(1),
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::U64(1), // content field
-            Token::U8(1),
-            Token::U64(0), // tag field
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Newtype",
-            },
-            Token::StructEnd,
-        ],
-    );
-
-    // byte-array field keys
-    assert_de_tokens(
-        &AdjacentlyTagged::Newtype::<u8>(1),
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Bytes(b"c"),
-            Token::U8(1),
-            Token::Bytes(b"t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Newtype",
-            },
-            Token::StructEnd,
-        ],
-    );
-}
-
-#[test]
-fn test_adjacently_tagged_enum_deny_unknown_fields() {
-    #[derive(Debug, PartialEq, Deserialize)]
-    #[serde(tag = "t", content = "c", deny_unknown_fields)]
-    enum AdjacentlyTagged {
-        Unit,
-    }
-
-    assert_de_tokens(
-        &AdjacentlyTagged::Unit,
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Unit",
-            },
-            Token::Str("c"),
-            Token::Unit,
-            Token::StructEnd,
-        ],
-    );
-
-    assert_de_tokens_error::<AdjacentlyTagged>(
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("t"),
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Unit",
-            },
-            Token::Str("c"),
-            Token::Unit,
-            Token::Str("h"),
-        ],
-        r#"invalid value: string "h", expected "t" or "c""#,
-    );
-
-    assert_de_tokens_error::<AdjacentlyTagged>(
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("h"),
-        ],
-        r#"invalid value: string "h", expected "t" or "c""#,
-    );
-
-    assert_de_tokens_error::<AdjacentlyTagged>(
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Str("c"),
-            Token::Unit,
-            Token::Str("h"),
-        ],
-        r#"invalid value: string "h", expected "t" or "c""#,
-    );
-
-    assert_de_tokens_error::<AdjacentlyTagged>(
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::U64(0), // tag field
-            Token::UnitVariant {
-                name: "AdjacentlyTagged",
-                variant: "Unit",
-            },
-            Token::U64(3),
-        ],
-        r#"invalid value: integer `3`, expected "t" or "c""#,
-    );
-
-    assert_de_tokens_error::<AdjacentlyTagged>(
-        &[
-            Token::Struct {
-                name: "AdjacentlyTagged",
-                len: 2,
-            },
-            Token::Bytes(b"c"),
-            Token::Unit,
-            Token::Bytes(b"h"),
-        ],
-        r#"invalid value: byte array, expected "t" or "c""#,
-    );
-}
-
 #[test]
 fn test_internally_tagged_struct() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]