From f6eb34a83059c35bb6c1e9104e39e7157dbe90bc Mon Sep 17 00:00:00 2001
From: Mingun <Alexander_Sergey@mail.ru>
Date: Thu, 22 Oct 2020 10:03:39 +0500
Subject: [PATCH] Assert that numeric field identifiers correctly deserialized
 (now failing)

---
 test_suite/tests/test_de.rs         | 101 ++++++++++++++++++++++++++++
 test_suite/tests/test_identifier.rs |  13 ++++
 2 files changed, 114 insertions(+)

diff --git a/test_suite/tests/test_de.rs b/test_suite/tests/test_de.rs
index 025d87b0..03b03941 100644
--- a/test_suite/tests/test_de.rs
+++ b/test_suite/tests/test_de.rs
@@ -622,6 +622,24 @@ declare_tests! {
                 Token::I32(2),
             Token::MapEnd,
         ],
+        Struct { a: 1, b: 2, c: 0 } => &[
+            Token::Map { len: Some(3) },
+                Token::U8(0),
+                Token::I32(1),
+
+                Token::U8(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        Struct { a: 1, b: 2, c: 0 } => &[
+            Token::Map { len: Some(3) },
+                Token::U16(0),
+                Token::I32(1),
+
+                Token::U16(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
         Struct { a: 1, b: 2, c: 0 } => &[
             Token::Map { len: Some(3) },
                 Token::U32(0),
@@ -631,6 +649,34 @@ declare_tests! {
                 Token::I32(2),
             Token::MapEnd,
         ],
+        Struct { a: 1, b: 2, c: 0 } => &[
+            Token::Map { len: Some(3) },
+                Token::U64(0),
+                Token::I32(1),
+
+                Token::U64(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        // Mixed key types
+        Struct { a: 1, b: 2, c: 0 } => &[
+            Token::Map { len: Some(3) },
+                Token::U8(0),
+                Token::I32(1),
+
+                Token::U64(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        Struct { a: 1, b: 2, c: 0 } => &[
+            Token::Map { len: Some(3) },
+                Token::U8(0),
+                Token::I32(1),
+
+                Token::Str("b"),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
         Struct { a: 1, b: 2, c: 0 } => &[
             Token::Struct { name: "Struct", len: 2 },
                 Token::Str("a"),
@@ -663,6 +709,21 @@ declare_tests! {
                 Token::I32(4),
             Token::MapEnd,
         ],
+        Struct { a: 1, b: 2, c: 0 } => &[
+            Token::Map { len: Some(3) },
+                Token::U8(0),
+                Token::I32(1),
+
+                Token::U16(1),
+                Token::I32(2),
+
+                Token::U32(2),
+                Token::I32(3),
+
+                Token::U64(3),
+                Token::I32(4),
+            Token::MapEnd,
+        ],
         Struct { a: 1, b: 2, c: 0 } => &[
             Token::Struct { name: "Struct", len: 2 },
                 Token::Str("a"),
@@ -780,6 +841,26 @@ declare_tests! {
             Token::Str("Unit"),
             Token::Unit,
         ],
+        EnumOther::Unit => &[
+            Token::Enum { name: "EnumOther" },
+            Token::U8(0),
+            Token::Unit,
+        ],
+        EnumOther::Unit => &[
+            Token::Enum { name: "EnumOther" },
+            Token::U16(0),
+            Token::Unit,
+        ],
+        EnumOther::Unit => &[
+            Token::Enum { name: "EnumOther" },
+            Token::U32(0),
+            Token::Unit,
+        ],
+        EnumOther::Unit => &[
+            Token::Enum { name: "EnumOther" },
+            Token::U64(0),
+            Token::Unit,
+        ],
     }
     test_enum_other {
         EnumOther::Other => &[
@@ -787,6 +868,26 @@ declare_tests! {
             Token::Str("Foo"),
             Token::Unit,
         ],
+        EnumOther::Other => &[
+            Token::Enum { name: "EnumOther" },
+            Token::U8(42),
+            Token::Unit,
+        ],
+        EnumOther::Other => &[
+            Token::Enum { name: "EnumOther" },
+            Token::U16(42),
+            Token::Unit,
+        ],
+        EnumOther::Other => &[
+            Token::Enum { name: "EnumOther" },
+            Token::U32(42),
+            Token::Unit,
+        ],
+        EnumOther::Other => &[
+            Token::Enum { name: "EnumOther" },
+            Token::U64(42),
+            Token::Unit,
+        ],
     }
     test_box {
         Box::new(0i32) => &[Token::I32(0)],
diff --git a/test_suite/tests/test_identifier.rs b/test_suite/tests/test_identifier.rs
index eba7d4da..12c6697e 100644
--- a/test_suite/tests/test_identifier.rs
+++ b/test_suite/tests/test_identifier.rs
@@ -1,3 +1,4 @@
+//! Tests for `#[serde(field_identifier)]` and `#[serde(variant_identifier)]`
 use serde::Deserialize;
 use serde_test::{assert_de_tokens, Token};
 
@@ -27,6 +28,10 @@ fn test_field_identifier() {
         Bbb,
     }
 
+    assert_de_tokens(&F::Aaa, &[Token::U8(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U16(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U32(0)]);
+    assert_de_tokens(&F::Aaa, &[Token::U64(0)]);
     assert_de_tokens(&F::Aaa, &[Token::Str("aaa")]);
     assert_de_tokens(&F::Aaa, &[Token::Bytes(b"aaa")]);
 }
@@ -42,6 +47,10 @@ fn test_unit_fallthrough() {
         Other,
     }
 
+    assert_de_tokens(&F::Other, &[Token::U8(42)]);
+    assert_de_tokens(&F::Other, &[Token::U16(42)]);
+    assert_de_tokens(&F::Other, &[Token::U32(42)]);
+    assert_de_tokens(&F::Other, &[Token::U64(42)]);
     assert_de_tokens(&F::Other, &[Token::Str("x")]);
 }
 
@@ -68,5 +77,9 @@ fn test_newtype_fallthrough_generic() {
         Other(T),
     }
 
+    assert_de_tokens(&F::Other(42u8), &[Token::U8(42)]);
+    assert_de_tokens(&F::Other(42u16), &[Token::U16(42)]);
+    assert_de_tokens(&F::Other(42u32), &[Token::U32(42)]);
+    assert_de_tokens(&F::Other(42u64), &[Token::U64(42)]);
     assert_de_tokens(&F::Other("x".to_owned()), &[Token::Str("x")]);
 }