fix tests

paritytech · Nov 9, 2021 · 9574a9b · 9574a9b
1 parent 3861b7f
commit 9574a9b
Show file tree

Hide file tree

Showing 3 changed files with 52 additions and 11 deletions.
diff --git a/ethereum-types/src/uint.rs b/ethereum-types/src/uint.rs
@@ -58,12 +58,29 @@ mod tests {
 					assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
 				}
 
+				let tests = vec![
+					($name::from(0), "0"),
+					($name::from(1), "1"),
+					($name::from(2), "2"),
+					($name::from(10), "a"),
+					($name::from(15), "f"),
+					($name::from(15), "f"),
+					($name::from(16), "10"),
+					($name::from(1_000), "3e8"),
+					($name::from(100_000), "186a0"),
+					($name::from(u64::max_value()), "ffffffffffffffff"),
+					($name::from(u64::max_value()) + 1, "10000000000000000"),
+				];
+
+				for (number, expected) in tests {
+					assert_eq!(format!("{:?}", "0x".to_string() + expected), ser::to_string_pretty(&number).unwrap());
+					assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
+				}
+
 				// Invalid examples
 				assert!(ser::from_str::<$name>("\"0x\"").unwrap_err().is_data());
 				assert!(ser::from_str::<$name>("\"0xg\"").unwrap_err().is_data());
 				assert!(ser::from_str::<$name>("\"\"").unwrap_err().is_data());
-				assert!(ser::from_str::<$name>("\"10\"").unwrap_err().is_data());
-				assert!(ser::from_str::<$name>("\"0\"").unwrap_err().is_data());
 			}
 		};
 	}

diff --git a/ethereum-types/tests/serde.rs b/ethereum-types/tests/serde.rs
@@ -32,12 +32,29 @@ macro_rules! test {
 				assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
 			}
 
+			let tests = vec![
+				($name::from(0), "0"),
+				($name::from(1), "1"),
+				($name::from(2), "2"),
+				($name::from(10), "a"),
+				($name::from(15), "f"),
+				($name::from(15), "f"),
+				($name::from(16), "10"),
+				($name::from(1_000), "3e8"),
+				($name::from(100_000), "186a0"),
+				($name::from(u64::max_value()), "ffffffffffffffff"),
+				($name::from(u64::max_value()) + $name::from(1u64), "10000000000000000"),
+			];
+
+			for (number, expected) in tests {
+				assert_eq!(format!("{:?}", "0x".to_string() + expected), ser::to_string_pretty(&number).unwrap());
+				assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
+			}
+
 			// Invalid examples
 			assert!(ser::from_str::<$name>("\"0x\"").unwrap_err().is_data());
 			assert!(ser::from_str::<$name>("\"0xg\"").unwrap_err().is_data());
 			assert!(ser::from_str::<$name>("\"\"").unwrap_err().is_data());
-			assert!(ser::from_str::<$name>("\"10\"").unwrap_err().is_data());
-			assert!(ser::from_str::<$name>("\"0\"").unwrap_err().is_data());
 		}
 	};
 }
@@ -109,8 +126,15 @@ fn test_invalid() {
 }
 
 #[test]
-fn test_invalid_char() {
+fn test_invalid_char_with_prefix() {
 	const INVALID_STR: &str = "\"0x000000000000000000000000000000000000000000000000000000000000000g\"";
 	const EXPECTED_MSG: &str = "invalid hex character: g, at 65 at line 1 column 68";
 	assert_eq!(ser::from_str::<H256>(INVALID_STR).unwrap_err().to_string(), EXPECTED_MSG);
 }
+
+#[test]
+fn test_invalid_char_without_prefix() {
+	const INVALID_STR: &str = "\"000000000000000000000000000000000000000000000000000000000000000g\"";
+	const EXPECTED_MSG: &str = "invalid hex character: g, at 63 at line 1 column 66";
+	assert_eq!(ser::from_str::<H256>(INVALID_STR).unwrap_err().to_string(), EXPECTED_MSG);
+}
diff --git a/primitive-types/impls/serde/src/serialize.rs b/primitive-types/impls/serde/src/serialize.rs
@@ -93,18 +93,18 @@ impl fmt::Display for FromHexError {
 ///
 /// Returns an error if non-hex characters are present.
 pub fn from_hex(v: &str) -> Result<Vec<u8>, FromHexError> {
-	let v = v.strip_prefix("0x").unwrap_or(v);
+	let (v, stripped) = if v.starts_with("0x") { (v.strip_prefix("0x").unwrap(), true) } else { (v, false) };
 
 	let mut bytes = vec![0u8; (v.len() + 1) / 2];
-	from_hex_raw(v, &mut bytes)?;
+	from_hex_raw(v, &mut bytes, stripped)?;
 	Ok(bytes)
 }
 
 /// Decode given 0x-prefix-stripped hex string into provided slice.
 /// Used internally by `from_hex` and `deserialize_check_len`.
 ///
 /// The method will panic if `bytes` have incorrect length (make sure to allocate enough beforehand).
-fn from_hex_raw<'a>(v: &str, bytes: &mut [u8]) -> Result<usize, FromHexError> {
+fn from_hex_raw<'a>(v: &str, bytes: &mut [u8], stripped: bool) -> Result<usize, FromHexError> {
 	let bytes_len = v.len();
 	let mut modulus = bytes_len % 2;
 	let mut buf = 0;
@@ -122,7 +122,7 @@ fn from_hex_raw<'a>(v: &str, bytes: &mut [u8]) -> Result<usize, FromHexError> {
 			},
 			b => {
 				let character = char::from(b);
-				return Err(FromHexError::InvalidHex { character, index })
+				return Err(FromHexError::InvalidHex { character, index: index + if stripped { 2 } else { 0 } })
 			},
 		}
 
@@ -237,7 +237,7 @@ where
 		}
 
 		fn visit_str<E: de::Error>(self, v: &str) -> Result<Self::Value, E> {
-			let v = v.strip_prefix("0x").unwrap_or(v);
+			let (v, stripped) = if v.starts_with("0x") { (v.strip_prefix("0x").unwrap(), true) } else { (v, false) };
 
 			let len = v.len();
 			let is_len_valid = match self.len {
@@ -254,7 +254,7 @@ where
 				ExpectedLen::Between(_, slice) => slice,
 			};
 
-			from_hex_raw(v, bytes).map_err(E::custom)
+			from_hex_raw(v, bytes, stripped).map_err(E::custom)
 		}
 
 		fn visit_string<E: de::Error>(self, v: String) -> Result<Self::Value, E> {