serde-smile 0.3.1

A Smile implementation for Serde
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::value::{BigDecimal, BigInteger, Value};
use indexmap::IndexMap;
use serde::de::DeserializeOwned;
use serde::Serialize;
use serde_bytes::ByteBuf;
use std::fmt::Debug;
use std::iter::FromIterator;

fn run_test<T>(raw: T, value: Value)
where
    T: Serialize + DeserializeOwned + PartialEq + Debug,
{
    let expected = crate::to_vec(&raw).unwrap();
    let actual = crate::to_vec(&raw).unwrap();
    assert_eq!(expected, actual);

    let actual = crate::from_slice::<Value>(&actual).unwrap();
    assert_eq!(value, actual);
}

#[test]
fn null() {
    run_test((), Value::Null);
}

#[test]
fn boolean() {
    run_test(true, Value::Boolean(true));
    run_test(false, Value::Boolean(false));
}

#[test]
fn integer() {
    run_test(0i32, Value::Integer(0));
    run_test(-10i32, Value::Integer(-10));
    run_test(10i32, Value::Integer(10));
}

#[test]
fn long() {
    run_test(1i64 << 50, Value::Long(1 << 50));
    run_test(-(1i64 << 50), Value::Long(-(1 << 50)));
}

#[test]
fn big_integer() {
    run_test(
        BigInteger::from_be_bytes(vec![0]),
        Value::BigInteger(BigInteger::from_be_bytes(vec![0])),
    );
    run_test(
        BigInteger::from_be_bytes(vec![0xff; 30]),
        Value::BigInteger(BigInteger::from_be_bytes(vec![0xff; 30])),
    );
}

#[test]
fn float() {
    run_test(0f32, Value::Float(0f32));
    run_test(f32::INFINITY, Value::Float(f32::INFINITY));
}

#[test]
fn double() {
    run_test(0f64, Value::Double(0f64));
    run_test(f64::INFINITY, Value::Double(f64::INFINITY));
}

#[test]
fn big_decimal() {
    run_test(
        BigDecimal::new(BigInteger::from_be_bytes(vec![0]), 0),
        Value::BigDecimal(BigDecimal::new(BigInteger::from_be_bytes(vec![0]), 0)),
    );
    run_test(
        BigDecimal::new(BigInteger::from_be_bytes(vec![0xff; 30]), -10),
        Value::BigDecimal(BigDecimal::new(
            BigInteger::from_be_bytes(vec![0xff; 30]),
            -10,
        )),
    );
}

#[test]
fn string() {
    run_test("".to_string(), Value::String("".to_string()));
    run_test(
        "hello world".to_string(),
        Value::String("hello world".to_string()),
    );
}

#[test]
fn binary() {
    run_test(ByteBuf::from(vec![]), Value::Binary(vec![]));
    run_test(ByteBuf::from(vec![0xff; 30]), Value::Binary(vec![0xff; 30]));
}

#[test]
fn array() {
    run_test(Vec::<i32>::new(), Value::Array(vec![]));
    run_test(
        vec![1, 2],
        Value::Array(vec![Value::Integer(1), Value::Integer(2)]),
    );
}

#[test]
fn object() {
    run_test(
        IndexMap::<String, i32>::new(),
        Value::Object(IndexMap::new()),
    );
    run_test(
        IndexMap::<_, _>::from_iter([("Hello".to_string(), 123)]),
        Value::Object(IndexMap::<_, _>::from_iter([(
            "Hello".to_string(),
            Value::Integer(123),
        )])),
    );
}