Quelle  ser.rs   Sprache: unbekannt

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);
    }
}