• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /// Represents an non standard ethertype. These are defined in the Linux
2 /// kernel with ids under 1500 so they don't clash with the standard ones.
3 ///
4 /// You can convert any valid `u16` value to an `LinuxNonstandardEtherType` and
5 /// the other way around.
6 ///
7 /// ```
8 /// use etherparse::LinuxNonstandardEtherType;
9 ///
10 /// // Convert to LinuxNonstandardEtherType using the from & into trait
11 /// let link_type: LinuxNonstandardEtherType = 0x0001.try_into().unwrap();
12 /// assert_eq!(LinuxNonstandardEtherType::N802_3, link_type);
13 ///
14 /// // convert to u16 using the from & into trait
15 /// let num: u16 = LinuxNonstandardEtherType::N802_3.try_into().unwrap();
16 /// assert_eq!(0x0001, num);
17 /// ```
18 #[derive(Clone, Copy, Eq, PartialEq)]
19 pub struct LinuxNonstandardEtherType(pub(crate) u16);
20 
21 impl LinuxNonstandardEtherType {
22     // Numbers sourced from https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/plain/include/uapi/linux/if_ether.h?id=e33c4963bf536900f917fb65a687724d5539bc21
23 
24     pub const N802_3: LinuxNonstandardEtherType = Self(0x0001);
25     pub const AX25: LinuxNonstandardEtherType = Self(0x0002);
26     pub const ALL: LinuxNonstandardEtherType = Self(0x0003);
27     pub const N802_2: LinuxNonstandardEtherType = Self(0x0004);
28     pub const SNAP: LinuxNonstandardEtherType = Self(0x0005);
29     pub const DDCMP: LinuxNonstandardEtherType = Self(0x0006);
30     pub const WAN_PPP: LinuxNonstandardEtherType = Self(0x0007);
31     pub const PPP_MP: LinuxNonstandardEtherType = Self(0x0008);
32     pub const LOCALTALK: LinuxNonstandardEtherType = Self(0x0009);
33     pub const CAN: LinuxNonstandardEtherType = Self(0x000C);
34     pub const CANFD: LinuxNonstandardEtherType = Self(0x000D);
35     pub const CANXL: LinuxNonstandardEtherType = Self(0x000E);
36     pub const PPPTALK: LinuxNonstandardEtherType = Self(0x0010);
37     pub const TR_802_2: LinuxNonstandardEtherType = Self(0x0011);
38     pub const MOBITEX: LinuxNonstandardEtherType = Self(0x0015);
39     pub const CONTROL: LinuxNonstandardEtherType = Self(0x0016);
40     pub const IRDA: LinuxNonstandardEtherType = Self(0x0017);
41     pub const ECONET: LinuxNonstandardEtherType = Self(0x0018);
42     pub const HDLC: LinuxNonstandardEtherType = Self(0x0019);
43     pub const ARCNET: LinuxNonstandardEtherType = Self(0x001A);
44     pub const DSA: LinuxNonstandardEtherType = Self(0x001B);
45     pub const TRAILER: LinuxNonstandardEtherType = Self(0x001C);
46     pub const PHONET: LinuxNonstandardEtherType = Self(0x00F5);
47     pub const IEEE802154: LinuxNonstandardEtherType = Self(0x00F6);
48     pub const CAIF: LinuxNonstandardEtherType = Self(0x00F7);
49     pub const XDSA: LinuxNonstandardEtherType = Self(0x00F8);
50     pub const MAP: LinuxNonstandardEtherType = Self(0x00F9);
51     pub const MCTP: LinuxNonstandardEtherType = Self(0x00FA);
52 }
53 
54 impl Default for LinuxNonstandardEtherType {
default() -> Self55     fn default() -> Self {
56         Self::N802_3
57     }
58 }
59 
60 impl TryFrom<u16> for LinuxNonstandardEtherType {
61     type Error = ();
62 
try_from(value: u16) -> Result<Self, Self::Error>63     fn try_from(value: u16) -> Result<Self, Self::Error> {
64         match value {
65             0x0000 => Err(()),
66             0x0001 => Ok(LinuxNonstandardEtherType::N802_3),
67             0x0002 => Ok(LinuxNonstandardEtherType::AX25),
68             0x0003 => Ok(LinuxNonstandardEtherType::ALL),
69             0x0004 => Ok(LinuxNonstandardEtherType::N802_2),
70             0x0005 => Ok(LinuxNonstandardEtherType::SNAP),
71             0x0006 => Ok(LinuxNonstandardEtherType::DDCMP),
72             0x0007 => Ok(LinuxNonstandardEtherType::WAN_PPP),
73             0x0008 => Ok(LinuxNonstandardEtherType::PPP_MP),
74             0x0009 => Ok(LinuxNonstandardEtherType::LOCALTALK),
75             0x000A..=0x000B => Err(()),
76             0x000C => Ok(LinuxNonstandardEtherType::CAN),
77             0x000D => Ok(LinuxNonstandardEtherType::CANFD),
78             0x000E => Ok(LinuxNonstandardEtherType::CANXL),
79             0x000F => Err(()),
80             0x0010 => Ok(LinuxNonstandardEtherType::PPPTALK),
81             0x0011 => Ok(LinuxNonstandardEtherType::TR_802_2),
82             0x0012..=0x0014 => Err(()),
83             0x0015 => Ok(LinuxNonstandardEtherType::MOBITEX),
84             0x0016 => Ok(LinuxNonstandardEtherType::CONTROL),
85             0x0017 => Ok(LinuxNonstandardEtherType::IRDA),
86             0x0018 => Ok(LinuxNonstandardEtherType::ECONET),
87             0x0019 => Ok(LinuxNonstandardEtherType::HDLC),
88             0x001A => Ok(LinuxNonstandardEtherType::ARCNET),
89             0x001B => Ok(LinuxNonstandardEtherType::DSA),
90             0x001C => Ok(LinuxNonstandardEtherType::TRAILER),
91             0x001D..=0x00F4 => Err(()),
92             0x00F5 => Ok(LinuxNonstandardEtherType::PHONET),
93             0x00F6 => Ok(LinuxNonstandardEtherType::IEEE802154),
94             0x00F7 => Ok(LinuxNonstandardEtherType::CAIF),
95             0x00F8 => Ok(LinuxNonstandardEtherType::XDSA),
96             0x00F9 => Ok(LinuxNonstandardEtherType::MAP),
97             0x00FA => Ok(LinuxNonstandardEtherType::MCTP),
98             0x00FB..=u16::MAX => Err(()),
99         }
100     }
101 }
102 
103 impl From<LinuxNonstandardEtherType> for u16 {
104     #[inline]
from(val: LinuxNonstandardEtherType) -> Self105     fn from(val: LinuxNonstandardEtherType) -> Self {
106         val.0
107     }
108 }
109 
110 impl core::fmt::Debug for LinuxNonstandardEtherType {
111     // Descriptions sourced from https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/plain/include/uapi/linux/if_ether.h?id=e33c4963bf536900f917fb65a687724d5539bc21
112 
fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result113     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
114         match *self {
115             LinuxNonstandardEtherType(0x0000) => write!(f, "{:#06X} (Unknown)", self.0),
116             LinuxNonstandardEtherType::N802_3 => {
117                 write!(f, "{:#06X} (Dummy type for 802.3 frames)", self.0)
118             }
119             LinuxNonstandardEtherType::AX25 => {
120                 write!(f, "{:#06X} (Dummy protocol id for AX.25)", self.0)
121             }
122             LinuxNonstandardEtherType::ALL => write!(f, "{:#06X} (Every packet)", self.0),
123             LinuxNonstandardEtherType::N802_2 => write!(f, "{:#06X} (802.2 frames)", self.0),
124             LinuxNonstandardEtherType::SNAP => write!(f, "{:#06X} (SNAP: Internal only)", self.0),
125             LinuxNonstandardEtherType::DDCMP => {
126                 write!(f, "{:#06X} (DEC DDCMP: Internal only)", self.0)
127             }
128             LinuxNonstandardEtherType::WAN_PPP => {
129                 write!(f, "{:#06X} (Dummy type for WAN PPP frames)", self.0)
130             }
131             LinuxNonstandardEtherType::PPP_MP => {
132                 write!(f, "{:#06X} (Dummy type for PPP MP frames)", self.0)
133             }
134             LinuxNonstandardEtherType::LOCALTALK => {
135                 write!(f, "{:#06X} (Localtalk pseudo type)", self.0)
136             }
137             LinuxNonstandardEtherType(0x000A..=0x000B) => write!(f, "{:#06X} (Unknown)", self.0),
138             LinuxNonstandardEtherType::CAN => {
139                 write!(f, "{:#06X} (CAN: Controller Area Network)", self.0)
140             }
141             LinuxNonstandardEtherType::CANFD => {
142                 write!(f, "{:#06X} (CANFD: CAN flexible data rate)", self.0)
143             }
144             LinuxNonstandardEtherType::CANXL => {
145                 write!(f, "{:#06X} (CANXL: eXtended frame Length)", self.0)
146             }
147             LinuxNonstandardEtherType(0x000F) => write!(f, "{:#06X} (Unknown)", self.0),
148             LinuxNonstandardEtherType::PPPTALK => {
149                 write!(f, "{:#06X} (Dummy type for Atalk over PPP)", self.0)
150             }
151             LinuxNonstandardEtherType::TR_802_2 => write!(f, "{:#06X} (802.2 frames)", self.0),
152             LinuxNonstandardEtherType(0x0012..=0x0014) => write!(f, "{:#06X} (Unknown)", self.0),
153             LinuxNonstandardEtherType::MOBITEX => write!(f, "{:#06X} (Mobitex)", self.0),
154             LinuxNonstandardEtherType::CONTROL => {
155                 write!(f, "{:#06X} (Card specific control frames)", self.0)
156             }
157             LinuxNonstandardEtherType::IRDA => write!(f, "{:#06X} (Linux-IrDA)", self.0),
158             LinuxNonstandardEtherType::ECONET => write!(f, "{:#06X} (Acorn Econet)", self.0),
159             LinuxNonstandardEtherType::HDLC => write!(f, "{:#06X} (HDLC frames)", self.0),
160             LinuxNonstandardEtherType::ARCNET => write!(f, "{:#06X} (1A for ArcNet)", self.0),
161             LinuxNonstandardEtherType::DSA => {
162                 write!(f, "{:#06X} (Distributed Switch Arch)", self.0)
163             }
164             LinuxNonstandardEtherType::TRAILER => {
165                 write!(f, "{:#06X} (Trailer switch tagging)", self.0)
166             }
167             LinuxNonstandardEtherType(0x001D..=0x00F4) => write!(f, "{:#06X} (Unknown)", self.0),
168             LinuxNonstandardEtherType::PHONET => write!(f, "{:#06X} (Nokia Phonet frame)", self.0),
169             LinuxNonstandardEtherType::IEEE802154 => {
170                 write!(f, "{:#06X} (IEEE802.15.4 frame)", self.0)
171             }
172             LinuxNonstandardEtherType::CAIF => {
173                 write!(f, "{:#06X} (ST-Ericsson CAIF protocol)", self.0)
174             }
175             LinuxNonstandardEtherType::XDSA => {
176                 write!(f, "{:#06X} (Multiplexed DSA protocol)", self.0)
177             }
178             LinuxNonstandardEtherType::MAP => write!(
179                 f,
180                 "{:#06X} (Qualcomm multiplexing and aggregation protocol)",
181                 self.0
182             ),
183             LinuxNonstandardEtherType::MCTP => write!(
184                 f,
185                 "{:#06X} (Management component transport protocol packets)",
186                 self.0
187             ),
188             LinuxNonstandardEtherType(0x00FB..=u16::MAX) => write!(f, "{:#06X} (Unknown)", self.0),
189         }
190     }
191 }
192 
193 #[cfg(test)]
194 mod test {
195     use super::*;
196     use alloc::format;
197 
198     #[test]
to_u16()199     fn to_u16() {
200         assert_eq!(0x0001, u16::from(LinuxNonstandardEtherType::N802_3));
201         assert_eq!(0x0002, u16::from(LinuxNonstandardEtherType::AX25));
202         assert_eq!(0x0003, u16::from(LinuxNonstandardEtherType::ALL));
203         assert_eq!(0x0004, u16::from(LinuxNonstandardEtherType::N802_2));
204         assert_eq!(0x0005, u16::from(LinuxNonstandardEtherType::SNAP));
205         assert_eq!(0x0006, u16::from(LinuxNonstandardEtherType::DDCMP));
206         assert_eq!(0x0007, u16::from(LinuxNonstandardEtherType::WAN_PPP));
207         assert_eq!(0x0008, u16::from(LinuxNonstandardEtherType::PPP_MP));
208         assert_eq!(0x0009, u16::from(LinuxNonstandardEtherType::LOCALTALK));
209         assert_eq!(0x000C, u16::from(LinuxNonstandardEtherType::CAN));
210         assert_eq!(0x000D, u16::from(LinuxNonstandardEtherType::CANFD));
211         assert_eq!(0x000E, u16::from(LinuxNonstandardEtherType::CANXL));
212         assert_eq!(0x0010, u16::from(LinuxNonstandardEtherType::PPPTALK));
213         assert_eq!(0x0011, u16::from(LinuxNonstandardEtherType::TR_802_2));
214         assert_eq!(0x0015, u16::from(LinuxNonstandardEtherType::MOBITEX));
215         assert_eq!(0x0016, u16::from(LinuxNonstandardEtherType::CONTROL));
216         assert_eq!(0x0017, u16::from(LinuxNonstandardEtherType::IRDA));
217         assert_eq!(0x0018, u16::from(LinuxNonstandardEtherType::ECONET));
218         assert_eq!(0x0019, u16::from(LinuxNonstandardEtherType::HDLC));
219         assert_eq!(0x001A, u16::from(LinuxNonstandardEtherType::ARCNET));
220         assert_eq!(0x001B, u16::from(LinuxNonstandardEtherType::DSA));
221         assert_eq!(0x001C, u16::from(LinuxNonstandardEtherType::TRAILER));
222         assert_eq!(0x00F5, u16::from(LinuxNonstandardEtherType::PHONET));
223         assert_eq!(0x00F6, u16::from(LinuxNonstandardEtherType::IEEE802154));
224         assert_eq!(0x00F7, u16::from(LinuxNonstandardEtherType::CAIF));
225         assert_eq!(0x00F8, u16::from(LinuxNonstandardEtherType::XDSA));
226         assert_eq!(0x00F9, u16::from(LinuxNonstandardEtherType::MAP));
227         assert_eq!(0x00FA, u16::from(LinuxNonstandardEtherType::MCTP));
228     }
229 
230     #[test]
try_from_u16()231     fn try_from_u16() {
232         assert_eq!(
233             LinuxNonstandardEtherType::try_from(0x0001),
234             Ok(LinuxNonstandardEtherType::N802_3)
235         );
236         assert_eq!(
237             LinuxNonstandardEtherType::try_from(0x0002),
238             Ok(LinuxNonstandardEtherType::AX25)
239         );
240         assert_eq!(
241             LinuxNonstandardEtherType::try_from(0x0003),
242             Ok(LinuxNonstandardEtherType::ALL)
243         );
244         assert_eq!(
245             LinuxNonstandardEtherType::try_from(0x0004),
246             Ok(LinuxNonstandardEtherType::N802_2)
247         );
248         assert_eq!(
249             LinuxNonstandardEtherType::try_from(0x0005),
250             Ok(LinuxNonstandardEtherType::SNAP)
251         );
252         assert_eq!(
253             LinuxNonstandardEtherType::try_from(0x0006),
254             Ok(LinuxNonstandardEtherType::DDCMP)
255         );
256         assert_eq!(
257             LinuxNonstandardEtherType::try_from(0x0007),
258             Ok(LinuxNonstandardEtherType::WAN_PPP)
259         );
260         assert_eq!(
261             LinuxNonstandardEtherType::try_from(0x0008),
262             Ok(LinuxNonstandardEtherType::PPP_MP)
263         );
264         assert_eq!(
265             LinuxNonstandardEtherType::try_from(0x0009),
266             Ok(LinuxNonstandardEtherType::LOCALTALK)
267         );
268         /* 0x00A..=0x00B */
269         assert_eq!(
270             LinuxNonstandardEtherType::try_from(0x000C),
271             Ok(LinuxNonstandardEtherType::CAN)
272         );
273         assert_eq!(
274             LinuxNonstandardEtherType::try_from(0x000D),
275             Ok(LinuxNonstandardEtherType::CANFD)
276         );
277         assert_eq!(
278             LinuxNonstandardEtherType::try_from(0x000E),
279             Ok(LinuxNonstandardEtherType::CANXL)
280         );
281         assert_eq!(
282             LinuxNonstandardEtherType::try_from(0x0010),
283             Ok(LinuxNonstandardEtherType::PPPTALK)
284         );
285         assert_eq!(
286             LinuxNonstandardEtherType::try_from(0x0011),
287             Ok(LinuxNonstandardEtherType::TR_802_2)
288         );
289         /* 0x0012..=0x0014 */
290         assert_eq!(
291             LinuxNonstandardEtherType::try_from(0x0015),
292             Ok(LinuxNonstandardEtherType::MOBITEX)
293         );
294         assert_eq!(
295             LinuxNonstandardEtherType::try_from(0x0016),
296             Ok(LinuxNonstandardEtherType::CONTROL)
297         );
298         assert_eq!(
299             LinuxNonstandardEtherType::try_from(0x0017),
300             Ok(LinuxNonstandardEtherType::IRDA)
301         );
302         assert_eq!(
303             LinuxNonstandardEtherType::try_from(0x0018),
304             Ok(LinuxNonstandardEtherType::ECONET)
305         );
306         assert_eq!(
307             LinuxNonstandardEtherType::try_from(0x0019),
308             Ok(LinuxNonstandardEtherType::HDLC)
309         );
310         assert_eq!(
311             LinuxNonstandardEtherType::try_from(0x001A),
312             Ok(LinuxNonstandardEtherType::ARCNET)
313         );
314         assert_eq!(
315             LinuxNonstandardEtherType::try_from(0x001B),
316             Ok(LinuxNonstandardEtherType::DSA)
317         );
318         assert_eq!(
319             LinuxNonstandardEtherType::try_from(0x001C),
320             Ok(LinuxNonstandardEtherType::TRAILER)
321         );
322         /* 0x001D..=0x00F4 */
323         assert_eq!(
324             LinuxNonstandardEtherType::try_from(0x00F5),
325             Ok(LinuxNonstandardEtherType::PHONET)
326         );
327         assert_eq!(
328             LinuxNonstandardEtherType::try_from(0x00F6),
329             Ok(LinuxNonstandardEtherType::IEEE802154)
330         );
331         assert_eq!(
332             LinuxNonstandardEtherType::try_from(0x00F7),
333             Ok(LinuxNonstandardEtherType::CAIF)
334         );
335         assert_eq!(
336             LinuxNonstandardEtherType::try_from(0x00F8),
337             Ok(LinuxNonstandardEtherType::XDSA)
338         );
339         assert_eq!(
340             LinuxNonstandardEtherType::try_from(0x00F9),
341             Ok(LinuxNonstandardEtherType::MAP)
342         );
343         assert_eq!(
344             LinuxNonstandardEtherType::try_from(0x00FA),
345             Ok(LinuxNonstandardEtherType::MCTP)
346         );
347         /* 0x00FB..=u16::MAX */
348     }
349 
350     #[test]
dbg()351     fn dbg() {
352         let pairs = &[
353             (
354                 LinuxNonstandardEtherType::N802_3,
355                 "0x0001 (Dummy type for 802.3 frames)",
356             ),
357             (
358                 LinuxNonstandardEtherType::AX25,
359                 "0x0002 (Dummy protocol id for AX.25)",
360             ),
361             (LinuxNonstandardEtherType::ALL, "0x0003 (Every packet)"),
362             (LinuxNonstandardEtherType::N802_2, "0x0004 (802.2 frames)"),
363             (
364                 LinuxNonstandardEtherType::SNAP,
365                 "0x0005 (SNAP: Internal only)",
366             ),
367             (
368                 LinuxNonstandardEtherType::DDCMP,
369                 "0x0006 (DEC DDCMP: Internal only)",
370             ),
371             (
372                 LinuxNonstandardEtherType::WAN_PPP,
373                 "0x0007 (Dummy type for WAN PPP frames)",
374             ),
375             (
376                 LinuxNonstandardEtherType::PPP_MP,
377                 "0x0008 (Dummy type for PPP MP frames)",
378             ),
379             (
380                 LinuxNonstandardEtherType::LOCALTALK,
381                 "0x0009 (Localtalk pseudo type)",
382             ),
383             (
384                 LinuxNonstandardEtherType::CAN,
385                 "0x000C (CAN: Controller Area Network)",
386             ),
387             (
388                 LinuxNonstandardEtherType::CANFD,
389                 "0x000D (CANFD: CAN flexible data rate)",
390             ),
391             (
392                 LinuxNonstandardEtherType::CANXL,
393                 "0x000E (CANXL: eXtended frame Length)",
394             ),
395             (
396                 LinuxNonstandardEtherType::PPPTALK,
397                 "0x0010 (Dummy type for Atalk over PPP)",
398             ),
399             (LinuxNonstandardEtherType::TR_802_2, "0x0011 (802.2 frames)"),
400             (LinuxNonstandardEtherType::MOBITEX, "0x0015 (Mobitex)"),
401             (
402                 LinuxNonstandardEtherType::CONTROL,
403                 "0x0016 (Card specific control frames)",
404             ),
405             (LinuxNonstandardEtherType::IRDA, "0x0017 (Linux-IrDA)"),
406             (LinuxNonstandardEtherType::ECONET, "0x0018 (Acorn Econet)"),
407             (LinuxNonstandardEtherType::HDLC, "0x0019 (HDLC frames)"),
408             (LinuxNonstandardEtherType::ARCNET, "0x001A (1A for ArcNet)"),
409             (
410                 LinuxNonstandardEtherType::DSA,
411                 "0x001B (Distributed Switch Arch)",
412             ),
413             (
414                 LinuxNonstandardEtherType::TRAILER,
415                 "0x001C (Trailer switch tagging)",
416             ),
417             (
418                 LinuxNonstandardEtherType::PHONET,
419                 "0x00F5 (Nokia Phonet frame)",
420             ),
421             (
422                 LinuxNonstandardEtherType::IEEE802154,
423                 "0x00F6 (IEEE802.15.4 frame)",
424             ),
425             (
426                 LinuxNonstandardEtherType::CAIF,
427                 "0x00F7 (ST-Ericsson CAIF protocol)",
428             ),
429             (
430                 LinuxNonstandardEtherType::XDSA,
431                 "0x00F8 (Multiplexed DSA protocol)",
432             ),
433             (
434                 LinuxNonstandardEtherType::MAP,
435                 "0x00F9 (Qualcomm multiplexing and aggregation protocol)",
436             ),
437             (
438                 LinuxNonstandardEtherType::MCTP,
439                 "0x00FA (Management component transport protocol packets)",
440             ),
441         ];
442 
443         for (ether_type, str_value) in pairs {
444             assert_eq!(str_value, &format!("{:?}", ether_type));
445         }
446     }
447 
448     #[test]
default()449     fn default() {
450         let value: LinuxNonstandardEtherType = Default::default();
451         assert_eq!(LinuxNonstandardEtherType::N802_3, value);
452     }
453 
454     #[test]
clone_eq()455     fn clone_eq() {
456         let values = &[
457             LinuxNonstandardEtherType::N802_3,
458             LinuxNonstandardEtherType::AX25,
459             LinuxNonstandardEtherType::ALL,
460             LinuxNonstandardEtherType::N802_2,
461             LinuxNonstandardEtherType::SNAP,
462             LinuxNonstandardEtherType::DDCMP,
463             LinuxNonstandardEtherType::WAN_PPP,
464             LinuxNonstandardEtherType::PPP_MP,
465             LinuxNonstandardEtherType::LOCALTALK,
466             LinuxNonstandardEtherType::CAN,
467             LinuxNonstandardEtherType::CANFD,
468             LinuxNonstandardEtherType::CANXL,
469             LinuxNonstandardEtherType::PPPTALK,
470             LinuxNonstandardEtherType::TR_802_2,
471             LinuxNonstandardEtherType::MOBITEX,
472             LinuxNonstandardEtherType::CONTROL,
473             LinuxNonstandardEtherType::IRDA,
474             LinuxNonstandardEtherType::ECONET,
475             LinuxNonstandardEtherType::HDLC,
476             LinuxNonstandardEtherType::ARCNET,
477             LinuxNonstandardEtherType::DSA,
478             LinuxNonstandardEtherType::TRAILER,
479             LinuxNonstandardEtherType::PHONET,
480             LinuxNonstandardEtherType::IEEE802154,
481             LinuxNonstandardEtherType::CAIF,
482             LinuxNonstandardEtherType::XDSA,
483             LinuxNonstandardEtherType::MAP,
484             LinuxNonstandardEtherType::MCTP,
485         ];
486 
487         // clone
488         for v in values {
489             assert_eq!(v, &v.clone());
490         }
491 
492         // eq
493         for (a_pos, a) in values.iter().enumerate() {
494             for (b_pos, b) in values.iter().enumerate() {
495                 assert_eq!(a_pos == b_pos, a == b);
496                 assert_eq!(a_pos != b_pos, a != b);
497             }
498         }
499     }
500 }
501