You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
255 lines
7.6 KiB
255 lines
7.6 KiB
use serde::Serialize;
|
|
use serde_cbor::ser::{Serializer, SliceWrite};
|
|
|
|
#[test]
|
|
fn test_str() {
|
|
serialize_and_compare("foobar", b"ffoobar");
|
|
}
|
|
|
|
#[test]
|
|
fn test_list() {
|
|
serialize_and_compare(&[1, 2, 3], b"\x83\x01\x02\x03");
|
|
}
|
|
|
|
#[test]
|
|
fn test_float() {
|
|
serialize_and_compare(12.3f64, b"\xfb@(\x99\x99\x99\x99\x99\x9a");
|
|
}
|
|
|
|
#[test]
|
|
fn test_integer() {
|
|
// u8
|
|
serialize_and_compare(24, b"\x18\x18");
|
|
// i8
|
|
serialize_and_compare(-5, b"\x24");
|
|
// i16
|
|
serialize_and_compare(-300, b"\x39\x01\x2b");
|
|
// i32
|
|
serialize_and_compare(-23567997, b"\x3a\x01\x67\x9e\x7c");
|
|
// u64
|
|
serialize_and_compare(::core::u64::MAX, b"\x1b\xff\xff\xff\xff\xff\xff\xff\xff");
|
|
}
|
|
|
|
fn serialize_and_compare<T: Serialize>(value: T, expected: &[u8]) {
|
|
let mut slice = [0u8; 64];
|
|
let writer = SliceWrite::new(&mut slice);
|
|
let mut serializer = Serializer::new(writer);
|
|
value.serialize(&mut serializer).unwrap();
|
|
let writer = serializer.into_inner();
|
|
let end = writer.bytes_written();
|
|
let slice = writer.into_inner();
|
|
assert_eq!(&slice[..end], expected);
|
|
}
|
|
|
|
#[cfg(feature = "std")]
|
|
mod std_tests {
|
|
use serde::Serializer;
|
|
use serde_cbor::ser;
|
|
use serde_cbor::{from_slice, to_vec};
|
|
use std::collections::BTreeMap;
|
|
|
|
#[test]
|
|
fn test_string() {
|
|
let value = "foobar".to_owned();
|
|
assert_eq!(&to_vec(&value).unwrap()[..], b"ffoobar");
|
|
}
|
|
|
|
#[test]
|
|
fn test_list() {
|
|
let value = vec![1, 2, 3];
|
|
assert_eq!(&to_vec(&value).unwrap()[..], b"\x83\x01\x02\x03");
|
|
}
|
|
|
|
#[test]
|
|
fn test_object() {
|
|
let mut object = BTreeMap::new();
|
|
object.insert("a".to_owned(), "A".to_owned());
|
|
object.insert("b".to_owned(), "B".to_owned());
|
|
object.insert("c".to_owned(), "C".to_owned());
|
|
object.insert("d".to_owned(), "D".to_owned());
|
|
object.insert("e".to_owned(), "E".to_owned());
|
|
let vec = to_vec(&object).unwrap();
|
|
let test_object = from_slice(&vec[..]).unwrap();
|
|
assert_eq!(object, test_object);
|
|
}
|
|
|
|
#[test]
|
|
fn test_object_list_keys() {
|
|
let mut object = BTreeMap::new();
|
|
object.insert(vec![0i64], ());
|
|
object.insert(vec![100i64], ());
|
|
object.insert(vec![-1i64], ());
|
|
object.insert(vec![-2i64], ());
|
|
object.insert(vec![0i64, 0i64], ());
|
|
object.insert(vec![0i64, -1i64], ());
|
|
let vec = to_vec(&serde_cbor::value::to_value(object.clone()).unwrap()).unwrap();
|
|
assert_eq!(
|
|
vec![
|
|
166, 129, 0, 246, 129, 24, 100, 246, 129, 32, 246, 129, 33, 246, 130, 0, 0, 246,
|
|
130, 0, 32, 246
|
|
],
|
|
vec
|
|
);
|
|
let test_object = from_slice(&vec[..]).unwrap();
|
|
assert_eq!(object, test_object);
|
|
}
|
|
|
|
#[test]
|
|
fn test_object_object_keys() {
|
|
use std::iter::FromIterator;
|
|
let mut object = BTreeMap::new();
|
|
let keys = vec![
|
|
vec!["a"],
|
|
vec!["b"],
|
|
vec!["c"],
|
|
vec!["d"],
|
|
vec!["aa"],
|
|
vec!["a", "aa"],
|
|
]
|
|
.into_iter()
|
|
.map(|v| BTreeMap::from_iter(v.into_iter().map(|s| (s.to_owned(), ()))));
|
|
|
|
for key in keys {
|
|
object.insert(key, ());
|
|
}
|
|
let vec = to_vec(&serde_cbor::value::to_value(object.clone()).unwrap()).unwrap();
|
|
assert_eq!(
|
|
vec![
|
|
166, 161, 97, 97, 246, 246, 161, 97, 98, 246, 246, 161, 97, 99, 246, 246, 161, 97,
|
|
100, 246, 246, 161, 98, 97, 97, 246, 246, 162, 97, 97, 246, 98, 97, 97, 246, 246
|
|
],
|
|
vec
|
|
);
|
|
let test_object = from_slice(&vec[..]).unwrap();
|
|
assert_eq!(object, test_object);
|
|
}
|
|
|
|
#[test]
|
|
fn test_float() {
|
|
let vec = to_vec(&12.3f64).unwrap();
|
|
assert_eq!(vec, b"\xfb@(\x99\x99\x99\x99\x99\x9a");
|
|
}
|
|
|
|
#[test]
|
|
fn test_f32() {
|
|
let vec = to_vec(&4000.5f32).unwrap();
|
|
assert_eq!(vec, b"\xfa\x45\x7a\x08\x00");
|
|
}
|
|
|
|
#[test]
|
|
fn test_infinity() {
|
|
let vec = to_vec(&::std::f64::INFINITY).unwrap();
|
|
assert_eq!(vec, b"\xf9|\x00");
|
|
}
|
|
|
|
#[test]
|
|
fn test_neg_infinity() {
|
|
let vec = to_vec(&::std::f64::NEG_INFINITY).unwrap();
|
|
assert_eq!(vec, b"\xf9\xfc\x00");
|
|
}
|
|
|
|
#[test]
|
|
fn test_nan() {
|
|
let vec = to_vec(&::std::f32::NAN).unwrap();
|
|
assert_eq!(vec, b"\xf9\x7e\x00");
|
|
}
|
|
|
|
#[test]
|
|
fn test_integer() {
|
|
// u8
|
|
let vec = to_vec(&24).unwrap();
|
|
assert_eq!(vec, b"\x18\x18");
|
|
// i8
|
|
let vec = to_vec(&-5).unwrap();
|
|
assert_eq!(vec, b"\x24");
|
|
// i16
|
|
let vec = to_vec(&-300).unwrap();
|
|
assert_eq!(vec, b"\x39\x01\x2b");
|
|
// i32
|
|
let vec = to_vec(&-23567997).unwrap();
|
|
assert_eq!(vec, b"\x3a\x01\x67\x9e\x7c");
|
|
// u64
|
|
let vec = to_vec(&::std::u64::MAX).unwrap();
|
|
assert_eq!(vec, b"\x1b\xff\xff\xff\xff\xff\xff\xff\xff");
|
|
}
|
|
|
|
#[test]
|
|
fn test_self_describing() {
|
|
let mut vec = Vec::new();
|
|
{
|
|
let mut serializer = ser::Serializer::new(&mut vec);
|
|
serializer.self_describe().unwrap();
|
|
serializer.serialize_u64(9).unwrap();
|
|
}
|
|
assert_eq!(vec, b"\xd9\xd9\xf7\x09");
|
|
}
|
|
|
|
#[test]
|
|
fn test_ip_addr() {
|
|
use std::net::Ipv4Addr;
|
|
|
|
let addr = Ipv4Addr::new(8, 8, 8, 8);
|
|
let vec = to_vec(&addr).unwrap();
|
|
println!("{:?}", vec);
|
|
assert_eq!(vec.len(), 5);
|
|
let test_addr: Ipv4Addr = from_slice(&vec).unwrap();
|
|
assert_eq!(addr, test_addr);
|
|
}
|
|
|
|
/// Test all of CBOR's fixed-length byte string types
|
|
#[test]
|
|
fn test_byte_string() {
|
|
// Very short byte strings have 1-byte headers
|
|
let short = vec![0, 1, 2, 255];
|
|
let mut short_s = Vec::new();
|
|
serde_cbor::Serializer::new(&mut short_s)
|
|
.serialize_bytes(&short)
|
|
.unwrap();
|
|
assert_eq!(&short_s[..], [0x44, 0, 1, 2, 255]);
|
|
|
|
// byte strings > 23 bytes have 2-byte headers
|
|
let medium = vec![
|
|
0u8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 255,
|
|
];
|
|
let mut medium_s = Vec::new();
|
|
serde_cbor::Serializer::new(&mut medium_s)
|
|
.serialize_bytes(&medium)
|
|
.unwrap();
|
|
assert_eq!(
|
|
&medium_s[..],
|
|
[
|
|
0x58, 24, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
|
|
21, 22, 255
|
|
]
|
|
);
|
|
|
|
// byte strings > 256 bytes have 3-byte headers
|
|
let long_vec = (0..256).map(|i| (i & 0xFF) as u8).collect::<Vec<_>>();
|
|
let mut long_s = Vec::new();
|
|
serde_cbor::Serializer::new(&mut long_s)
|
|
.serialize_bytes(&long_vec)
|
|
.unwrap();
|
|
assert_eq!(&long_s[0..3], [0x59, 1, 0]);
|
|
assert_eq!(&long_s[3..], &long_vec[..]);
|
|
|
|
// byte strings > 2^16 bytes have 5-byte headers
|
|
let very_long_vec = (0..65536).map(|i| (i & 0xFF) as u8).collect::<Vec<_>>();
|
|
let mut very_long_s = Vec::new();
|
|
serde_cbor::Serializer::new(&mut very_long_s)
|
|
.serialize_bytes(&very_long_vec)
|
|
.unwrap();
|
|
assert_eq!(&very_long_s[0..5], [0x5a, 0, 1, 0, 0]);
|
|
assert_eq!(&very_long_s[5..], &very_long_vec[..]);
|
|
|
|
// byte strings > 2^32 bytes have 9-byte headers, but they take too much RAM
|
|
// to test in Travis.
|
|
}
|
|
|
|
#[test]
|
|
fn test_half() {
|
|
let vec = to_vec(&42.5f32).unwrap();
|
|
assert_eq!(vec, b"\xF9\x51\x50");
|
|
assert_eq!(from_slice::<f32>(&vec[..]).unwrap(), 42.5f32);
|
|
}
|
|
}
|