Merge pull request #2788 from Mingun/internally-tagged-enum-tests

Consolidate and add new tests of internally tagged enums

Author: dtolnay

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)]