161 lines
4.5 KiB
Rust
161 lines
4.5 KiB
Rust
use std::io;
|
|
|
|
pub mod reader;
|
|
pub mod writer;
|
|
|
|
pub use reader::TextReader;
|
|
pub use writer::TextWriter;
|
|
|
|
use crate::BinarySource;
|
|
use crate::BytesBinarySource;
|
|
use crate::Domain;
|
|
use crate::DomainDecode;
|
|
use crate::IOValue;
|
|
use crate::Reader;
|
|
use crate::Value;
|
|
|
|
pub fn from_str<'de, D: Domain, Dec: DomainDecode<D>>(
|
|
s: &'de str,
|
|
decode_embedded: &mut Dec,
|
|
) -> io::Result<Value<D>> {
|
|
BytesBinarySource::new(s.as_bytes()).text().next(false, decode_embedded)
|
|
}
|
|
|
|
pub fn iovalue_from_str(s: &str) -> io::Result<IOValue> {
|
|
BytesBinarySource::new(s.as_bytes()).text().next_iovalue(false)
|
|
}
|
|
|
|
pub fn annotated_from_str<'de, D: Domain, Dec: DomainDecode<D>>(
|
|
s: &'de str,
|
|
decode_embedded: &mut Dec,
|
|
) -> io::Result<Value<D>> {
|
|
BytesBinarySource::new(s.as_bytes()).text().next(true, decode_embedded)
|
|
}
|
|
|
|
pub fn annotated_iovalue_from_str(s: &str) -> io::Result<IOValue> {
|
|
BytesBinarySource::new(s.as_bytes()).text().next_iovalue(true)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod formatting_tests {
|
|
use crate::IOValue;
|
|
use crate::Value;
|
|
use crate::test_domain::Dom;
|
|
|
|
#[test] fn format_debug_and_parse() {
|
|
let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<Value<Dom>>().unwrap();
|
|
assert_eq!(format!("{:?}", &v), "[1, {a: #!\"One\", z: 2}, 3]");
|
|
}
|
|
|
|
#[test] fn format_pretty_debug_and_parse() {
|
|
let v = "[1, {z: 2, a: #!\"One\"}, 3]".parse::<Value<Dom>>().unwrap();
|
|
assert_eq!(format!("{:#?}", &v), concat!(
|
|
"[\n",
|
|
" 1,\n",
|
|
" {\n",
|
|
" a: #!\"One\",\n",
|
|
" z: 2\n",
|
|
" },\n",
|
|
" 3\n",
|
|
"]"));
|
|
}
|
|
|
|
#[test] fn iovalue_parse() {
|
|
let v = "[1 @{a:b c:d} @\"foo\" #![2 3] 4]".parse::<IOValue>().unwrap();
|
|
assert_eq!(format!("{:#?}", &v), concat!(
|
|
"[\n",
|
|
" 1,\n",
|
|
" @{\n",
|
|
" a: b,\n",
|
|
" c: d\n",
|
|
" } @\"foo\" #![\n",
|
|
" 2,\n",
|
|
" 3\n",
|
|
" ],\n",
|
|
" 4\n",
|
|
"]"));
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod unusual_float_tests {
|
|
use std::io;
|
|
use crate::*;
|
|
|
|
fn d32(u: u32, expected: &str) {
|
|
let v = f32::from_bits(u);
|
|
let w = value(v).into();
|
|
assert_eq!(format!("{:?}", w), expected);
|
|
let x = expected.parse::<IOValue>().unwrap();
|
|
assert_eq!(x, w);
|
|
}
|
|
|
|
fn d64(u: u64, expected: &str) {
|
|
let v = f64::from_bits(u);
|
|
let w = value(v).into();
|
|
assert_eq!(format!("{:?}", w), expected);
|
|
let x = expected.parse::<IOValue>().unwrap();
|
|
assert_eq!(x, w);
|
|
}
|
|
|
|
#[test] fn subnormal32() -> io::Result<()> {
|
|
d32(0x00000100, "3.59e-43f");
|
|
d32(0x80000100, "-3.59e-43f");
|
|
Ok(())
|
|
}
|
|
|
|
#[test] fn normal32() -> io::Result<()> {
|
|
d32(0x01000000, "2.3509887e-38f");
|
|
d32(0x81000000, "-2.3509887e-38f");
|
|
Ok(())
|
|
}
|
|
|
|
#[test] fn nan32() -> io::Result<()> {
|
|
d32(0x7fc00000, "#xf\"7fc00000\"");
|
|
d32(0x7fc5a5a5, "#xf\"7fc5a5a5\"");
|
|
d32(0x7f800001, "#xf\"7f800001\"");
|
|
d32(0x7f85a5a5, "#xf\"7f85a5a5\"");
|
|
d32(0xffc00000, "#xf\"ffc00000\"");
|
|
d32(0xffc5a5a5, "#xf\"ffc5a5a5\"");
|
|
d32(0xff800001, "#xf\"ff800001\"");
|
|
d32(0xff85a5a5, "#xf\"ff85a5a5\"");
|
|
Ok(())
|
|
}
|
|
|
|
#[test] fn inf32() -> io::Result<()> {
|
|
d32(0x7f800000, "#xf\"7f800000\"");
|
|
d32(0xff800000, "#xf\"ff800000\"");
|
|
Ok(())
|
|
}
|
|
|
|
#[test] fn subnormal64() -> io::Result<()> {
|
|
d64(0x0000000000000100, "1.265e-321");
|
|
d64(0x8000000000000100, "-1.265e-321");
|
|
Ok(())
|
|
}
|
|
|
|
#[test] fn normal64() -> io::Result<()> {
|
|
d64(0x0100000000000000, "7.291122019556398e-304");
|
|
d64(0x8100000000000000, "-7.291122019556398e-304");
|
|
Ok(())
|
|
}
|
|
|
|
#[test] fn nan64() -> io::Result<()> {
|
|
d64(0x7ff8000000000000, "#xd\"7ff8000000000000\"");
|
|
d64(0x7ff85a5a5a5a5a5a, "#xd\"7ff85a5a5a5a5a5a\"");
|
|
d64(0x7ff0000000000001, "#xd\"7ff0000000000001\"");
|
|
d64(0x7ff05a5a5a5a5a5a, "#xd\"7ff05a5a5a5a5a5a\"");
|
|
d64(0xfff8000000000000, "#xd\"fff8000000000000\"");
|
|
d64(0xfff85a5a5a5a5a5a, "#xd\"fff85a5a5a5a5a5a\"");
|
|
d64(0xfff0000000000001, "#xd\"fff0000000000001\"");
|
|
d64(0xfff05a5a5a5a5a5a, "#xd\"fff05a5a5a5a5a5a\"");
|
|
Ok(())
|
|
}
|
|
|
|
#[test] fn inf64() -> io::Result<()> {
|
|
d64(0x7ff0000000000000, "#xd\"7ff0000000000000\"");
|
|
d64(0xfff0000000000000, "#xd\"fff0000000000000\"");
|
|
Ok(())
|
|
}
|
|
}
|