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.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&true, &[Token::Bool(true)]);

I8(i8)

A serialized i8.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0i8, &[Token::I8(0)]);

I16(i16)

A serialized i16.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0i16, &[Token::I16(0)]);

I32(i32)

A serialized i32.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0i32, &[Token::I32(0)]);

I64(i64)

A serialized i64.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0i64, &[Token::I64(0)]);

U8(u8)

A serialized u8.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0u8, &[Token::U8(0)]);

U16(u16)

A serialized u16.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0u16, &[Token::U16(0)]);

U32(u32)

A serialized u32.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0u32, &[Token::U32(0)]);

U64(u64)

A serialized u64.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0u64, &[Token::U64(0)]);

F32(f32)

A serialized f32.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0f32, &[Token::F32(0.0)]);

F64(f64)

A serialized f64.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&0f64, &[Token::F64(0.0)]);

Char(char)

A serialized char.

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&'\n', &[Token::Char('\n')]);

Str(&'static str)

A serialized str.

# use serde_test::{assert_tokens, Token};
#
let s = String::from("transient");
assert_tokens(&s, &[Token::Str("transient")]);

BorrowedStr(&'static str)

A borrowed str.

# use serde_test::{assert_tokens, Token};
#
let s: &str = "borrowed";
assert_tokens(&s, &[Token::BorrowedStr("borrowed")]);

String(&'static str)

A serialized String.

# use serde_test::{assert_tokens, Token};
#
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.

# use serde_test::{assert_tokens, Token};
#
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.

# use serde_test::{assert_tokens, Token};
#
let opt = Some('c');
assert_tokens(&opt, &[
    Token::Some,
    Token::Char('c'),
]);

Unit

A serialized ().

# use serde_test::{assert_tokens, Token};
#
assert_tokens(&(), &[Token::Unit]);

UnitStruct

A serialized unit struct of the given name.

# use serde::{Serialize, Deserialize};
# use serde_test::{assert_tokens, Token};
#
# fn main() {
#[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.

# use serde::{Serialize, Deserialize};
# use serde_test::{assert_tokens, Token};
#
# fn main() {
#[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 strvariant: &'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.

# use serde::{Serialize, Deserialize};
# use serde_test::{assert_tokens, Token};
#
# fn main() {
#[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.

# use serde::{Serialize, Deserialize};
# use serde_test::{assert_tokens, Token};
#
# fn main() {
#[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 strvariant: &'static str

Seq

The header to a sequence.

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

# use serde_test::{assert_tokens, Token};
#
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.

# use serde_test::{assert_tokens, Token};
#
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.

# use serde::{Serialize, Deserialize};
# use serde_test::{assert_tokens, Token};
#
# fn main() {
#[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 strlen: 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.

# use serde::{Serialize, Deserialize};
# use serde_test::{assert_tokens, Token};
#
# fn main() {
#[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 strvariant: &'static strlen: 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 serde_test::{assert_tokens, Token};
#
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.

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

# use serde::{Serialize, Deserialize};
# use serde_test::{assert_tokens, Token};
#
# fn main() {
#[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 strlen: usize

StructEnd

An indicator of the end of a struct.

StructVariant

The header of a struct variant of an enum.

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

# use serde::{Serialize, Deserialize};
# use serde_test::{assert_tokens, Token};
#
# fn main() {
#[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 strvariant: &'static strlen: usize

StructVariantEnd

An indicator of the end of a struct variant.

Enum

The header to an enum of the given name.

# use serde::{Serialize, Deserialize};
# use serde_test::{assert_tokens, Token};
#
# fn main() {
#[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 PartialEq<Token> for Token

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

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

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

This method tests for !=.

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 Copy for Token

impl Debug for Token

fn fmt(&self, f: &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.