use std::borrow::Cow;
use jsonx_lib::{
DuplicateKeys, ErrorKind, Event, Kind, Limits, Number, Object, Parser, Reader, Value, json,
};
#[test]
fn test_strings_without_escapes_borrow_from_the_input() {
let text = "[\"plain\", \"esc\\taped\", 12.50]";
let v = jsonx_lib::parse(text).unwrap_or_default();
assert!(matches!(&v[0], Value::String(Cow::Borrowed("plain"))));
assert!(matches!(&v[1], Value::String(Cow::Owned(s)) if s == "esc\taped"));
let inner = v[0].as_str().unwrap_or_default();
assert!(text.as_bytes().as_ptr_range().contains(&inner.as_ptr()));
assert_eq!(v[2].as_number().map(Number::as_str), Some("12.50"));
}
#[test]
fn test_reader_json_rpc_envelope_reads_members_and_raw_params() {
struct Envelope<'a> {
id: Option<&'a str>,
method: Option<Cow<'a, str>>,
params: Option<&'a str>,
result: Option<&'a str>,
}
fn envelope(body: &str) -> Result<Envelope<'_>, jsonx_lib::Error> {
let mut r = Reader::new(body);
let mut env = Envelope {
id: None,
method: None,
params: None,
result: None,
};
if r.next_event()? != Some(Event::StartObject) {
return Err(jsonx_lib::parse("x").unwrap_err());
}
while let Some(Event::Key(key)) = r.next_event()? {
match &*key {
"id" => env.id = r.read_raw()?,
"method" => match r.next_event()? {
Some(Event::String(m)) => env.method = Some(m),
_ => env.method = None,
},
"params" => env.params = r.read_raw()?,
"result" => env.result = r.read_raw()?,
_ => {
let _ignored = r.read_raw()?;
}
}
}
r.finish()?;
Ok(env)
}
let req = envelope(r#"{"jsonrpc":"2.0","id":"a","method":"m","params":[1, {"x": "\n"}]}"#);
let req = req.unwrap_or_else(|e| panic!("{e}"));
assert_eq!(req.id, Some("\"a\""));
assert!(matches!(req.method, Some(Cow::Borrowed("m"))));
assert_eq!(req.params, Some(r#"[1, {"x": "\n"}]"#));
assert_eq!(req.result, None);
let resp = envelope(r#"{"id":1,"result":null}"#).unwrap_or_else(|e| panic!("{e}"));
assert_eq!(resp.result, Some("null"));
assert_eq!(resp.id, Some("1"));
let broken = envelope(r#"{"id":1,"result":null,}"#);
assert_eq!(
broken.err().map(|e| e.kind()),
Some(ErrorKind::TrailingComma)
);
}
#[test]
fn test_reader_raw_reads_where_no_value_comes_consume_nothing() {
let mut r = Reader::new(r#"{"a": [1, 2], "b": {}}"#);
assert_eq!(r.next_event().ok().flatten(), Some(Event::StartObject));
assert_eq!(r.read_raw().ok(), Some(None));
assert_eq!(r.read_value().ok(), Some(None));
assert_eq!(r.next_event().ok().flatten(), Some(Event::Key("a".into())));
assert_eq!(r.event_offset(), 1);
assert_eq!(r.next_event().ok().flatten(), Some(Event::StartArray));
assert_eq!(r.depth(), 2);
assert_eq!(r.read_value().ok().flatten(), Some(json!(1)));
assert_eq!(r.read_raw().ok().flatten(), Some("2"));
assert_eq!(r.read_raw().ok(), Some(None)); assert_eq!(r.next_event().ok().flatten(), Some(Event::EndArray));
assert_eq!(r.next_event().ok().flatten(), Some(Event::Key("b".into())));
assert_eq!(r.read_value().ok().flatten(), Some(json!({})));
assert_eq!(r.next_event().ok().flatten(), Some(Event::EndObject));
assert_eq!(r.read_raw().ok(), Some(None)); assert_eq!(r.next_event().ok(), Some(None));
assert_eq!(r.next_event().ok(), Some(None));
}
#[test]
fn test_reader_after_an_error_returns_the_same_error() {
let mut r = Reader::new("[1 2]");
let _start = r.next_event();
let _one = r.next_event();
let first = r.next_event().err();
assert_eq!(
first.map(|e| (e.kind(), e.offset())),
Some((ErrorKind::ExpectedCommaOrBracket, 3))
);
assert_eq!(r.next_event().err(), first);
assert_eq!(r.read_raw().err(), first);
assert_eq!(r.read_value().err(), first);
let items: Vec<_> = Reader::new("[1 2]").collect();
assert_eq!(items.len(), 3);
assert!(items.last().is_some_and(Result::is_err));
let over = Parser::new()
.limits(Limits::new().with_max_input_bytes(1))
.reader("[]");
let items: Vec<_> = over.collect();
assert_eq!(items.len(), 1);
}
#[test]
fn test_read_value_with_duplicates_applies_the_policy() {
let text = r#"{"x": {"k": 1, "k": 2}}"#;
let mut r = Reader::new(text);
let _start = r.next_event();
let _key = r.next_event();
assert_eq!(
r.read_value().err().map(|e| (e.kind(), e.offset())),
Some((ErrorKind::DuplicateKey, 15))
);
let mut r = Parser::new()
.duplicate_keys(DuplicateKeys::Last)
.reader(text);
let _start = r.next_event();
let _key = r.next_event();
assert_eq!(r.read_value().ok().flatten(), Some(json!({ "k": 2 })));
}
#[test]
fn test_duplicate_policies_nested_objects_apply_at_every_depth() {
let text = r#"[{"a": {"b": 1, "b": 2}, "a": 3}]"#;
let first = Parser::new()
.duplicate_keys(DuplicateKeys::First)
.parse(text)
.unwrap_or_default();
assert_eq!(first.to_string(), r#"[{"a":{"b":1}}]"#);
let last = Parser::new()
.duplicate_keys(DuplicateKeys::Last)
.parse(text)
.unwrap_or_default();
assert_eq!(last.to_string(), r#"[{"a":3}]"#);
let all = Parser::new()
.duplicate_keys(DuplicateKeys::KeepAll)
.parse(text)
.unwrap_or_default();
assert_eq!(all.to_string(), r#"[{"a":{"b":1,"b":2},"a":3}]"#);
let err = jsonx_lib::parse(text).err().map(|e| e.offset());
assert_eq!(err, Some(16));
}
#[test]
fn test_value_accessors_wrong_shape_return_none() {
let v =
json!({ "n": -3, "u": 18446744073709551615u64, "f": 0.25, "s": "x", "b": true, "z": null });
assert_eq!(v["n"].as_i64(), Some(-3));
assert_eq!(v["n"].as_u64(), None);
assert_eq!(v["u"].as_u64(), Some(u64::MAX));
assert_eq!(v["u"].as_i64(), None);
assert_eq!(v["f"].as_f64(), Some(0.25));
assert_eq!(v["f"].as_i64(), None);
assert_eq!(v["s"].as_str(), Some("x"));
assert_eq!(v["b"].as_bool(), Some(true));
assert!(v["z"].is_null());
assert!(v["missing"].is_null());
assert_eq!(v.kind(), Kind::Object);
assert_eq!(v["s"].kind().name(), "string");
assert_eq!(v["n"], -3);
assert_eq!(v["n"], -3i8);
assert_eq!(v["u"], u64::MAX);
#[cfg(target_pointer_width = "64")]
assert_eq!(v["u"], usize::MAX as u64);
assert_eq!(v["u"], u64::MAX);
assert_eq!(v["f"], 0.25);
assert_ne!(v["s"], "y");
assert_eq!(v["s"], String::from("x"));
assert_eq!(Value::from(f64::NAN), Value::Null);
assert_eq!(Value::from(Some("a")), "a");
assert_eq!(Value::from(None::<i32>), Value::Null);
assert_eq!(Value::from('c'), "c");
assert_eq!(Value::from(()), Value::Null);
assert_eq!(Value::from(1.5f32).to_string(), "1.5");
let collected: Value = (1..=3).collect();
assert_eq!(collected.to_string(), "[1,2,3]");
let obj: Object = [("a", 1), ("b", 2)].into_iter().collect();
assert_eq!(Value::from(obj).to_string(), r#"{"a":1,"b":2}"#);
}
#[test]
fn test_value_equality_numbers_and_order_compare_exactly() {
assert_ne!(jsonx_lib::parse("1").ok(), jsonx_lib::parse("1.0").ok());
assert_ne!(
jsonx_lib::parse(r#"{"a":1,"b":2}"#).ok(),
jsonx_lib::parse(r#"{"b":2,"a":1}"#).ok()
);
assert_eq!(
jsonx_lib::parse("[1, \"\\u0041\"]").ok(),
jsonx_lib::parse("[1,\"A\"]").ok()
);
assert_eq!(
jsonx_lib::parse("1.0").ok().and_then(|v| v.as_f64()),
Some(1.0)
);
}
#[cfg(feature = "std")]
#[test]
fn test_writers_io_failure_returns_the_error() {
let v = json!({ "list": [1, "two", null], "nested": { "ok": true } });
let mut buf = Vec::new();
assert!(jsonx_lib::to_writer(&mut buf, &v).is_ok());
assert_eq!(buf, jsonx_lib::to_string(&v).as_bytes());
let mut buf = Vec::new();
assert!(jsonx_lib::to_writer_pretty(&mut buf, &v).is_ok());
assert_eq!(buf, jsonx_lib::to_string_pretty(&v).as_bytes());
struct Broken;
impl std::io::Write for Broken {
fn write(&mut self, _: &[u8]) -> std::io::Result<usize> {
Err(std::io::Error::other("disk full"))
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
let err = jsonx_lib::to_writer(Broken, &v).err();
assert_eq!(err.map(|e| e.to_string()), Some("disk full".to_owned()));
let big: Value = (0..100_000).map(|i| json!({ "i": i })).collect();
let mut buf = Vec::new();
assert!(jsonx_lib::to_writer(&mut buf, &big).is_ok());
assert_eq!(buf, jsonx_lib::to_string(&big).as_bytes());
}
#[test]
fn test_error_display_names_kind_and_offset() {
let err = jsonx_lib::parse("[1,]").err();
assert_eq!(
err.map(|e| e.to_string()),
Some("trailing comma before `}` or `]` at byte 3".to_owned())
);
let boxed: Box<dyn std::error::Error> = Box::new(jsonx_lib::parse("").unwrap_err());
assert_eq!(boxed.to_string(), "unexpected end of input at byte 0");
}
#[test]
fn test_value_into_owned_outlives_its_input() {
let owned: Value<'static> = {
let text = String::from("{\"k\": [\"v\\n\", 1e5]}");
jsonx_lib::parse(&text)
.map(Value::into_owned)
.unwrap_or_default()
};
assert_eq!(owned["k"][0], "v\n");
assert_eq!(owned["k"][1].as_f64(), Some(1e5));
}
#[test]
fn test_object_insert_push_remove_keep_member_order() {
let mut v = jsonx_lib::parse(r#"{"c": 1, "a": 2, "b": 3}"#)
.map(Value::into_owned)
.unwrap_or_default();
let obj = v.as_object_mut().unwrap_or_else(|| panic!("object"));
assert_eq!(obj.insert("a", "new"), Some(json!(2)));
obj.push("d", json!([]));
assert_eq!(obj.remove("c"), Some(json!(1)));
assert_eq!(obj.remove("nope"), None);
assert_eq!(v.to_string(), r#"{"a":"new","b":3,"d":[]}"#);
assert_eq!(v.pointer("/d"), Some(&json!([])));
}
#[test]
fn test_reader_loop_with_duplicate_method_is_refused_like_parse() {
let text = r#"{"jsonrpc":"2.0","id":1,"method":"initialize","method":"shutdown","params":{}}"#;
let parsed = jsonx_lib::parse(text).err().map(|e| (e.kind(), e.offset()));
assert_eq!(parsed, Some((ErrorKind::DuplicateKey, 46)));
let run = || -> Result<Option<Value<'_>>, jsonx_lib::Error> {
let mut reader = Reader::new(text);
let mut method = None;
assert_eq!(reader.next_event()?, Some(Event::StartObject));
while let Some(Event::Key(key)) = reader.next_event()? {
match &*key {
"method" => method = reader.read_value()?,
_ => {
let _skipped = reader.read_raw()?;
}
}
}
reader.finish()?;
Ok(method)
};
assert_eq!(run().err().map(|e| (e.kind(), e.offset())), parsed);
let wrapped = format!("[{text}]");
let mut r = Reader::new(&wrapped);
let _start = r.next_event();
assert_eq!(
r.read_raw().err().map(|e| (e.kind(), e.offset())),
Some((ErrorKind::DuplicateKey, 47))
);
let mut s = jsonx_lib::StreamReader::new();
assert!(s.feed(text.as_bytes()).is_ok());
assert_eq!(s.read_raw().err().map(|e| (e.kind(), e.offset())), parsed);
let mut r = Parser::new()
.duplicate_keys(DuplicateKeys::Last)
.reader(text);
assert!(r.read_raw().is_ok_and(|raw| raw == Some(text)));
}
#[test]
fn test_array_and_object_apis_cover_every_conversion() {
use jsonx_lib::{Array, Entry, Object};
let mut a = Array::with_capacity(4);
assert!(a.capacity() >= 4);
a.extend([1, 2]);
a.push(Value::from("x"));
assert_eq!(
a,
Array::from(vec![Value::from(1), Value::from(2), Value::from("x")])
);
assert_ne!(a, Array::new());
assert_eq!(format!("{a:?}"), r#"[1, 2, "x"]"#);
for item in &mut a {
if item.is_number() {
*item = Value::Null;
}
}
assert_eq!((&a).into_iter().filter(|v| v.is_null()).count(), 2);
let owned: Array<'static> = {
let text = String::from(r#"["borrowed"]"#);
jsonx_lib::parse(&text)
.ok()
.and_then(|v| v.as_array().cloned())
.unwrap_or_default()
.into_owned()
};
assert_eq!(owned[0], "borrowed");
assert_eq!(a.clone().into_vec().len(), 3);
assert_eq!(a.into_iter().count(), 3);
let mut o = Object::with_capacity(2);
o.extend([("a", 1), ("b", 2)]);
o.push("c", true);
assert_eq!(o.values().count(), 3);
assert_eq!(o.keys().rev().collect::<Vec<_>>(), ["c", "b", "a"]);
assert_eq!(format!("{o:?}"), r#"{"a": 1, "b": 2, "c": true}"#);
let mut it = o.iter_mut();
assert_eq!(it.len(), 3);
if let Some((key, value)) = it.next_back() {
assert_eq!(key, "c");
*value = Value::Null;
}
assert_eq!(
o.iter().next_back().map(|(k, v)| (k, v.is_null())),
Some(("c", true))
);
for (_, value) in &mut o {
if *value == 2 {
*value = Value::from(20);
}
}
assert_eq!(o["b"], 20);
assert!(o["missing"].is_null());
assert_eq!(o, o.clone());
assert_ne!(o, Object::new());
let pairs: Vec<_> = o.clone().into_iter().map(|(k, _)| k.into_owned()).collect();
assert_eq!(pairs, ["a", "b", "c"]);
assert_eq!(o.clone().into_vec().len(), 3);
let owned: Object<'static> = {
let text = String::from(r#"{"k": "v"}"#);
jsonx_lib::parse(&text)
.ok()
.and_then(|v| v.as_object().cloned())
.unwrap_or_default()
.into_owned()
};
assert_eq!(owned["k"], "v");
o.retain(|key, _| key != "a");
o.push("a", 0);
o.sort_keys();
assert_eq!(o.keys().collect::<Vec<_>>(), ["a", "b", "c"]);
match o.entry("b") {
Entry::Occupied(mut e) => {
assert_eq!((e.key(), e.get().as_i64()), ("b", Some(20)));
assert_eq!(e.insert(21), 20);
assert_eq!(e.remove(), 21);
}
Entry::Vacant(_) => panic!("b is there"),
}
match o.entry("z") {
Entry::Vacant(e) => {
assert_eq!(e.key(), "z");
*e.insert(1) = Value::from(2);
}
Entry::Occupied(_) => panic!("z is not there"),
}
assert_eq!(o["z"], 2);
assert_eq!(o.entry("z").key(), "z");
assert!(o.entry("new").or_insert_with(|| Value::from("v")) == "v");
assert_eq!(
o.entry("new")
.and_modify(|v| *v = Value::from(3))
.or_default(),
&Value::from(3)
);
}
#[test]
fn test_value_comparisons_with_wide_and_platform_integers() {
let big = jsonx_lib::parse("18446744073709551616").unwrap_or_default(); assert_ne!(big, u64::MAX);
assert_eq!(big, u128::from(u64::MAX) + 1);
assert_eq!(Value::from(-5), -5isize);
assert_ne!(Value::from(-5), 5usize);
assert_eq!(Value::from(5), 5usize);
assert_ne!(Value::from("5"), 5usize);
let mut v = json!({ "list": [1] });
assert!(v.pointer_mut("").is_some());
assert!(v.pointer_mut("list").is_none());
assert!(v.pointer_mut("/list/0/x").is_none());
assert!(v.pointer_mut("/list/~2").is_none());
assert_eq!(format!("{:?}", Number::from(7)), "7");
assert_eq!(
format!(
"{}",
Number::from_text("1e5").unwrap_or_else(|| Number::from(0))
),
"1e5"
);
assert_eq!(format!("{:?}", json!({ "a": [null] })), r#"{"a":[null]}"#);
}