use std::io::{BufRead, Read};
use dataprof_core::DataProfilerError;
use serde::Deserialize;
use serde_json::Value;
use crate::JsonObject;
pub enum JsonRecord {
Object(JsonObject),
NonObject(&'static str),
Malformed(serde_json::Error),
WideInteger,
}
pub fn read_json_record<R: BufRead>(
reader: &mut R,
first: u8,
) -> Result<JsonRecord, DataProfilerError> {
if first == b'-' || first.is_ascii_digit() {
let token = read_number_token(reader)?;
return Ok(match serde_json::from_str::<Value>(&token) {
Ok(_) => JsonRecord::NonObject("number"),
Err(err) => JsonRecord::Malformed(err),
});
}
let mut recorded = RecordingReader {
inner: reader,
bytes: Vec::new(),
};
let parsed = {
let mut deserializer = serde_json::Deserializer::from_reader(&mut recorded);
Value::deserialize(&mut deserializer)
};
Ok(match parsed {
Ok(Value::Object(obj)) => object_record(obj, &recorded.bytes),
Ok(value) => JsonRecord::NonObject(json_value_kind(&value)),
Err(err) if err.is_io() => {
let message = format!("JSON record read failed: {err}");
return Err(DataProfilerError::json_parsing_with_source(
message,
std::io::Error::from(err),
));
}
Err(err) => JsonRecord::Malformed(err),
})
}
struct RecordingReader<'a, R> {
inner: &'a mut R,
bytes: Vec<u8>,
}
impl<R: Read> Read for RecordingReader<'_, R> {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
let read = self.inner.read(buffer)?;
self.bytes.extend_from_slice(&buffer[..read]);
Ok(read)
}
}
pub fn may_hold_wide_integer(value: &Value) -> bool {
match value {
Value::Number(number) => {
number.as_i64().is_none()
&& number.as_u64().is_none()
&& number
.as_f64()
.is_some_and(|float| float.abs() >= 2f64.powi(63))
}
Value::Array(items) => items.iter().any(may_hold_wide_integer),
Value::Object(fields) => fields.values().any(may_hold_wide_integer),
_ => false,
}
}
pub fn has_wide_integer_literal(raw: &[u8]) -> bool {
integer_literals(raw).any(|(_, token)| is_wide_integer(token))
}
pub fn is_lossy_float_scalar(raw: &[u8]) -> bool {
number_literals(raw).next().is_some_and(|literal| {
literal.depth == 0
&& is_float_literal(literal.token)
&& is_lossy_float_literal(literal.token)
})
}
fn integer_literals(raw: &[u8]) -> impl Iterator<Item = (usize, &[u8])> {
number_literals(raw)
.filter(|literal| !is_float_literal(literal.token))
.map(|literal| (literal.start, literal.token))
}
struct NumberLiteral<'a> {
start: usize,
depth: usize,
token: &'a [u8],
}
fn number_literals(raw: &[u8]) -> impl Iterator<Item = NumberLiteral<'_>> {
let mut index = 0;
let mut depth = 0usize;
std::iter::from_fn(move || {
while index < raw.len() {
match raw[index] {
b'"' => {
index += 1;
while index < raw.len() && raw[index] != b'"' {
index += if raw[index] == b'\\' { 2 } else { 1 };
}
index += 1;
}
b'{' | b'[' => {
depth += 1;
index += 1;
}
b'}' | b']' => {
depth = depth.saturating_sub(1);
index += 1;
}
byte if byte == b'-' || byte.is_ascii_digit() => {
let start = index;
while index < raw.len() && is_json_number_byte(raw[index]) {
index += 1;
}
return Some(NumberLiteral {
start,
depth,
token: &raw[start..index],
});
}
_ => index += 1,
}
}
None
})
}
fn is_float_literal(token: &[u8]) -> bool {
token.iter().any(|byte| matches!(byte, b'.' | b'e' | b'E'))
}
fn is_lossy_float_literal(token: &[u8]) -> bool {
let Some(literal) = Decimal::parse(token) else {
return false;
};
if literal.digits <= 15 && (-290..=290).contains(&(literal.exponent + literal.digits as i64)) {
return false;
}
let text = std::str::from_utf8(token).expect("JSON number bytes are ASCII");
let Ok(value) = text.parse::<f64>() else {
return false;
};
let mut shortest = ShortBuffer::default();
std::fmt::Write::write_fmt(&mut shortest, format_args!("{value:e}"))
.expect("an f64 in exponent form fits in 32 bytes");
Decimal::parse(shortest.as_bytes()).is_none_or(|held| !literal.same_value(&held))
}
struct Decimal<'a> {
negative: bool,
significant: &'a [u8],
digits: usize,
exponent: i64,
}
impl<'a> Decimal<'a> {
fn parse(text: &'a [u8]) -> Option<Self> {
let (negative, unsigned) = match text.split_first() {
Some((b'-', rest)) => (true, rest),
_ => (false, text),
};
let (mantissa, exponent) = match unsigned.iter().position(|b| matches!(b, b'e' | b'E')) {
Some(at) => {
let exponent = &unsigned[at + 1..];
let parsed = std::str::from_utf8(exponent)
.expect("JSON number bytes are ASCII")
.parse::<i64>()
.unwrap_or(if exponent.first() == Some(&b'-') {
i64::MIN / 2
} else {
i64::MAX / 2
});
(&unsigned[..at], parsed)
}
None => (unsigned, 0),
};
let point = mantissa
.iter()
.position(|&b| b == b'.')
.unwrap_or(mantissa.len());
let first = mantissa.iter().position(|b| matches!(b, b'1'..=b'9'))?;
let last = mantissa
.iter()
.rposition(|b| matches!(b, b'1'..=b'9'))
.expect("a nonzero digit was found");
let last_power = if last < point {
(point - last - 1) as i64
} else {
-((last - point) as i64)
};
let digits = last - first + 1 - usize::from(first < point && point < last);
Some(Self {
negative,
significant: &mantissa[first..=last],
digits,
exponent: exponent.saturating_add(last_power),
})
}
fn same_value(&self, other: &Decimal<'_>) -> bool {
self.negative == other.negative
&& self.exponent == other.exponent
&& self.digits == other.digits
&& self
.significant
.iter()
.filter(|&&b| b != b'.')
.eq(other.significant.iter().filter(|&&b| b != b'.'))
}
}
#[derive(Default)]
struct ShortBuffer {
bytes: [u8; 32],
len: usize,
}
impl ShortBuffer {
fn as_bytes(&self) -> &[u8] {
&self.bytes[..self.len]
}
}
impl std::fmt::Write for ShortBuffer {
fn write_str(&mut self, text: &str) -> std::fmt::Result {
let end = self.len + text.len();
self.bytes
.get_mut(self.len..end)
.ok_or(std::fmt::Error)?
.copy_from_slice(text.as_bytes());
self.len = end;
Ok(())
}
}
fn is_wide_integer(token: &[u8]) -> bool {
let digits = token.len() - usize::from(token.first() == Some(&b'-'));
if digits < 19 {
return false;
}
let text = std::str::from_utf8(token).expect("JSON number bytes are ASCII");
text.parse::<i64>().is_err() && text.parse::<u64>().is_err()
}
pub fn object_record(obj: JsonObject, raw: &[u8]) -> JsonRecord {
let mut negative_zeros = Vec::new();
let mut lossy_fields = Vec::new();
for literal in number_literals(raw) {
if is_float_literal(literal.token) {
if literal.depth == 1 && is_lossy_float_literal(literal.token) {
lossy_fields.push((literal.start, literal.token.len()));
}
} else if is_wide_integer(literal.token) {
return JsonRecord::WideInteger;
} else if literal.token == b"-0" {
negative_zeros.push(literal.start);
}
}
if negative_zeros.is_empty() && lossy_fields.is_empty() {
return JsonRecord::Object(obj);
}
let mut unsigned = raw.to_vec();
for start in negative_zeros {
unsigned[start] = b' ';
}
let mut rewritten = Vec::with_capacity(unsigned.len() + 2 * lossy_fields.len());
let mut copied = 0;
for (start, len) in lossy_fields {
rewritten.extend_from_slice(&unsigned[copied..start]);
rewritten.push(b'"');
rewritten.extend_from_slice(&unsigned[start..start + len]);
rewritten.push(b'"');
copied = start + len;
}
rewritten.extend_from_slice(&unsigned[copied..]);
JsonRecord::Object(
serde_json::from_slice::<JsonObject>(&rewritten)
.expect("an object with its `-0` signs blanked and literals quoted is still an object"),
)
}
pub fn wide_integer_record_error(location: &str) -> DataProfilerError {
DataProfilerError::json_parsing_error(&format!(
"JSON record {location} holds an integer outside the 64-bit range, which would be rounded to a float and could merge distinct values; write such integers as strings to profile them"
))
}
const JSONL_BOUNDARY_RULE: &str = "a JSONL record must be one complete JSON value on one line";
pub fn malformed_jsonl_record_error(
line_number: usize,
line: &str,
err: serde_json::Error,
) -> DataProfilerError {
let message = malformed_jsonl_record_message(line_number, line, &err);
DataProfilerError::json_parsing_with_source(message, err)
}
pub fn jsonl_line_error_message(line_number: usize, line: &str) -> Option<String> {
match read_jsonl_line(line) {
JsonRecord::Malformed(err) => Some(malformed_jsonl_record_message(line_number, line, &err)),
_ => None,
}
}
fn malformed_jsonl_record_message(
line_number: usize,
line: &str,
err: &serde_json::Error,
) -> String {
let record = line.trim();
let leading = line[..line.len() - line.trim_start().len()].chars().count();
let rendered = err.to_string();
let position = format!(" at line {} column {}", err.line(), err.column());
let reason = rendered.strip_suffix(&position).unwrap_or(&rendered);
let ends_early = err.classify() == serde_json::error::Category::Eof;
let column = if ends_early {
leading + record.chars().count() + 1
} else {
leading
+ record
.char_indices()
.take_while(|(start, _)| *start < err.column())
.count()
};
if ends_early || reason == "trailing characters" {
format!(
"malformed JSON record on line {line_number}, column {column}: {reason}; {JSONL_BOUNDARY_RULE}"
)
} else {
format!("malformed JSON record on line {line_number}, column {column}: {reason}")
}
}
fn read_number_token<R: BufRead>(reader: &mut R) -> Result<String, DataProfilerError> {
skip_ascii_whitespace(reader)?;
let mut token = String::new();
loop {
let (consume, token_ended) = {
let buf = reader.fill_buf().map_err(DataProfilerError::from)?;
if buf.is_empty() {
break;
}
let consume = buf
.iter()
.take_while(|byte| is_json_number_byte(**byte))
.count();
token.push_str(
std::str::from_utf8(&buf[..consume]).expect("JSON number bytes are ASCII"),
);
(consume, consume < buf.len())
};
reader.consume(consume);
if token_ended {
break;
}
}
Ok(token)
}
fn is_json_number_byte(byte: u8) -> bool {
byte.is_ascii_digit() || matches!(byte, b'-' | b'+' | b'.' | b'e' | b'E')
}
pub(crate) fn skip_ascii_whitespace<R: BufRead>(reader: &mut R) -> Result<(), DataProfilerError> {
loop {
let (consume, done) = {
let buf = reader.fill_buf().map_err(DataProfilerError::from)?;
if buf.is_empty() {
return Ok(());
}
let consume = buf
.iter()
.take_while(|byte| byte.is_ascii_whitespace())
.count();
(consume, consume < buf.len())
};
reader.consume(consume);
if done {
return Ok(());
}
}
}
pub fn json_value_text(value: &Value) -> String {
match value {
Value::Null => String::new(),
Value::Bool(boolean) => boolean.to_string(),
Value::Number(number) => number.to_string(),
Value::String(string) => string.to_string(),
Value::Array(_) | Value::Object(_) => {
let mut text = String::new();
write_canonical_json(value, &mut text);
text
}
}
}
fn write_canonical_json(value: &Value, out: &mut String) {
match value {
Value::Array(items) => {
out.push('[');
for (index, item) in items.iter().enumerate() {
if index > 0 {
out.push(',');
}
write_canonical_json(item, out);
}
out.push(']');
}
Value::Object(fields) => {
let mut entries: Vec<_> = fields.iter().collect();
entries.sort_unstable_by_key(|(key, _)| *key);
out.push('{');
for (index, (key, field)) in entries.into_iter().enumerate() {
if index > 0 {
out.push(',');
}
out.push_str(&scalar_json(key));
out.push(':');
write_canonical_json(field, out);
}
out.push('}');
}
scalar => out.push_str(&scalar_json(scalar)),
}
}
fn scalar_json<T: serde::Serialize + ?Sized>(value: &T) -> String {
serde_json::to_string(value).expect("re-serializing a parsed JSON value cannot fail")
}
pub fn json_value_kind(value: &Value) -> &'static str {
match value {
Value::Null => "null",
Value::Bool(_) => "boolean",
Value::Number(_) => "number",
Value::String(_) => "string",
Value::Array(_) => "array",
Value::Object(_) => "object",
}
}
pub fn non_object_record_error(kind: &str, position: usize) -> DataProfilerError {
DataProfilerError::json_parsing_error(&format!(
"non-object JSON record at position {position}: \
expected an object with fields to profile, found {kind}"
))
}
pub fn malformed_array_error(message: &str) -> DataProfilerError {
DataProfilerError::json_parsing_error(&format!("malformed JSON array: {message}"))
}
pub fn json_document_error(err: serde_json::Error) -> DataProfilerError {
let message = format!(
"malformed JSON document: {err}. A JSON source must hold exactly one array or object; for one record per line use format=\"jsonl\""
);
DataProfilerError::json_parsing_with_source(message, err)
}
pub fn drain_to_end<R: BufRead>(reader: &mut R) -> Result<usize, DataProfilerError> {
let mut consumed = 0;
loop {
let available = reader.fill_buf().map_err(DataProfilerError::from)?.len();
if available == 0 {
return Ok(consumed);
}
reader.consume(available);
consumed += available;
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LeadingWhiteSpace {
pub skipped: usize,
pub pending: Vec<u8>,
pub first: Option<u8>,
}
enum WhiteSpaceRun {
All,
Other(usize),
Partial(usize),
}
fn utf8_width(lead: u8) -> usize {
match lead {
0x00..=0x7F => 1,
0xC2..=0xDF => 2,
0xE0..=0xEF => 3,
0xF0..=0xF4 => 4,
_ => 0,
}
}
fn is_white_space_char(bytes: &[u8]) -> bool {
match std::str::from_utf8(bytes) {
Ok(text) => text.chars().next().is_some_and(char::is_whitespace),
Err(_) => false,
}
}
fn white_space_run(bytes: &[u8]) -> WhiteSpaceRun {
let mut index = 0;
while index < bytes.len() {
let width = utf8_width(bytes[index]);
if width == 0 {
return WhiteSpaceRun::Other(index);
}
if index + width > bytes.len() {
return WhiteSpaceRun::Partial(index);
}
if !is_white_space_char(&bytes[index..index + width]) {
return WhiteSpaceRun::Other(index);
}
index += width;
}
WhiteSpaceRun::All
}
fn finish_pending<R: BufRead>(
reader: &mut R,
pending: &mut Vec<u8>,
) -> Result<Option<bool>, DataProfilerError> {
let width = utf8_width(pending[0]);
let buf = reader.fill_buf().map_err(DataProfilerError::from)?;
let take = (width - pending.len()).min(buf.len());
let mut character = pending.clone();
character.extend_from_slice(&buf[..take]);
if character.len() < width {
reader.consume(take);
*pending = character;
return Ok(None);
}
if is_white_space_char(&character) {
reader.consume(take);
pending.clear();
return Ok(Some(true));
}
Ok(Some(false))
}
pub fn skip_leading_white_space<R: BufRead>(
reader: &mut R,
) -> Result<LeadingWhiteSpace, DataProfilerError> {
let mut pending = Vec::new();
let mut skipped = 0;
loop {
if !pending.is_empty() {
let width = utf8_width(pending[0]);
let at_end = reader
.fill_buf()
.map_err(DataProfilerError::from)?
.is_empty();
if at_end {
let first = pending.first().copied();
return Ok(LeadingWhiteSpace {
skipped,
pending,
first,
});
}
match finish_pending(reader, &mut pending)? {
None => continue,
Some(true) => {
skipped += width;
continue;
}
Some(false) => {
let first = pending.first().copied();
return Ok(LeadingWhiteSpace {
skipped,
pending,
first,
});
}
}
}
let buf = reader.fill_buf().map_err(DataProfilerError::from)?;
if buf.is_empty() {
return Ok(LeadingWhiteSpace {
skipped,
pending,
first: None,
});
}
match white_space_run(buf) {
WhiteSpaceRun::Other(len) => {
let first = Some(buf[len]);
reader.consume(len);
skipped += len;
return Ok(LeadingWhiteSpace {
skipped,
pending,
first,
});
}
WhiteSpaceRun::Partial(len) => {
pending = buf[len..].to_vec();
let read = buf.len();
reader.consume(read);
skipped += len;
}
WhiteSpaceRun::All => {
let read = buf.len();
reader.consume(read);
skipped += read;
}
}
}
}
pub fn rest_is_white_space<R: BufRead>(reader: &mut R) -> Result<(bool, usize), DataProfilerError> {
let leading = skip_leading_white_space(reader)?;
let consumed = leading.skipped + leading.pending.len();
Ok((leading.first.is_none(), consumed))
}
pub fn read_jsonl_line(line: &str) -> JsonRecord {
match serde_json::from_str::<Value>(line.trim()) {
Ok(Value::Object(obj)) => object_record(obj, line.as_bytes()),
Ok(value) => JsonRecord::NonObject(json_value_kind(&value)),
Err(_) if has_wide_integer_literal(line.as_bytes()) => JsonRecord::WideInteger,
Err(err) => JsonRecord::Malformed(err),
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::error::Error as _;
use std::io::{self, BufReader, Cursor, Read};
#[test]
fn white_space_helpers_decode_characters_split_across_buffers() {
let leading: [(&str, &str, usize, Option<u8>); 7] = [
("none", "[1]", 0, Some(b'[')),
("ascii", " \n[1]", 2, Some(b'[')),
("nbsp and ideographic", "\u{A0}\u{3000}[1]", 5, Some(b'[')),
("all white space", "\u{2028}\u{85}", 5, None),
("not white space", "\u{1C}[1]", 0, Some(0x1C)),
("a two-byte non-space", "\u{E9}[1]", 0, Some(0xC3)),
("a three-byte non-space", "\u{A0}\u{20AC}[1]", 2, Some(0xE2)),
];
let mut wrong = Vec::new();
for capacity in [1, 2, 64] {
for (case, input, skipped, first) in leading {
let mut reader = BufReader::with_capacity(capacity, input.as_bytes());
let read = skip_leading_white_space(&mut reader).unwrap();
let mut rest = Vec::new();
reader.read_to_end(&mut rest).unwrap();
let mut all = input.as_bytes()[..read.skipped].to_vec();
all.extend(&read.pending);
all.extend(rest);
if (read.skipped, read.first, all.as_slice()) != (skipped, first, input.as_bytes())
|| read.pending.len() > 3
{
wrong.push(format!("leading, capacity {capacity}, {case}: {read:?}"));
}
}
}
let rest: [(&str, &str, bool); 5] = [
("empty", "", true),
("ascii", " \r\n", true),
("unicode", "\u{A0}\u{3000}\u{2029}", true),
("content after", "\u{A0}x", false),
("a truncated character", "\u{A0}\u{E2}", false),
];
for (case, input, white) in rest {
let bytes: Vec<u8> = if case == "a truncated character" {
vec![0xC2, 0xA0, 0xE2, 0x80]
} else {
input.as_bytes().to_vec()
};
let mut reader = BufReader::with_capacity(1, bytes.as_slice());
let (seen, _) = rest_is_white_space(&mut reader).unwrap();
if seen != white {
wrong.push(format!("rest, {case}: {seen}"));
}
}
assert!(wrong.is_empty(), "{}", wrong.join("\n"));
}
#[derive(Debug)]
struct LocalReadFailure;
impl std::fmt::Display for LocalReadFailure {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("local read failure")
}
}
impl std::error::Error for LocalReadFailure {}
impl Read for LocalReadFailure {
fn read(&mut self, _buffer: &mut [u8]) -> io::Result<usize> {
Err(io::Error::new(io::ErrorKind::PermissionDenied, Self))
}
}
#[test]
fn integer_negative_zero_reads_as_zero_and_float_negative_zero_keeps_its_sign() {
let text = r#"{"v":-0,"w":[-0,{"k":-0}],"s":"-0","-0":1,"f":-0.0,"e":-0e0}"#;
let from_line = match read_jsonl_line(text) {
JsonRecord::Object(obj) => obj,
_ => panic!("a JSONL object"),
};
let mut reader = Cursor::new(text.as_bytes());
let from_array = match read_json_record(&mut reader, b'{').unwrap() {
JsonRecord::Object(obj) => obj,
_ => panic!("an array element object"),
};
for obj in [from_line, from_array] {
assert_eq!(json_value_text(&obj["v"]), "0");
assert_eq!(json_value_text(&obj["w"]), r#"[0,{"k":0}]"#);
assert_eq!(json_value_text(&obj["s"]), "-0");
assert!(obj.contains_key("-0"));
assert_eq!(json_value_text(&obj["f"]), "-0.0");
assert_eq!(json_value_text(&obj["e"]), "-0.0");
}
}
#[test]
fn json_record_read_failure_keeps_the_original_io_source() {
let mut reader = BufReader::new(Cursor::new(b"{\"x\":\"").chain(LocalReadFailure));
let error = read_json_record(&mut reader, b'{')
.err()
.expect("a read failure must abort before a caller can skip a malformed record");
assert!(
error
.to_string()
.contains("JSON record read failed: local read failure")
);
let source = error
.source()
.and_then(|source| source.downcast_ref::<io::Error>())
.expect("the original I/O error must survive serde's wrapper");
assert_eq!(source.kind(), io::ErrorKind::PermissionDenied);
assert!(source.get_ref().unwrap().is::<LocalReadFailure>());
}
#[test]
fn only_a_lossy_float_scalar_is_reported() {
for raw in [" 1000000000000000.01 ", "1e-400", "-12345678901234567890.0"] {
assert!(is_lossy_float_scalar(raw.as_bytes()), "{raw}");
}
for raw in [
r#"{"v":1000000000000000.01}"#,
r#"[1e-400]"#,
r#""1000000000000000.01""#,
"1.50",
"18446744073709551615",
] {
assert!(!is_lossy_float_scalar(raw.as_bytes()), "{raw}");
}
}
#[test]
fn a_float_literal_is_lossy_only_when_its_value_changes() {
let held = [
"0.1", "1.50", "1e2", "1E+2", "-0.0", "0e999", "2.5e-3", "1e308",
];
let lossy = [
"1000000000000000.01",
"1e-400",
"0.30000000000000000001",
"12345678901234567890.0",
"1e-99999999999999999999",
"9007199254740993.0",
"-1.00000000000000001",
];
for token in held {
assert!(!is_lossy_float_literal(token.as_bytes()), "{token}");
}
for token in lossy {
assert!(is_lossy_float_literal(token.as_bytes()), "{token}");
}
}
#[test]
fn fifteen_digit_literals_in_the_normal_range_are_held() {
let mut state = 0x9e37_79b9_7f4a_7c15u64;
for exponent in (-305..=275).step_by(5) {
for _ in 0..200 {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
let mantissa = 100_000_000_000_000 + state % 900_000_000_000_000;
let token = format!("{mantissa}e{exponent}");
let literal = Decimal::parse(token.as_bytes()).unwrap();
let value: f64 = token.parse().unwrap();
let mut shortest = ShortBuffer::default();
std::fmt::Write::write_fmt(&mut shortest, format_args!("{value:e}")).unwrap();
let held = Decimal::parse(shortest.as_bytes()).unwrap();
assert!(literal.same_value(&held), "{token}");
}
}
}
#[test]
fn only_a_lossy_field_of_the_root_object_becomes_text() {
let raw =
br#"{"a":1000000000000000.01,"b":[1000000000000000.01],"c":-0,"d":1.5,"e":1e-400}"#;
let obj = serde_json::from_slice(raw).unwrap();
let JsonRecord::Object(obj) = object_record(obj, raw) else {
panic!("not an object record");
};
assert_eq!(obj["a"], Value::String("1000000000000000.01".into()));
assert_eq!(json_value_text(&obj["b"]), "[1000000000000000.0]");
assert_eq!(json_value_text(&obj["c"]), "0");
assert_eq!(json_value_text(&obj["d"]), "1.5");
assert_eq!(obj["e"], Value::String("1e-400".into()));
}
}