1 use crate::*;
2 
3 /// A slice containing a single or double vlan header.
4 #[derive(Clone, Debug, Eq, PartialEq)]
5 pub enum VlanSlice<'a> {
6     SingleVlan(SingleVlanSlice<'a>),
7     DoubleVlan(DoubleVlanSlice<'a>),
8 }
9 
10 impl<'a> VlanSlice<'a> {
11     /// Decode all the fields and copy the results to a VlanHeader struct
12     #[inline]
to_header(&self) -> VlanHeader13     pub fn to_header(&self) -> VlanHeader {
14         use crate::VlanHeader::*;
15         use crate::VlanSlice::*;
16         match self {
17             SingleVlan(value) => Single(value.to_header()),
18             DoubleVlan(value) => Double(value.to_header()),
19         }
20     }
21 
22     #[inline]
payload(&self) -> EtherPayloadSlice<'a>23     pub fn payload(&self) -> EtherPayloadSlice<'a> {
24         match self {
25             VlanSlice::SingleVlan(s) => s.payload(),
26             VlanSlice::DoubleVlan(d) => d.payload(),
27         }
28     }
29 }
30 
31 #[cfg(test)]
32 mod test {
33     use crate::{test_gens::*, *};
34     use alloc::format;
35     use proptest::prelude::*;
36 
37     proptest! {
38         #[test]
39         fn to_header(
40             single in vlan_single_any(),
41             double in vlan_double_any(),
42         ) {
43             // single
44             {
45                 let raw = single.to_bytes();
46                 let slice = VlanSlice::SingleVlan(
47                     SingleVlanSlice::from_slice(&raw).unwrap()
48                 );
49                 assert_eq!(
50                     slice.to_header(),
51                     VlanHeader::Single(single)
52                 );
53             }
54 
55             // double
56             {
57                 let raw = double.to_bytes();
58                 let slice = VlanSlice::DoubleVlan(
59                     DoubleVlanSlice::from_slice(&raw).unwrap()
60                 );
61                 assert_eq!(
62                     slice.to_header(),
63                     VlanHeader::Double(double)
64                 );
65             }
66         }
67     }
68 
69     proptest! {
70         #[test]
71         fn debug(
72             single in vlan_single_any(),
73             double in vlan_double_any(),
74         ) {
75             // single
76             {
77                 let raw = single.to_bytes();
78                 let s = SingleVlanSlice::from_slice(&raw).unwrap();
79                 assert_eq!(
80                     format!("{:?}", VlanSlice::SingleVlan(s.clone())),
81                     format!("SingleVlan({:?})", s)
82                 );
83             }
84 
85             // double
86             {
87                 let raw = double.to_bytes();
88                 let d = DoubleVlanSlice::from_slice(&raw).unwrap();
89                 assert_eq!(
90                     format!("{:?}", VlanSlice::DoubleVlan(d.clone())),
91                     format!("DoubleVlan({:?})", d)
92                 );
93             }
94         }
95     }
96 
97     proptest! {
98         #[test]
99         fn clone_eq(
100             single in vlan_single_any(),
101             double in vlan_double_any(),
102         ) {
103             // single
104             {
105                 let raw = single.to_bytes();
106                 let s = VlanSlice::SingleVlan(
107                     SingleVlanSlice::from_slice(&raw).unwrap()
108                 );
109                 assert_eq!(s.clone(), s);
110             }
111 
112             // double
113             {
114                 let raw = double.to_bytes();
115                 let d = VlanSlice::DoubleVlan(
116                     DoubleVlanSlice::from_slice(&raw).unwrap()
117                 );
118                 assert_eq!(d.clone(), d);
119             }
120         }
121     }
122 }
123