generic-arraydeque 0.2.0

A fixed-capacity, stack-allocated double-ended queue (deque) backed by generic-array
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

#![cfg(feature = "serde")]

use generic_arraydeque::{typenum::U4, GenericArrayDeque};
use serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};

#[test]
fn serialize_roundtrip() {
  let mut deque = GenericArrayDeque::<u32, U4>::new();
  deque.push_back(10);
  deque.push_back(20);
  deque.push_back(30);

  assert_tokens(
    &deque,
    &[
      Token::Seq { len: Some(3) },
      Token::U32(10),
      Token::U32(20),
      Token::U32(30),
      Token::SeqEnd,
    ],
  );

  assert_de_tokens(
    &GenericArrayDeque::<u32, U4>::try_from_array([10, 20, 30]).unwrap(),
    &[
      Token::Seq { len: Some(3) },
      Token::U32(10),
      Token::U32(20),
      Token::U32(30),
      Token::SeqEnd,
    ],
  );
}

#[test]
fn deserialize_overflow() {
  assert_de_tokens_error::<GenericArrayDeque<u8, U4>>(
    &[
      Token::Seq { len: Some(5) },
      Token::U8(1),
      Token::U8(2),
      Token::U8(3),
      Token::U8(4),
      Token::U8(5),
      Token::SeqEnd,
    ],
    "sequence length exceeds capacity",
  );
}

#[test]
fn deserialize_rejects_non_sequence() {
  // Hits `Visitor::expecting`, which is called to format the error
  // message when the incoming token is not a sequence.
  assert_de_tokens_error::<GenericArrayDeque<u8, U4>>(
    &[Token::I32(42)],
    "invalid type: integer `42`, expected a sequence",
  );
}