Skip to content

Commit cf53d1d

Browse files
daniel-nolanddaniel-noland
committed
Clean up experiment
1 parent 7f889a7 commit cf53d1d

File tree

1 file changed

+67
-175
lines changed

1 file changed

+67
-175
lines changed

‎src/tc/actions/tunnel_key.rs‎

Lines changed: 67 additions & 175 deletions
Original file line numberDiff line numberDiff line change
@@ -192,7 +192,7 @@ pub enum TcActionTunnelKeyOption {
192192
KeyEncTos(u8),
193193
/// Encapsulation TTL.
194194
KeyEncTtl(u8),
195-
/// Flag which indicated that the "do not fragment" bit should be set in
195+
/// Flag which indicates that the "do not fragment" bit should be set in
196196
/// the outer header.
197197
KeyNoFrag,
198198
/// Other option unknown at the time of writing.
@@ -363,8 +363,6 @@ fn parse_ipv6(data: &[u8]) -> Result<Ipv6Addr, DecodeError> {
363363

364364
#[cfg(test)]
365365
mod tests {
366-
use std::fmt::Debug;
367-
368366
use crate::tc::TcActionAttribute::Kind;
369367
use crate::tc::TcActionMessageAttribute::Actions;
370368
use crate::tc::TcTunnelKeyAction::{Release, Set};
@@ -377,107 +375,45 @@ mod tests {
377375

378376
use super::*;
379377

380-
trait ParseBuffer {
381-
fn parse_buffer(buf: Vec<u8>) -> Self;
382-
}
383-
384-
trait SerializeToBuffer {
385-
fn serialize_to_buffer(&self) -> Vec<u8>;
386-
}
387-
388-
trait AssertParsesFrom {
389-
fn assert_parses_from(&self, serialized: Vec<u8>);
390-
}
391-
392-
trait AssertSerializesTo {
393-
fn assert_serializes_to(&self, serialized: Vec<u8>);
394-
}
395-
396-
trait AssertSerThenParse {
397-
fn assert_ser_then_parse(&self);
398-
}
399-
400-
trait AssertParseThenSer {
401-
fn assert_parse_then_ser(serialized: Vec<u8>);
402-
}
403-
404-
impl<Message> AssertSerThenParse for Message
405-
where
406-
Message: SerializeToBuffer + ParseBuffer + Debug + Eq,
407-
{
408-
fn assert_ser_then_parse(&self) {
409-
let serialized = self.serialize_to_buffer();
410-
let parsed = Message::parse_buffer(serialized);
411-
assert_eq!(parsed, *self);
412-
}
413-
}
414-
415-
impl<Message> AssertParseThenSer for Message
416-
where
417-
Message: SerializeToBuffer + ParseBuffer + Debug + Eq,
418-
{
419-
fn assert_parse_then_ser(serialized: Vec<u8>) {
420-
let parsed = Message::parse_buffer(serialized.clone());
421-
let reserialized = parsed.serialize_to_buffer();
422-
assert_eq!(reserialized, serialized);
423-
}
424-
}
425-
426-
impl<Message> AssertParsesFrom for Message
427-
where
428-
Message: ParseBuffer + Debug + Eq,
429-
{
430-
fn assert_parses_from(&self, serialized: Vec<u8>) {
431-
assert_eq!(self, &Message::parse_buffer(serialized));
432-
}
433-
}
434-
435-
impl<Message> AssertSerializesTo for Message
436-
where
437-
Message: SerializeToBuffer + Debug + Eq,
438-
{
439-
fn assert_serializes_to(&self, serialized: Vec<u8>) {
440-
assert_eq!(self.serialize_to_buffer(), serialized);
441-
}
442-
}
443-
444-
impl<Message> SerializeToBuffer for Message
445-
where
446-
Message: Emitable,
447-
{
448-
fn serialize_to_buffer(&self) -> Vec<u8> {
449-
let mut buffer = vec![0; self.buffer_len()];
450-
self.emit(&mut buffer);
451-
buffer
452-
}
453-
}
454-
455-
impl ParseBuffer for TcActionMessage {
456-
fn parse_buffer(buf: Vec<u8>) -> TcActionMessage {
457-
TcActionMessage::parse(
458-
&TcActionMessageBuffer::new_checked(&buf).unwrap(),
459-
)
460-
.unwrap()
461-
}
462-
}
463-
464378
mod list {
465-
use crate::tc::TcActionAttribute;
466379
use crate::tc::TcActionAttribute::{InHwCount, Options, Stats};
467380
use crate::tc::TcActionMessageAttribute::RootCount;
468381
use crate::tc::TcActionTunnelKeyOption::{
469382
KeyEncDstPort, KeyEncIpv4Dst, KeyEncIpv4Src, KeyEncKeyId,
470383
KeyNoChecksum, Params, Tm,
471384
};
385+
use crate::tc::TcStats2::{Basic, BasicHw, Queue};
386+
use crate::tc::{TcActionAttribute, TcStatsBasic, TcStatsQueue};
472387

473388
use super::*;
474389

475-
const LIST_REQUEST: &str = "0000000018000100140001000f00010074756e6e656c5f6b657900000c0002000100000001000000";
476-
fn reference_list_request_serialized() -> Vec<u8> {
477-
hex::decode(LIST_REQUEST).unwrap()
390+
struct EquivalentMessage<T> {
391+
pub serialized: Vec<u8>,
392+
pub deserialized: T,
478393
}
479-
fn list_request() -> TcActionMessage {
480-
TcActionMessage {
394+
395+
impl EquivalentMessage<TcActionMessage> {
396+
pub fn assert_serialized_parses_to_deserialized(&self) {
397+
let parsed = TcActionMessage::parse(
398+
&TcActionMessageBuffer::new_checked(&self.serialized)
399+
.unwrap(),
400+
)
401+
.unwrap();
402+
assert_eq!(parsed, self.deserialized);
403+
}
404+
405+
pub fn assert_deserialized_serializes_to_serialized(&self) {
406+
let mut buf = vec![0; self.serialized.len()];
407+
self.deserialized.emit(&mut buf);
408+
assert_eq!(self.serialized, buf);
409+
}
410+
}
411+
412+
fn reference_message_list_request() -> EquivalentMessage<TcActionMessage>
413+
{
414+
const LIST_REQUEST: &str = "0000000018000100140001000f00010074756e6e656c5f6b657900000c0002000100000001000000";
415+
let serialized = hex::decode(LIST_REQUEST).unwrap();
416+
let deserialized = TcActionMessage {
481417
header: TcActionMessageHeader {
482418
family: AddressFamily::Unspec,
483419
},
@@ -493,15 +429,18 @@ mod tests {
493429
},
494430
),
495431
],
432+
};
433+
EquivalentMessage {
434+
serialized,
435+
deserialized,
496436
}
497437
}
498438

499-
const LIST_RESPONSE: &str = "000000000800030001000000dc000100d80000000f00010074756e6e656c5f6b6579000044000400140001000000000000000000000000000000000014000700000000000000000000000000000000001800030000000000000000000000000000000000000000000c000900000000000300000008000a00000000006c0002001c0002000100000000000000030000000100000000000000010000000800070000000bb808000300ac12010108000400ac1201040600090012b5000005000a000100000024000100e3a5800000000000e3a580000000000000000000000000000000000000000000";
500-
fn reference_list_response_serialized() -> Vec<u8> {
501-
hex::decode(LIST_RESPONSE).unwrap()
502-
}
503-
fn list_response() -> TcActionMessage {
504-
TcActionMessage {
439+
fn reference_message_list_response(
440+
) -> EquivalentMessage<TcActionMessage> {
441+
const LIST_RESPONSE: &str = "000000000800030001000000dc000100d80000000f00010074756e6e656c5f6b6579000044000400140001000000000000000000000000000000000014000700000000000000000000000000000000001800030000000000000000000000000000000000000000000c000900000000000300000008000a00000000006c0002001c0002000100000000000000030000000100000000000000010000000800070000000bb808000300ac12010108000400ac1201040600090012b5000005000a000100000024000100e3a5800000000000e3a580000000000000000000000000000000000000000000";
442+
let serialized = hex::decode(LIST_RESPONSE).unwrap();
443+
let deserialized = TcActionMessage {
505444
header: TcActionMessageHeader {
506445
family: AddressFamily::Unspec,
507446
},
@@ -512,27 +451,21 @@ mod tests {
512451
attributes: vec![
513452
Kind("tunnel_key".to_string()),
514453
Stats(vec![
515-
crate::tc::TcStats2::Basic(
516-
crate::tc::TcStatsBasic {
517-
bytes: 0,
518-
packets: 0,
519-
},
520-
),
521-
crate::tc::TcStats2::BasicHw(
522-
crate::tc::TcStatsBasic {
523-
bytes: 0,
524-
packets: 0,
525-
},
526-
),
527-
crate::tc::TcStats2::Queue(
528-
crate::tc::TcStatsQueue {
529-
qlen: 0,
530-
backlog: 0,
531-
drops: 0,
532-
requeues: 0,
533-
overlimits: 0,
534-
},
535-
),
454+
Basic(TcStatsBasic {
455+
bytes: 0,
456+
packets: 0,
457+
}),
458+
BasicHw(TcStatsBasic {
459+
bytes: 0,
460+
packets: 0,
461+
}),
462+
Queue(TcStatsQueue {
463+
qlen: 0,
464+
backlog: 0,
465+
drops: 0,
466+
requeues: 0,
467+
overlimits: 0,
468+
}),
536469
]),
537470
// TODO: properly parse whatever this is
538471
TcActionAttribute::Other(DefaultNla::new(
@@ -580,83 +513,42 @@ mod tests {
580513
],
581514
}]),
582515
],
516+
};
517+
EquivalentMessage {
518+
serialized,
519+
deserialized,
583520
}
584521
}
585522

586523
#[test]
587524
fn parses_reference_request() {
588-
list_request()
589-
.assert_parses_from(reference_list_request_serialized());
525+
reference_message_list_request()
526+
.assert_serialized_parses_to_deserialized();
590527
}
591528

592529
#[test]
593530
fn serializes_to_reference_request() {
594-
list_request()
595-
.assert_serializes_to(reference_list_request_serialized());
531+
reference_message_list_request()
532+
.assert_deserialized_serializes_to_serialized();
596533
}
597534

598535
#[test]
599536
fn parses_reference_response() {
600-
list_response()
601-
.assert_parses_from(reference_list_response_serialized());
537+
reference_message_list_response()
538+
.assert_serialized_parses_to_deserialized();
602539
}
603540

604541
#[test]
605542
fn serializes_to_reference_response() {
606-
list_response()
607-
.assert_serializes_to(reference_list_response_serialized());
608-
}
609-
610-
#[test]
611-
fn ser_then_parse_reference_request() {
612-
list_request().assert_ser_then_parse();
613-
}
614-
615-
#[test]
616-
fn parse_then_ser_reference_request() {
617-
TcActionMessage::assert_parse_then_ser(
618-
reference_list_request_serialized(),
619-
);
543+
reference_message_list_response()
544+
.assert_deserialized_serializes_to_serialized();
620545
}
621546
}
622547

623-
// #[test]
624-
// fn parse_reference_request() {
625-
// let serialized = list::Request.serialized();
626-
// let parsed = list::Request.parse_buffer(serialized);
627-
// assert_eq!(parsed, list::Request.deserialized());
628-
// }
629-
//
630-
// #[test]
631-
// fn serialize_reference_request() {
632-
// let deserialized = list::Request.deserialized();
633-
// let serialized = list::Request.serialized();
634-
// let mut buffer: Vec<u8> =
635-
// std::iter::repeat(0).take(serialized.len()).collect();
636-
// deserialized.emit(&mut buffer);
637-
// assert_eq!(buffer, serialized);
638-
// }
639-
//
640-
// #[test]
641-
// fn parse_reference_reply() {
642-
// use TcActionAttribute::*;
643-
// use TcActionMessageAttribute::*;
644-
// use TcActionTunnelKeyOption::*;
645-
// let data = list::Response.serialized();
646-
// let science = TcActionMessageBuffer::new_checked(&data).unwrap();
647-
// let parsed = TcActionMessage::parse_buffer(&science).unwrap();
648-
//
649-
// let expected = ;
650-
// assert_eq!(parsed, expected);
651-
// }
652-
653548
#[test]
654549
fn u32_from_tunnel_key_action_is_faithful_to_spec() {
655550
assert_eq!(TCA_TUNNEL_KEY_ACT_SET, u32::from(Set));
656-
assert_eq!(
657-
TCA_TUNNEL_KEY_ACT_RELEASE,
658-
u32::from(TcTunnelKeyAction::Release)
659-
);
551+
assert_eq!(TCA_TUNNEL_KEY_ACT_RELEASE, u32::from(Release));
660552
let arbitrary_value = 42;
661553
assert_eq!(
662554
arbitrary_value,
@@ -705,7 +597,7 @@ mod tests {
705597
index: 4,
706598
refcnt: 5,
707599
},
708-
tunnel_key_action: TcTunnelKeyAction::Release,
600+
tunnel_key_action: Release,
709601
};
710602
let mut bytes = vec![0; params.buffer_len()];
711603
params.emit(&mut bytes);

0 commit comments

Comments
 (0)