enumoid 0.4.0

Enum Indexed Containers
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use crate::test::types::{
  CompoundSeven, Seventeen, Sixteen, StructOne, StructThree, Three,
  ThreeHundred, WideThree,
};
use enumoid::{EnumIndex, Enumoid};
use std::{fmt::Debug, iter::zip};

use super::types::{CompoundOnWideSeven, CompoundWideOnSeven};

fn test_type<T: Enumoid + Copy + Debug + PartialEq>(values: &Vec<T>) {
  assert_eq!(T::FIRST, *values.first().unwrap());
  assert_eq!(T::LAST, *values.last().unwrap());
  assert_eq!(T::SIZE, values.len());
  let test: Vec<T> = values.iter().copied().collect();
  assert_eq!(T::SIZE, test.len());
  for (i, (x, y)) in zip(test, values.iter().copied()).enumerate() {
    assert_eq!(x, y);
    assert_eq!(EnumIndex::from_value(x).into_usize(), i);
    if i == 0 {
      assert_eq!(x.prev(), None);
      assert_eq!(x.prev_wrapped(), T::LAST);
    } else {
      assert_eq!(x.prev(), Some(values[i - 1]));
      assert_eq!(x.prev_wrapped(), values[i - 1]);
    }
    if i == values.len() - 1 {
      assert_eq!(x.next(), None);
      assert_eq!(x.next_wrapped(), T::FIRST);
    } else {
      assert_eq!(x.next(), Some(values[i + 1]));
      assert_eq!(x.next_wrapped(), values[i + 1]);
    }
  }
}

#[test]
fn test_three() {
  test_type::<Three>(&vec![Three::A, Three::B, Three::C]);
  test_type::<WideThree>(&vec![WideThree::A, WideThree::B, WideThree::C]);
}

#[test]
fn test_struct() {
  test_type::<StructOne>(&vec![StructOne]);
  test_type::<StructThree>(&vec![
    StructThree(Three::A),
    StructThree(Three::B),
    StructThree(Three::C),
  ]);
}

#[test]
fn test_compound_seven() {
  test_type::<CompoundSeven>(&vec![
    CompoundSeven::X(Three::A),
    CompoundSeven::X(Three::B),
    CompoundSeven::X(Three::C),
    CompoundSeven::Y,
    CompoundSeven::Z(Three::A),
    CompoundSeven::Z(Three::B),
    CompoundSeven::Z(Three::C),
  ]);
  test_type::<CompoundOnWideSeven>(&vec![
    CompoundOnWideSeven::X(WideThree::A),
    CompoundOnWideSeven::X(WideThree::B),
    CompoundOnWideSeven::X(WideThree::C),
    CompoundOnWideSeven::Y,
    CompoundOnWideSeven::Z(WideThree::A),
    CompoundOnWideSeven::Z(WideThree::B),
    CompoundOnWideSeven::Z(WideThree::C),
  ]);
  test_type::<CompoundWideOnSeven>(&vec![
    CompoundWideOnSeven::X(Three::A),
    CompoundWideOnSeven::X(Three::B),
    CompoundWideOnSeven::X(Three::C),
    CompoundWideOnSeven::Y,
    CompoundWideOnSeven::Z(Three::A),
    CompoundWideOnSeven::Z(Three::B),
    CompoundWideOnSeven::Z(Three::C),
  ]);
}

#[test]
fn test_sixteen() {
  test_type::<Sixteen>(&vec![
    Sixteen::A,
    Sixteen::B,
    Sixteen::C,
    Sixteen::D,
    Sixteen::E,
    Sixteen::F,
    Sixteen::G,
    Sixteen::H,
    Sixteen::I,
    Sixteen::J,
    Sixteen::K,
    Sixteen::L,
    Sixteen::M,
    Sixteen::N,
    Sixteen::O,
    Sixteen::P,
  ]);
}

#[test]
fn test_seventeen() {
  test_type::<Seventeen>(&vec![
    Seventeen::A,
    Seventeen::B,
    Seventeen::C,
    Seventeen::D,
    Seventeen::E,
    Seventeen::F,
    Seventeen::G,
    Seventeen::H,
    Seventeen::I,
    Seventeen::J,
    Seventeen::K,
    Seventeen::L,
    Seventeen::M,
    Seventeen::N,
    Seventeen::O,
    Seventeen::P,
    Seventeen::Q,
  ]);
}

#[test]
fn test_three_hundred() {
  assert_eq!(ThreeHundred::SIZE, 300);
}