1 use std::fmt::{self, Debug, Display}; 2 3 #[derive(Copy, Clone, PartialEq, Debug)] 4 pub enum Token { 5 /// A serialized `bool`. 6 /// 7 /// ```edition2018 8 /// # use serde_test::{assert_tokens, Token}; 9 /// # 10 /// assert_tokens(&true, &[Token::Bool(true)]); 11 /// ``` 12 Bool(bool), 13 14 /// A serialized `i8`. 15 /// 16 /// ```edition2018 17 /// # use serde_test::{assert_tokens, Token}; 18 /// # 19 /// assert_tokens(&0i8, &[Token::I8(0)]); 20 /// ``` 21 I8(i8), 22 23 /// A serialized `i16`. 24 /// 25 /// ```edition2018 26 /// # use serde_test::{assert_tokens, Token}; 27 /// # 28 /// assert_tokens(&0i16, &[Token::I16(0)]); 29 /// ``` 30 I16(i16), 31 32 /// A serialized `i32`. 33 /// 34 /// ```edition2018 35 /// # use serde_test::{assert_tokens, Token}; 36 /// # 37 /// assert_tokens(&0i32, &[Token::I32(0)]); 38 /// ``` 39 I32(i32), 40 41 /// A serialized `i64`. 42 /// 43 /// ```edition2018 44 /// # use serde_test::{assert_tokens, Token}; 45 /// # 46 /// assert_tokens(&0i64, &[Token::I64(0)]); 47 /// ``` 48 I64(i64), 49 50 /// A serialized `u8`. 51 /// 52 /// ```edition2018 53 /// # use serde_test::{assert_tokens, Token}; 54 /// # 55 /// assert_tokens(&0u8, &[Token::U8(0)]); 56 /// ``` 57 U8(u8), 58 59 /// A serialized `u16`. 60 /// 61 /// ```edition2018 62 /// # use serde_test::{assert_tokens, Token}; 63 /// # 64 /// assert_tokens(&0u16, &[Token::U16(0)]); 65 /// ``` 66 U16(u16), 67 68 /// A serialized `u32`. 69 /// 70 /// ```edition2018 71 /// # use serde_test::{assert_tokens, Token}; 72 /// # 73 /// assert_tokens(&0u32, &[Token::U32(0)]); 74 /// ``` 75 U32(u32), 76 77 /// A serialized `u64`. 78 /// 79 /// ```edition2018 80 /// # use serde_test::{assert_tokens, Token}; 81 /// # 82 /// assert_tokens(&0u64, &[Token::U64(0)]); 83 /// ``` 84 U64(u64), 85 86 /// A serialized `f32`. 87 /// 88 /// ```edition2018 89 /// # use serde_test::{assert_tokens, Token}; 90 /// # 91 /// assert_tokens(&0f32, &[Token::F32(0.0)]); 92 /// ``` 93 F32(f32), 94 95 /// A serialized `f64`. 96 /// 97 /// ```edition2018 98 /// # use serde_test::{assert_tokens, Token}; 99 /// # 100 /// assert_tokens(&0f64, &[Token::F64(0.0)]); 101 /// ``` 102 F64(f64), 103 104 /// A serialized `char`. 105 /// 106 /// ```edition2018 107 /// # use serde_test::{assert_tokens, Token}; 108 /// # 109 /// assert_tokens(&'\n', &[Token::Char('\n')]); 110 /// ``` 111 Char(char), 112 113 /// A serialized `str`. 114 /// 115 /// ```edition2018 116 /// # use serde_test::{assert_tokens, Token}; 117 /// # 118 /// let s = String::from("transient"); 119 /// assert_tokens(&s, &[Token::Str("transient")]); 120 /// ``` 121 Str(&'static str), 122 123 /// A borrowed `str`. 124 /// 125 /// ```edition2018 126 /// # use serde_test::{assert_tokens, Token}; 127 /// # 128 /// let s: &str = "borrowed"; 129 /// assert_tokens(&s, &[Token::BorrowedStr("borrowed")]); 130 /// ``` 131 BorrowedStr(&'static str), 132 133 /// A serialized `String`. 134 /// 135 /// ```edition2018 136 /// # use serde_test::{assert_tokens, Token}; 137 /// # 138 /// let s = String::from("owned"); 139 /// assert_tokens(&s, &[Token::String("owned")]); 140 /// ``` 141 String(&'static str), 142 143 /// A serialized `[u8]` 144 Bytes(&'static [u8]), 145 146 /// A borrowed `[u8]`. 147 BorrowedBytes(&'static [u8]), 148 149 /// A serialized `ByteBuf` 150 ByteBuf(&'static [u8]), 151 152 /// A serialized `Option<T>` containing none. 153 /// 154 /// ```edition2018 155 /// # use serde_test::{assert_tokens, Token}; 156 /// # 157 /// let opt = None::<char>; 158 /// assert_tokens(&opt, &[Token::None]); 159 /// ``` 160 None, 161 162 /// The header to a serialized `Option<T>` containing some value. 163 /// 164 /// The tokens of the value follow after this header. 165 /// 166 /// ```edition2018 167 /// # use serde_test::{assert_tokens, Token}; 168 /// # 169 /// let opt = Some('c'); 170 /// assert_tokens(&opt, &[ 171 /// Token::Some, 172 /// Token::Char('c'), 173 /// ]); 174 /// ``` 175 Some, 176 177 /// A serialized `()`. 178 /// 179 /// ```edition2018 180 /// # use serde_test::{assert_tokens, Token}; 181 /// # 182 /// assert_tokens(&(), &[Token::Unit]); 183 /// ``` 184 Unit, 185 186 /// A serialized unit struct of the given name. 187 /// 188 /// ```edition2018 189 /// # use serde::{Serialize, Deserialize}; 190 /// # use serde_test::{assert_tokens, Token}; 191 /// # 192 /// # fn main() { 193 /// #[derive(Serialize, Deserialize, PartialEq, Debug)] 194 /// struct X; 195 /// 196 /// assert_tokens(&X, &[Token::UnitStruct { name: "X" }]); 197 /// # } 198 /// ``` 199 UnitStruct { name: &'static str }, 200 201 /// A unit variant of an enum. 202 /// 203 /// ```edition2018 204 /// # use serde::{Serialize, Deserialize}; 205 /// # use serde_test::{assert_tokens, Token}; 206 /// # 207 /// # fn main() { 208 /// #[derive(Serialize, Deserialize, PartialEq, Debug)] 209 /// enum E { 210 /// A, 211 /// } 212 /// 213 /// let a = E::A; 214 /// assert_tokens(&a, &[Token::UnitVariant { name: "E", variant: "A" }]); 215 /// # } 216 /// ``` 217 UnitVariant { 218 name: &'static str, 219 variant: &'static str, 220 }, 221 222 /// The header to a serialized newtype struct of the given name. 223 /// 224 /// After this header is the value contained in the newtype struct. 225 /// 226 /// ```edition2018 227 /// # use serde::{Serialize, Deserialize}; 228 /// # use serde_test::{assert_tokens, Token}; 229 /// # 230 /// # fn main() { 231 /// #[derive(Serialize, Deserialize, PartialEq, Debug)] 232 /// struct N(String); 233 /// 234 /// let n = N("newtype".to_owned()); 235 /// assert_tokens(&n, &[ 236 /// Token::NewtypeStruct { name: "N" }, 237 /// Token::String("newtype"), 238 /// ]); 239 /// # } 240 /// ``` 241 NewtypeStruct { name: &'static str }, 242 243 /// The header to a newtype variant of an enum. 244 /// 245 /// After this header is the value contained in the newtype variant. 246 /// 247 /// ```edition2018 248 /// # use serde::{Serialize, Deserialize}; 249 /// # use serde_test::{assert_tokens, Token}; 250 /// # 251 /// # fn main() { 252 /// #[derive(Serialize, Deserialize, PartialEq, Debug)] 253 /// enum E { 254 /// B(u8), 255 /// } 256 /// 257 /// let b = E::B(0); 258 /// assert_tokens(&b, &[ 259 /// Token::NewtypeVariant { name: "E", variant: "B" }, 260 /// Token::U8(0), 261 /// ]); 262 /// # } 263 /// ``` 264 NewtypeVariant { 265 name: &'static str, 266 variant: &'static str, 267 }, 268 269 /// The header to a sequence. 270 /// 271 /// After this header are the elements of the sequence, followed by 272 /// `SeqEnd`. 273 /// 274 /// ```edition2018 275 /// # use serde_test::{assert_tokens, Token}; 276 /// # 277 /// let vec = vec!['a', 'b', 'c']; 278 /// assert_tokens(&vec, &[ 279 /// Token::Seq { len: Some(3) }, 280 /// Token::Char('a'), 281 /// Token::Char('b'), 282 /// Token::Char('c'), 283 /// Token::SeqEnd, 284 /// ]); 285 /// ``` 286 Seq { len: Option<usize> }, 287 288 /// An indicator of the end of a sequence. 289 SeqEnd, 290 291 /// The header to a tuple. 292 /// 293 /// After this header are the elements of the tuple, followed by `TupleEnd`. 294 /// 295 /// ```edition2018 296 /// # use serde_test::{assert_tokens, Token}; 297 /// # 298 /// let tuple = ('a', 100); 299 /// assert_tokens(&tuple, &[ 300 /// Token::Tuple { len: 2 }, 301 /// Token::Char('a'), 302 /// Token::I32(100), 303 /// Token::TupleEnd, 304 /// ]); 305 /// ``` 306 Tuple { len: usize }, 307 308 /// An indicator of the end of a tuple. 309 TupleEnd, 310 311 /// The header to a tuple struct. 312 /// 313 /// After this header are the fields of the tuple struct, followed by 314 /// `TupleStructEnd`. 315 /// 316 /// ```edition2018 317 /// # use serde::{Serialize, Deserialize}; 318 /// # use serde_test::{assert_tokens, Token}; 319 /// # 320 /// # fn main() { 321 /// #[derive(Serialize, Deserialize, PartialEq, Debug)] 322 /// struct T(u8, u8); 323 /// 324 /// let t = T(0, 0); 325 /// assert_tokens(&t, &[ 326 /// Token::TupleStruct { name: "T", len: 2 }, 327 /// Token::U8(0), 328 /// Token::U8(0), 329 /// Token::TupleStructEnd, 330 /// ]); 331 /// # } 332 /// ``` 333 TupleStruct { name: &'static str, len: usize }, 334 335 /// An indicator of the end of a tuple struct. 336 TupleStructEnd, 337 338 /// The header to a tuple variant of an enum. 339 /// 340 /// After this header are the fields of the tuple variant, followed by 341 /// `TupleVariantEnd`. 342 /// 343 /// ```edition2018 344 /// # use serde::{Serialize, Deserialize}; 345 /// # use serde_test::{assert_tokens, Token}; 346 /// # 347 /// # fn main() { 348 /// #[derive(Serialize, Deserialize, PartialEq, Debug)] 349 /// enum E { 350 /// C(u8, u8), 351 /// } 352 /// 353 /// let c = E::C(0, 0); 354 /// assert_tokens(&c, &[ 355 /// Token::TupleVariant { name: "E", variant: "C", len: 2 }, 356 /// Token::U8(0), 357 /// Token::U8(0), 358 /// Token::TupleVariantEnd, 359 /// ]); 360 /// # } 361 /// ``` 362 TupleVariant { 363 name: &'static str, 364 variant: &'static str, 365 len: usize, 366 }, 367 368 /// An indicator of the end of a tuple variant. 369 TupleVariantEnd, 370 371 /// The header to a map. 372 /// 373 /// After this header are the entries of the map, followed by `MapEnd`. 374 /// 375 /// ```edition2018 376 /// # use serde_test::{assert_tokens, Token}; 377 /// # 378 /// use std::collections::BTreeMap; 379 /// 380 /// let mut map = BTreeMap::new(); 381 /// map.insert('A', 65); 382 /// map.insert('Z', 90); 383 /// 384 /// assert_tokens(&map, &[ 385 /// Token::Map { len: Some(2) }, 386 /// Token::Char('A'), 387 /// Token::I32(65), 388 /// Token::Char('Z'), 389 /// Token::I32(90), 390 /// Token::MapEnd, 391 /// ]); 392 /// ``` 393 Map { len: Option<usize> }, 394 395 /// An indicator of the end of a map. 396 MapEnd, 397 398 /// The header of a struct. 399 /// 400 /// After this header are the fields of the struct, followed by `StructEnd`. 401 /// 402 /// ```edition2018 403 /// # use serde::{Serialize, Deserialize}; 404 /// # use serde_test::{assert_tokens, Token}; 405 /// # 406 /// # fn main() { 407 /// #[derive(Serialize, Deserialize, PartialEq, Debug)] 408 /// struct S { 409 /// a: u8, 410 /// b: u8, 411 /// } 412 /// 413 /// let s = S { a: 0, b: 0 }; 414 /// assert_tokens(&s, &[ 415 /// Token::Struct { name: "S", len: 2 }, 416 /// Token::Str("a"), 417 /// Token::U8(0), 418 /// Token::Str("b"), 419 /// Token::U8(0), 420 /// Token::StructEnd, 421 /// ]); 422 /// # } 423 /// ``` 424 Struct { name: &'static str, len: usize }, 425 426 /// An indicator of the end of a struct. 427 StructEnd, 428 429 /// The header of a struct variant of an enum. 430 /// 431 /// After this header are the fields of the struct variant, followed by 432 /// `StructVariantEnd`. 433 /// 434 /// ```edition2018 435 /// # use serde::{Serialize, Deserialize}; 436 /// # use serde_test::{assert_tokens, Token}; 437 /// # 438 /// # fn main() { 439 /// #[derive(Serialize, Deserialize, PartialEq, Debug)] 440 /// enum E { 441 /// D { d: u8 }, 442 /// } 443 /// 444 /// let d = E::D { d: 0 }; 445 /// assert_tokens(&d, &[ 446 /// Token::StructVariant { name: "E", variant: "D", len: 1 }, 447 /// Token::Str("d"), 448 /// Token::U8(0), 449 /// Token::StructVariantEnd, 450 /// ]); 451 /// # } 452 /// ``` 453 StructVariant { 454 name: &'static str, 455 variant: &'static str, 456 len: usize, 457 }, 458 459 /// An indicator of the end of a struct variant. 460 StructVariantEnd, 461 462 /// The header to an enum of the given name. 463 /// 464 /// ```edition2018 465 /// # use serde::{Serialize, Deserialize}; 466 /// # use serde_test::{assert_tokens, Token}; 467 /// # 468 /// # fn main() { 469 /// #[derive(Serialize, Deserialize, PartialEq, Debug)] 470 /// enum E { 471 /// A, 472 /// B(u8), 473 /// C(u8, u8), 474 /// D { d: u8 }, 475 /// } 476 /// 477 /// let a = E::A; 478 /// assert_tokens(&a, &[ 479 /// Token::Enum { name: "E" }, 480 /// Token::Str("A"), 481 /// Token::Unit, 482 /// ]); 483 /// 484 /// let b = E::B(0); 485 /// assert_tokens(&b, &[ 486 /// Token::Enum { name: "E" }, 487 /// Token::Str("B"), 488 /// Token::U8(0), 489 /// ]); 490 /// 491 /// let c = E::C(0, 0); 492 /// assert_tokens(&c, &[ 493 /// Token::Enum { name: "E" }, 494 /// Token::Str("C"), 495 /// Token::Seq { len: Some(2) }, 496 /// Token::U8(0), 497 /// Token::U8(0), 498 /// Token::SeqEnd, 499 /// ]); 500 /// 501 /// let d = E::D { d: 0 }; 502 /// assert_tokens(&d, &[ 503 /// Token::Enum { name: "E" }, 504 /// Token::Str("D"), 505 /// Token::Map { len: Some(1) }, 506 /// Token::Str("d"), 507 /// Token::U8(0), 508 /// Token::MapEnd, 509 /// ]); 510 /// # } 511 /// ``` 512 Enum { name: &'static str }, 513 } 514 515 impl Display for Token { fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result516 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 517 Debug::fmt(self, formatter) 518 } 519 } 520