Skip to content

Commit 097b62c

Browse files
daniel-nolanddaniel-noland
committed
Experimental tests
1 parent 85dce1f commit 097b62c

File tree

1 file changed

+273
-12
lines changed

1 file changed

+273
-12
lines changed

‎src/tc/actions/tunnel_key.rs‎

Lines changed: 273 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -39,9 +39,9 @@ impl TcActionTunnelKey {
3939
#[repr(u32)]
4040
pub enum TcTunnelKeyAction {
4141
/// Set the tunnel key (encap).
42-
Set,
42+
Set = TCA_TUNNEL_KEY_ACT_SET,
4343
/// Release the tunnel key (decap).
44-
Release,
44+
Release = TCA_TUNNEL_KEY_ACT_RELEASE,
4545
/// Other action unknown at the time of writing.
4646
Other(u32),
4747
}
@@ -51,7 +51,7 @@ impl From<u32> for TcTunnelKeyAction {
5151
match value {
5252
TCA_TUNNEL_KEY_ACT_SET => Self::Set,
5353
TCA_TUNNEL_KEY_ACT_RELEASE => Self::Release,
54-
x => Self::Other(x),
54+
_ => Self::Other(value),
5555
}
5656
}
5757
}
@@ -117,16 +117,14 @@ impl<'a, T: AsRef<[u8]> + 'a + ?Sized> Parseable<TunnelParamsBuffer<&'a T>>
117117
}
118118
}
119119

120-
pub type UdpPort = u16;
121-
pub type Tos = u8;
122-
pub type Ttl = u8;
123-
124120
pub type TimeCode = u64;
125121

126-
#[derive(Debug, PartialEq, Eq, Clone)]
122+
/// Tracks times in which a filter was installed, last used, expires, and first
123+
/// used.
124+
#[derive(Debug, PartialEq, Eq, Clone, Copy, Default, Ord, PartialOrd, Hash)]
127125
#[non_exhaustive]
128126
pub struct Tcft {
129-
install: TimeCode, // time codes in seconds?
127+
install: TimeCode,
130128
last_use: TimeCode,
131129
expires: TimeCode,
132130
first_use: TimeCode,
@@ -185,15 +183,15 @@ pub enum TcActionTunnelKeyOption {
185183
/// Encapsulation IPv6 source address.
186184
KeyEncIpv6Src(Ipv6Addr),
187185
/// Encapsulation destination port.
188-
KeyEncDstPort(UdpPort),
186+
KeyEncDstPort(u16),
189187
/// If true, do not compute the checksum of the encapsulating packet.
190188
KeyNoChecksum(bool),
191189
/// Encapsulation options.
192190
KeyEncOpts(Options),
193191
/// Encapsulation TOS.
194-
KeyEncTos(Tos),
192+
KeyEncTos(u8),
195193
/// Encapsulation TTL.
196-
KeyEncTtl(Ttl),
194+
KeyEncTtl(u8),
197195
/// Flag which indicated that the "do not fragment" bit should be set in
198196
/// the outer header.
199197
KeyNoFrag,
@@ -362,3 +360,266 @@ fn parse_ipv6(data: &[u8]) -> Result<Ipv6Addr, DecodeError> {
362360
)))
363361
}
364362
}
363+
364+
#[cfg(test)]
365+
mod tests {
366+
use super::*;
367+
use crate::tc::TcActionType;
368+
369+
#[test]
370+
fn u32_from_tunnel_key_action_is_faithful_to_spec() {
371+
assert_eq!(TCA_TUNNEL_KEY_ACT_SET, u32::from(TcTunnelKeyAction::Set));
372+
assert_eq!(
373+
TCA_TUNNEL_KEY_ACT_RELEASE,
374+
u32::from(TcTunnelKeyAction::Release)
375+
);
376+
let arbitrary_value = 42;
377+
assert_eq!(
378+
arbitrary_value,
379+
u32::from(TcTunnelKeyAction::Other(arbitrary_value))
380+
);
381+
}
382+
383+
#[test]
384+
fn tunnel_key_action_to_from_u32_is_identity() {
385+
assert_eq!(
386+
TcTunnelKeyAction::Set,
387+
TcTunnelKeyAction::from(u32::from(TcTunnelKeyAction::Set))
388+
);
389+
assert_eq!(
390+
TcTunnelKeyAction::Release,
391+
TcTunnelKeyAction::from(u32::from(TcTunnelKeyAction::Release))
392+
);
393+
let arbitrary_value = 42;
394+
assert_eq!(
395+
TcTunnelKeyAction::Other(arbitrary_value),
396+
TcTunnelKeyAction::from(u32::from(TcTunnelKeyAction::Other(
397+
arbitrary_value
398+
)))
399+
);
400+
}
401+
402+
#[test]
403+
fn tunnel_params_buffer_length_is_as_specified() {
404+
let params = TcTunnelParams::default();
405+
assert_eq!(TUNNEL_PARAMS_BUF_LEN, params.buffer_len());
406+
}
407+
408+
#[test]
409+
fn default_tunnel_params_emit_and_parse_is_identity() {
410+
let params = TcTunnelParams::default();
411+
let mut bytes = vec![0; params.buffer_len()];
412+
params.emit(&mut bytes);
413+
let parsed = TcTunnelParams::parse(
414+
&TunnelParamsBuffer::new_checked(&bytes).unwrap(),
415+
)
416+
.unwrap();
417+
assert_eq!(params, parsed);
418+
}
419+
420+
#[test]
421+
fn arbitrary_tunnel_params_emit_and_parse_is_identity() {
422+
let params = TcTunnelParams {
423+
generic: TcActionGeneric {
424+
action: TcActionType::Queued,
425+
bindcnt: 2,
426+
capab: 3,
427+
index: 4,
428+
refcnt: 5,
429+
},
430+
tunnel_key_action: TcTunnelKeyAction::Release,
431+
};
432+
let mut bytes = vec![0; params.buffer_len()];
433+
params.emit(&mut bytes);
434+
let parsed =
435+
TcTunnelParams::parse(&TunnelParamsBuffer::new(&bytes)).unwrap();
436+
assert_eq!(params, parsed);
437+
}
438+
439+
#[test]
440+
fn tcft_buffer_length_is_as_specified() {
441+
let tcft = Tcft::default();
442+
assert_eq!(TCFT_BUF_LEN, tcft.buffer_len());
443+
}
444+
445+
#[test]
446+
fn default_tcft_emit_and_parse_is_identity() {
447+
let tcft = Tcft::default();
448+
let mut bytes = vec![0; tcft.buffer_len()];
449+
tcft.emit(&mut bytes);
450+
let parsed =
451+
Tcft::parse(&TcftBuffer::new_checked(&bytes).unwrap()).unwrap();
452+
assert_eq!(tcft, parsed);
453+
}
454+
455+
#[test]
456+
fn arbitrary_tcft_emit_and_parse_is_identity() {
457+
let tcft = Tcft {
458+
install: 1,
459+
last_use: 2,
460+
expires: 3,
461+
first_use: 4,
462+
};
463+
let mut bytes = vec![0; tcft.buffer_len()];
464+
tcft.emit(&mut bytes);
465+
let parsed = Tcft::parse(&TcftBuffer::new(&bytes)).unwrap();
466+
assert_eq!(tcft, parsed);
467+
}
468+
469+
#[test]
470+
fn tunnel_key_option_value_length_is_as_specified() {
471+
let option =
472+
TcActionTunnelKeyOption::KeyEncKeyId(EncKeyId::new_unchecked(1));
473+
assert_eq!(4, option.value_len());
474+
}
475+
476+
#[test]
477+
fn tunnel_key_option_emit_and_parse_is_identity_enc_key_id() {
478+
let option =
479+
TcActionTunnelKeyOption::KeyEncKeyId(EncKeyId::new_unchecked(1));
480+
let mut bytes = vec![0; option.buffer_len()];
481+
option.emit(&mut bytes);
482+
let parsed =
483+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
484+
assert_eq!(option, parsed);
485+
}
486+
487+
#[test]
488+
fn tunnel_key_option_emit_and_parse_is_identity_enc_ipv4_dst() {
489+
let option =
490+
TcActionTunnelKeyOption::KeyEncIpv4Dst(Ipv4Addr::new(1, 2, 3, 4));
491+
let mut bytes = vec![0; option.buffer_len()];
492+
option.emit(&mut bytes);
493+
let parsed =
494+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
495+
assert_eq!(option, parsed);
496+
}
497+
498+
#[test]
499+
fn tunnel_key_option_emit_and_parse_is_identity_enc_ipv4_src() {
500+
let option =
501+
TcActionTunnelKeyOption::KeyEncIpv4Src(Ipv4Addr::new(1, 2, 3, 4));
502+
let mut bytes = vec![0; option.buffer_len()];
503+
option.emit(&mut bytes);
504+
let parsed =
505+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
506+
assert_eq!(option, parsed);
507+
}
508+
509+
#[test]
510+
fn tunnel_key_option_emit_and_parse_is_identity_enc_ipv6_dst() {
511+
let option = TcActionTunnelKeyOption::KeyEncIpv6Dst(Ipv6Addr::new(
512+
0x2001, 0xdb8, 0, 0, 0, 0, 0, 1,
513+
));
514+
let mut bytes = vec![0; option.buffer_len()];
515+
option.emit(&mut bytes);
516+
let parsed =
517+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
518+
assert_eq!(option, parsed);
519+
}
520+
521+
#[test]
522+
fn tunnel_key_option_emit_and_parse_is_identity_enc_ipv6_src() {
523+
let option = TcActionTunnelKeyOption::KeyEncIpv6Src(Ipv6Addr::new(
524+
0x2001, 0xdb8, 0, 0, 0, 0, 0, 1,
525+
));
526+
let mut bytes = vec![0; option.buffer_len()];
527+
option.emit(&mut bytes);
528+
let parsed =
529+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
530+
assert_eq!(option, parsed);
531+
}
532+
533+
#[test]
534+
fn tunnel_key_option_emit_and_parse_is_identity_enc_dst_port() {
535+
let option = TcActionTunnelKeyOption::KeyEncDstPort(1);
536+
let mut bytes = vec![0; option.buffer_len()];
537+
option.emit(&mut bytes);
538+
let parsed =
539+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
540+
assert_eq!(option, parsed);
541+
}
542+
543+
#[test]
544+
fn tunnel_key_option_emit_and_parse_is_identity_no_checksum() {
545+
let option = TcActionTunnelKeyOption::KeyNoChecksum(true);
546+
let mut bytes = vec![0; option.buffer_len()];
547+
option.emit(&mut bytes);
548+
let parsed =
549+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
550+
assert_eq!(option, parsed);
551+
}
552+
553+
#[test]
554+
fn tunnel_key_option_emit_and_parse_is_identity_enc_opts_empty_geneve() {
555+
let option =
556+
TcActionTunnelKeyOption::KeyEncOpts(Options::Geneve(vec![]));
557+
let mut bytes = vec![0; option.buffer_len()];
558+
option.emit(&mut bytes);
559+
let parsed =
560+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
561+
assert_eq!(option, parsed);
562+
}
563+
564+
#[test]
565+
fn tunnel_key_option_emit_and_parse_is_identity_enc_opts_empty_vxlan() {
566+
let option =
567+
TcActionTunnelKeyOption::KeyEncOpts(Options::Vxlan(vec![]));
568+
let mut bytes = vec![0; option.buffer_len()];
569+
option.emit(&mut bytes);
570+
let parsed =
571+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
572+
assert_eq!(option, parsed);
573+
}
574+
575+
#[test]
576+
fn tunnel_key_option_emit_and_parse_is_identity_enc_opts_empty_erspan() {
577+
let option =
578+
TcActionTunnelKeyOption::KeyEncOpts(Options::Erspan(vec![]));
579+
let mut bytes = vec![0; option.buffer_len()];
580+
option.emit(&mut bytes);
581+
let parsed =
582+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
583+
assert_eq!(option, parsed);
584+
}
585+
586+
#[test]
587+
fn tunnel_key_option_emit_and_parse_is_identity_enc_opts_empty_gtp() {
588+
let option = TcActionTunnelKeyOption::KeyEncOpts(Options::Gtp(vec![]));
589+
let mut bytes = vec![0; option.buffer_len()];
590+
option.emit(&mut bytes);
591+
let parsed =
592+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
593+
assert_eq!(option, parsed);
594+
}
595+
596+
#[test]
597+
fn tunnel_key_options_emit_and_parse_is_identity_enc_tos() {
598+
let option = TcActionTunnelKeyOption::KeyEncTos(1);
599+
let mut bytes = vec![0; option.buffer_len()];
600+
option.emit(&mut bytes);
601+
let parsed =
602+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
603+
assert_eq!(option, parsed);
604+
}
605+
606+
#[test]
607+
fn tunnel_key_options_emit_and_parse_is_identity_enc_ttl() {
608+
let option = TcActionTunnelKeyOption::KeyEncTtl(1);
609+
let mut bytes = vec![0; option.buffer_len()];
610+
option.emit(&mut bytes);
611+
let parsed =
612+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
613+
assert_eq!(option, parsed);
614+
}
615+
616+
#[test]
617+
fn tunnel_key_options_emit_and_parse_is_identity_no_frag() {
618+
let option = TcActionTunnelKeyOption::KeyNoFrag;
619+
let mut bytes = vec![0; option.buffer_len()];
620+
option.emit(&mut bytes);
621+
let parsed =
622+
TcActionTunnelKeyOption::parse(&NlaBuffer::new(&bytes)).unwrap();
623+
assert_eq!(option, parsed);
624+
}
625+
}

0 commit comments

Comments
 (0)