Lines
100 %
Functions
Branches
use alloc::{format, vec};
use serde_derive::Serialize;
use crate::Number;
#[derive(Serialize)]
struct EmptyStruct1;
struct EmptyStruct2 {}
struct NewType(i32);
struct TupleStruct(f32, f32);
struct MyStruct {
x: f32,
y: f32,
}
enum MyEnum {
A,
B(bool),
C(bool, f32),
D { a: i32, b: i32 },
#[test]
fn test_empty_struct() {
check_to_string_writer(&EmptyStruct1, "()", "EmptyStruct1");
check_to_string_writer(&EmptyStruct2 {}, "()", "EmptyStruct2()");
fn test_struct() {
let my_struct = MyStruct { x: 4.0, y: 7.0 };
check_to_string_writer(&my_struct, "(x:4.0,y:7.0)", "MyStruct(x: 4.0, y: 7.0)");
check_to_string_writer(&NewType(42), "(42)", "NewType(42)");
check_to_string_writer(&TupleStruct(2.0, 5.0), "(2.0,5.0)", "TupleStruct(2.0, 5.0)");
fn test_option() {
check_to_string_writer(&Some(1u8), "Some(1)", "Some(1)");
check_to_string_writer(&None::<u8>, "None", "None");
fn test_enum() {
check_to_string_writer(&MyEnum::A, "A", "A");
check_to_string_writer(&MyEnum::B(true), "B(true)", "B(true)");
check_to_string_writer(&MyEnum::C(true, 3.5), "C(true,3.5)", "C(true, 3.5)");
check_to_string_writer(&MyEnum::D { a: 2, b: 3 }, "D(a:2,b:3)", "D(a: 2, b: 3)");
fn test_array() {
let empty: [i32; 0] = [];
check_to_string_writer(&empty, "()", "()");
let empty_ref: &[i32] = ∅
check_to_string_writer(&empty_ref, "[]", "[]");
check_to_string_writer(&[2, 3, 4i32], "(2,3,4)", "(2, 3, 4)");
check_to_string_writer(
&(&[2, 3, 4i32] as &[i32]),
"[2,3,4]",
"[\n 2,\n 3,\n 4,\n]",
);
fn test_slice() {
&[0, 1, 2, 3, 4, 5][..],
"[0,1,2,3,4,5]",
"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n]",
&[0, 1, 2, 3, 4, 5][1..4],
"[1,2,3]",
"[\n 1,\n 2,\n 3,\n]",
fn test_vec() {
&vec![0, 1, 2, 3, 4, 5],
fn test_map() {
use alloc::collections::BTreeMap;
let mut map = BTreeMap::new();
map.insert((true, false), 4);
map.insert((false, false), 123);
&map,
"{(false,false):123,(true,false):4}",
"{\n (false, false): 123,\n (true, false): 4,\n}",
fn test_string() {
check_to_string_writer(&"Some string", "\"Some string\"", "\"Some string\"");
fn test_char() {
check_to_string_writer(&'c', "'c'", "'c'");
fn test_escape() {
check_to_string_writer(&r#""Quoted""#, r#""\"Quoted\"""#, r#""\"Quoted\"""#);
fn test_byte_stream() {
use serde_bytes;
let small: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
&small,
"(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)",
"(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)",
let large = vec![0x01, 0x02, 0x03, 0x04];
let large = serde_bytes::Bytes::new(&large);
&large,
"b\"\\x01\\x02\\x03\\x04\"",
let large = vec![0x01, 0x02, 0x03, 0x04, 0x05, 0x06];
"b\"\\x01\\x02\\x03\\x04\\x05\\x06\"",
let large = vec![255u8; 64];
concat!(
"b\"\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff",
"\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff",
"\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\""
),
fn rename() {
#[derive(Serialize, Debug, PartialEq)]
enum Foo {
#[serde(rename = "2d")]
D2,
#[serde(rename = "triangle-list")]
TriangleList,
check_to_string_writer(&Foo::D2, "r#2d", "r#2d");
check_to_string_writer(&Foo::TriangleList, "r#triangle-list", "r#triangle-list");
fn test_any_number_precision() {
check_ser_any_number(1_u8);
check_ser_any_number(-1_i8);
check_ser_any_number(1_f32);
check_ser_any_number(-1_f32);
check_ser_any_number(0.3_f64);
check_to_string_writer(&Number::new(f32::NAN), "NaN", "NaN");
check_to_string_writer(&f32::NAN, "NaN", "NaN");
check_to_string_writer(&Number::new(-f32::NAN), "-NaN", "-NaN");
check_to_string_writer(&(-f32::NAN), "-NaN", "-NaN");
check_to_string_writer(&Number::new(f32::INFINITY), "inf", "inf");
check_to_string_writer(&f32::INFINITY, "inf", "inf");
check_to_string_writer(&Number::new(f32::NEG_INFINITY), "-inf", "-inf");
check_to_string_writer(&f32::NEG_INFINITY, "-inf", "-inf");
macro_rules! test_min_max {
($ty:ty) => {
check_ser_any_number(<$ty>::MIN);
check_ser_any_number(<$ty>::MAX);
};
($($ty:ty),*) => {
$(test_min_max! { $ty })*
test_min_max! { i8, i16, i32, i64, u8, u16, u32, u64, f32, f64 }
#[cfg(feature = "integer128")]
test_min_max! { i128, u128 }
fn check_ser_any_number<T: Copy + Into<Number> + core::fmt::Display + serde::Serialize>(n: T) {
let mut fmt = format!("{}", n);
if !fmt.contains('.') && core::any::type_name::<T>().contains('f') {
fmt.push_str(".0");
check_to_string_writer(&n.into(), &fmt, &fmt);
check_to_string_writer(&n, &fmt, &fmt);
fn recursion_limit() {
assert_eq!(
crate::Options::default()
.with_recursion_limit(0)
.to_string(&[42]),
Err(crate::Error::ExceededRecursionLimit),
.with_recursion_limit(1)
.to_string(&[42])
.as_deref(),
Ok("(42)"),
.without_recursion_limit()
.to_string(&[[42]]),
.with_recursion_limit(2)
.to_string(&[[42]])
Ok("((42))"),
fn check_to_string_writer<T: ?Sized + serde::Serialize>(val: &T, check: &str, check_pretty: &str) {
let ron_str = super::to_string(val).unwrap();
assert_eq!(ron_str, check);
let ron_str_pretty = super::to_string_pretty(
val,
super::PrettyConfig::default()
.struct_names(true)
.compact_structs(true),
)
.unwrap();
assert_eq!(ron_str_pretty, check_pretty);
#[cfg(feature = "std")]
{
let mut ron_writer = std::ffi::OsString::new();
super::to_writer(&mut ron_writer, val).unwrap();
assert_eq!(ron_writer, check);
let mut ron_writer_pretty = std::ffi::OsString::new();
super::to_writer_pretty(
&mut ron_writer_pretty,
assert_eq!(ron_writer_pretty, check_pretty);