Enum serde_test::Token

pub enum Token {
    Bool(bool),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    F32(f32),
    F64(f64),
    Char(char),
    Str(&'static str),
    BorrowedStr(&'static str),
    String(&'static str),
    Bytes(&'static [u8]),
    BorrowedBytes(&'static [u8]),
    ByteBuf(&'static [u8]),
    None,
    Some,
    Unit,
    UnitStruct {
        name: &'static str,
    },
    UnitVariant {
        name: &'static str,
        variant: &'static str,
    },
    NewtypeStruct {
        name: &'static str,
    },
    NewtypeVariant {
        name: &'static str,
        variant: &'static str,
    },
    Seq {
        len: Option<usize>,
    },
    SeqEnd,
    Tuple {
        len: usize,
    },
    TupleEnd,
    TupleStruct {
        name: &'static str,
        len: usize,
    },
    TupleStructEnd,
    TupleVariant {
        name: &'static str,
        variant: &'static str,
        len: usize,
    },
    TupleVariantEnd,
    Map {
        len: Option<usize>,
    },
    MapEnd,
    Struct {
        name: &'static str,
        len: usize,
    },
    StructEnd,
    StructVariant {
        name: &'static str,
        variant: &'static str,
        len: usize,
    },
    StructVariantEnd,
    Enum {
        name: &'static str,
    },
}

Variants

Bool(bool)

A serialized bool.

assert_tokens(&true, &[Token::Bool(true)]);

I8(i8)

A serialized i8.

assert_tokens(&0i8, &[Token::I8(0)]);

I16(i16)

A serialized i16.

assert_tokens(&0i16, &[Token::I16(0)]);

I32(i32)

A serialized i32.

assert_tokens(&0i32, &[Token::I32(0)]);

I64(i64)

A serialized i64.

assert_tokens(&0i64, &[Token::I64(0)]);

U8(u8)

A serialized u8.

assert_tokens(&0u8, &[Token::U8(0)]);

U16(u16)

A serialized u16.

assert_tokens(&0u16, &[Token::U16(0)]);

U32(u32)

A serialized u32.

assert_tokens(&0u32, &[Token::U32(0)]);

U64(u64)

A serialized u64.

assert_tokens(&0u64, &[Token::U64(0)]);

F32(f32)

A serialized f32.

assert_tokens(&0f32, &[Token::F32(0.0)]);

F64(f64)

A serialized f64.

assert_tokens(&0f64, &[Token::F64(0.0)]);

Char(char)

A serialized char.

assert_tokens(&'\n', &[Token::Char('\n')]);

Str(&'static str)

A serialized str.

let s = String::from("transient");
assert_tokens(&s, &[Token::Str("transient")]);

BorrowedStr(&'static str)

A borrowed str.

let s: &str = "borrowed";
assert_tokens(&s, &[Token::BorrowedStr("borrowed")]);

String(&'static str)

A serialized String.

let s = String::from("owned");
assert_tokens(&s, &[Token::String("owned")]);

Bytes(&'static [u8])

A serialized [u8]

BorrowedBytes(&'static [u8])

A borrowed [u8].

ByteBuf(&'static [u8])

A serialized ByteBuf

None

A serialized Option<T> containing none.

let opt = None::<char>;
assert_tokens(&opt, &[Token::None]);

Some

The header to a serialized Option<T> containing some value.

The tokens of the value follow after this header.

let opt = Some('c');
assert_tokens(&opt, &[
    Token::Some,
    Token::Char('c'),
]);

Unit

A serialized ().

assert_tokens(&(), &[Token::Unit]);

UnitStruct

A serialized unit struct of the given name.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct X;

assert_tokens(&X, &[Token::UnitStruct { name: "X" }]);

Fields of UnitStruct

name: &'static str

UnitVariant

A unit variant of an enum.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
    A,
}

let a = E::A;
assert_tokens(&a, &[Token::UnitVariant { name: "E", variant: "A" }]);

Fields of UnitVariant

name: &'static str
variant: &'static str

NewtypeStruct

The header to a serialized newtype struct of the given name.

After this header is the value contained in the newtype struct.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct N(String);

let n = N("newtype".to_owned());
assert_tokens(&n, &[
    Token::NewtypeStruct { name: "N" },
    Token::String("newtype"),
]);

Fields of NewtypeStruct

name: &'static str

NewtypeVariant

The header to a newtype variant of an enum.

After this header is the value contained in the newtype variant.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
    B(u8),
}

let b = E::B(0);
assert_tokens(&b, &[
    Token::NewtypeVariant { name: "E", variant: "B" },
    Token::U8(0),
]);

Fields of NewtypeVariant

name: &'static str
variant: &'static str

Seq

The header to a sequence.

After this header are the elements of the sequence, followed by SeqEnd.

let vec = vec!['a', 'b', 'c'];
assert_tokens(&vec, &[
    Token::Seq { len: Some(3) },
    Token::Char('a'),
    Token::Char('b'),
    Token::Char('c'),
    Token::SeqEnd,
]);

Fields of Seq

len: Option<usize>

SeqEnd

An indicator of the end of a sequence.

Tuple

The header to a tuple.

After this header are the elements of the tuple, followed by TupleEnd.

let tuple = ('a', 100);
assert_tokens(&tuple, &[
    Token::Tuple { len: 2 },
    Token::Char('a'),
    Token::I32(100),
    Token::TupleEnd,
]);

Fields of Tuple

len: usize

TupleEnd

An indicator of the end of a tuple.

TupleStruct

The header to a tuple struct.

After this header are the fields of the tuple struct, followed by TupleStructEnd.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct T(u8, u8);

let t = T(0, 0);
assert_tokens(&t, &[
    Token::TupleStruct { name: "T", len: 2 },
    Token::U8(0),
    Token::U8(0),
    Token::TupleStructEnd,
]);

Fields of TupleStruct

name: &'static str
len: usize

TupleStructEnd

An indicator of the end of a tuple struct.

TupleVariant

The header to a tuple variant of an enum.

After this header are the fields of the tuple variant, followed by TupleVariantEnd.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
    C(u8, u8),
}

let c = E::C(0, 0);
assert_tokens(&c, &[
    Token::TupleVariant { name: "E", variant: "C", len: 2 },
    Token::U8(0),
    Token::U8(0),
    Token::TupleVariantEnd,
]);

Fields of TupleVariant

name: &'static str
variant: &'static str
len: usize

TupleVariantEnd

An indicator of the end of a tuple variant.

Map

The header to a map.

After this header are the entries of the map, followed by MapEnd.

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert('A', 65);
map.insert('Z', 90);

assert_tokens(&map, &[
    Token::Map { len: Some(2) },
    Token::Char('A'),
    Token::I32(65),
    Token::Char('Z'),
    Token::I32(90),
    Token::MapEnd,
]);

Fields of Map

len: Option<usize>

MapEnd

An indicator of the end of a map.

Struct

The header of a struct.

When testing deserialization, the len field must match the number of fields that the struct expects to deserialize. This may be different from the number of fields contained in the input tokens.

After this header are the fields of the struct, followed by StructEnd.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct S {
    a: u8,
    b: u8,
}

let s = S { a: 0, b: 0 };
assert_tokens(&s, &[
    Token::Struct { name: "S", len: 2 },
    Token::Str("a"),
    Token::U8(0),
    Token::Str("b"),
    Token::U8(0),
    Token::StructEnd,
]);

Fields of Struct

name: &'static str
len: usize

StructEnd

An indicator of the end of a struct.

StructVariant

The header of a struct variant of an enum.

When testing deserialization, the len field must match the number of fields that the struct variant expects to deserialize. This may be different from the number of fields contained in the input tokens.

After this header are the fields of the struct variant, followed by StructVariantEnd.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
    D { d: u8 },
}

let d = E::D { d: 0 };
assert_tokens(&d, &[
    Token::StructVariant { name: "E", variant: "D", len: 1 },
    Token::Str("d"),
    Token::U8(0),
    Token::StructVariantEnd,
]);

Fields of StructVariant

name: &'static str
variant: &'static str
len: usize

StructVariantEnd

An indicator of the end of a struct variant.

Enum

The header to an enum of the given name.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
    A,
    B(u8),
    C(u8, u8),
    D { d: u8 },
}

let a = E::A;
assert_tokens(&a, &[
    Token::Enum { name: "E" },
    Token::Str("A"),
    Token::Unit,
]);

let b = E::B(0);
assert_tokens(&b, &[
    Token::Enum { name: "E" },
    Token::Str("B"),
    Token::U8(0),
]);

let c = E::C(0, 0);
assert_tokens(&c, &[
    Token::Enum { name: "E" },
    Token::Str("C"),
    Token::Seq { len: Some(2) },
    Token::U8(0),
    Token::U8(0),
    Token::SeqEnd,
]);

let d = E::D { d: 0 };
assert_tokens(&d, &[
    Token::Enum { name: "E" },
    Token::Str("D"),
    Token::Map { len: Some(1) },
    Token::Str("d"),
    Token::U8(0),
    Token::MapEnd,
]);

Fields of Enum

name: &'static str

Trait Implementations

impl Copy for Token

impl Clone for Token

fn clone(&self) -> Token

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq for Token

fn eq(&self, __arg_0: &Token) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Token) -> bool

This method tests for !=.

impl Debug for Token

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for Token

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.