95 lines
2.5 KiB
Rust
95 lines
2.5 KiB
Rust
use serde::de::value::{self, MapAccessDeserializer};
|
|
use serde::de::{IntoDeserializer, MapAccess, Visitor};
|
|
use serde::{Deserialize, Deserializer};
|
|
use serde_test::{assert_de_tokens, Token};
|
|
use std::fmt;
|
|
|
|
#[test]
|
|
fn test_u32_to_enum() {
|
|
#[derive(Deserialize, Debug, PartialEq)]
|
|
enum E {
|
|
A,
|
|
B,
|
|
}
|
|
|
|
let deserializer = IntoDeserializer::<value::Error>::into_deserializer(1u32);
|
|
let e: E = E::deserialize(deserializer).unwrap();
|
|
assert_eq!(E::B, e);
|
|
}
|
|
|
|
#[cfg(not(any(target_arch = "asmjs", target_arch = "wasm32")))]
|
|
#[test]
|
|
fn test_integer128() {
|
|
let de_u128 = IntoDeserializer::<value::Error>::into_deserializer(1u128);
|
|
let de_i128 = IntoDeserializer::<value::Error>::into_deserializer(1i128);
|
|
|
|
// u128 to u128
|
|
assert_eq!(1u128, u128::deserialize(de_u128).unwrap());
|
|
|
|
// u128 to i128
|
|
assert_eq!(1i128, i128::deserialize(de_u128).unwrap());
|
|
|
|
// i128 to u128
|
|
assert_eq!(1u128, u128::deserialize(de_i128).unwrap());
|
|
|
|
// i128 to i128
|
|
assert_eq!(1i128, i128::deserialize(de_i128).unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_map_access_to_enum() {
|
|
#[derive(PartialEq, Debug)]
|
|
struct Potential(PotentialKind);
|
|
|
|
#[derive(PartialEq, Debug, Deserialize)]
|
|
enum PotentialKind {
|
|
Airebo(Airebo),
|
|
}
|
|
|
|
#[derive(PartialEq, Debug, Deserialize)]
|
|
struct Airebo {
|
|
lj_sigma: f64,
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for Potential {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
struct PotentialVisitor;
|
|
|
|
impl<'de> Visitor<'de> for PotentialVisitor {
|
|
type Value = Potential;
|
|
|
|
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(formatter, "a map")
|
|
}
|
|
|
|
fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
|
|
where
|
|
A: MapAccess<'de>,
|
|
{
|
|
Deserialize::deserialize(MapAccessDeserializer::new(map)).map(Potential)
|
|
}
|
|
}
|
|
|
|
deserializer.deserialize_any(PotentialVisitor)
|
|
}
|
|
}
|
|
|
|
let expected = Potential(PotentialKind::Airebo(Airebo { lj_sigma: 14.0 }));
|
|
|
|
assert_de_tokens(
|
|
&expected,
|
|
&[
|
|
Token::Map { len: Some(1) },
|
|
Token::Str("Airebo"),
|
|
Token::Map { len: Some(1) },
|
|
Token::Str("lj_sigma"),
|
|
Token::F64(14.0),
|
|
Token::MapEnd,
|
|
Token::MapEnd,
|
|
],
|
|
);
|
|
}
|