1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
|
use serde_derive::Deserialize;
use serde_json::{json, Value};
use std::collections::HashMap;
use std::fs::File;
use std::io::prelude::*;
mod common;
use crate::common::{deserializes_to, serializes_to, Val};
#[test]
fn serializes_example_infinite() {
let mut map = HashMap::new();
map.insert("inf".to_string(), Val::Number(f64::INFINITY));
serializes_to(Val::Object(map), "{\"inf\":Infinity}");
serializes_to(json!({ "inf": f64::INFINITY }), "{\"inf\":null}");
let mut map2 = HashMap::new();
map2.insert("neg_inf".to_string(), Val::Number(f64::NEG_INFINITY));
serializes_to(Val::Object(map2), "{\"neg_inf\":-Infinity}");
serializes_to(
json!({ "neg_inf": f64::NEG_INFINITY }),
"{\"neg_inf\":null}",
);
}
#[test]
fn deserializes_example_infinite() {
let mut contents = String::new();
File::open("tests/assets/infinite.json5")
.unwrap()
.read_to_string(&mut contents)
.unwrap();
#[derive(Deserialize, PartialEq, Debug)]
struct InfiniteF64 {
inf: f64,
neg_inf: f64,
}
let expected_f64 = InfiniteF64 {
inf: f64::INFINITY,
neg_inf: f64::NEG_INFINITY,
};
deserializes_to(&contents, expected_f64);
#[derive(Deserialize, PartialEq, Debug)]
struct InfiniteF32 {
inf: f32,
neg_inf: f32,
}
let expected_f32 = InfiniteF32 {
inf: f32::INFINITY,
neg_inf: f32::NEG_INFINITY,
};
deserializes_to(&contents, expected_f32);
let mut map = HashMap::new();
map.insert("inf".to_owned(), Val::Number(f64::INFINITY));
map.insert("neg_inf".to_owned(), Val::Number(f64::NEG_INFINITY));
deserializes_to::<Val>(&contents, Val::Object(map));
deserializes_to::<Value>(
&contents,
json!({
"inf": null,
"neg_inf": null
}),
)
}
#[test]
fn serializes_example_nan() {
let mut map = HashMap::new();
map.insert("nan".to_string(), Val::Number(f64::NAN));
serializes_to(Val::Object(map), "{\"nan\":NaN}");
serializes_to(json!({ "nan": f64::NAN }), "{\"nan\":null}");
let mut map2 = HashMap::new();
map2.insert("neg_nan".to_string(), Val::Number(f64::NAN));
serializes_to(Val::Object(map2), "{\"neg_nan\":NaN}");
serializes_to(json!({ "neg_nan": f64::NAN }), "{\"neg_nan\":null}");
}
#[test]
fn deserializes_example_nan() {
let mut contents = String::new();
File::open("tests/assets/nan.json5")
.unwrap()
.read_to_string(&mut contents)
.unwrap();
#[derive(Deserialize, PartialEq, Debug)]
struct NanF64 {
nan: f64,
neg_nan: f64,
}
match json5::from_str::<NanF64>(&contents) {
Ok(value) => assert!(value.nan.is_nan() && value.neg_nan.is_nan()),
Err(err) => panic!(format!("{}", err)),
}
#[derive(Deserialize, PartialEq, Debug)]
struct NanF32 {
nan: f32,
neg_nan: f32,
}
match json5::from_str::<NanF32>(&contents) {
Ok(value) => assert!(value.nan.is_nan() && value.neg_nan.is_nan()),
Err(err) => panic!(format!("{}", err)),
}
let mut map = HashMap::new();
map.insert("nan".to_string(), Val::Number(f64::NAN));
map.insert("neg_nan".to_string(), Val::Number(f64::NAN));
match json5::from_str::<Val>(&contents) {
Ok(value) => match value {
Val::Object(v) => {
let nan = match v.get(&"nan".to_string()).unwrap() {
Val::Number(n) => n,
_ => panic!("not NaN"),
};
let neg_nan = match v.get(&"neg_nan".to_string()).unwrap() {
Val::Number(n) => n,
_ => panic!("not NaN"),
};
assert!(nan.is_nan() && neg_nan.is_nan())
}
_ => panic!("not NaN"),
},
Err(err) => panic!(format!("{}", err)),
}
deserializes_to::<Value>(
&contents,
json!({
"nan": null,
"neg_nan": null
}),
)
}
|