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

use serde::{Serialize, Deserialize};

use de::Deserializer;
use error::Error;
use ser::Serializer;
use token::Token;

use std::fmt::Debug;

pub fn assert_tokens<T>(value: &T, tokens: &[Token<'static>])
    where T: Serialize + Deserialize + PartialEq + Debug,
{
    assert_ser_tokens(value, tokens);
    assert_de_tokens(value, tokens);
}

pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
    where T: Serialize,
{
    let mut ser = Serializer::new(tokens.iter());
    assert_eq!(Serialize::serialize(value, &mut ser), Ok(()));
    assert_eq!(ser.next_token(), None);
}

/// Expect an error serializing `T`.
pub fn assert_ser_tokens_error<T>(value: &T, tokens: &[Token], error: Error)
    where T: Serialize + PartialEq + Debug,
{
    let mut ser = Serializer::new(tokens.iter());
    let v: Result<(), Error> = Serialize::serialize(value, &mut ser);
    assert_eq!(v.as_ref(), Err(&error));
    assert_eq!(ser.next_token(), None);
}

pub fn assert_de_tokens<T>(value: &T, tokens: &[Token<'static>])
    where T: Deserialize + PartialEq + Debug,
{
    let mut de = Deserializer::new(tokens.to_vec().into_iter());
    let v: Result<T, Error> = Deserialize::deserialize(&mut de);
    assert_eq!(v.as_ref(), Ok(value));
    assert_eq!(de.next_token(), None);
}

/// Expect an error deserializing tokens into a `T`.
pub fn assert_de_tokens_error<T>(tokens: &[Token<'static>], error: Error)
    where T: Deserialize + PartialEq + Debug,
{
    let mut de = Deserializer::new(tokens.to_vec().into_iter());
    let v: Result<T, Error> = Deserialize::deserialize(&mut de);
    assert_eq!(v, Err(error));
    // There may be one token left if a peek caused the error
    de.next_token();
    assert_eq!(de.next_token(), None);
}