Skip to content

Commit

Permalink
Clean up experiment
Browse files Browse the repository at this point in the history
  • Loading branch information
@daniel-noland
daniel-noland committed May 6, 2024
1 parent 7f889a7 commit cf53d1d
Showing 1 changed file with 67 additions and 175 deletions.
242 changes: 67 additions & 175 deletions src/tc/actions/tunnel_key.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -192,7 +192,7 @@ pub enum TcActionTunnelKeyOption {
KeyEncTos(u8),
/// Encapsulation TTL.
KeyEncTtl(u8),
/// Flag which indicated that the "do not fragment" bit should be set in
/// Flag which indicates that the "do not fragment" bit should be set in
/// the outer header.
KeyNoFrag,
/// Other option unknown at the time of writing.
Expand Down Expand Up @@ -363,8 +363,6 @@ fn parse_ipv6(data: &[u8]) -> Result<Ipv6Addr, DecodeError> {

#[cfg(test)]
mod tests {
use std::fmt::Debug;

use crate::tc::TcActionAttribute::Kind;
use crate::tc::TcActionMessageAttribute::Actions;
use crate::tc::TcTunnelKeyAction::{Release, Set};
Expand All @@ -377,107 +375,45 @@ mod tests {

use super::*;

trait ParseBuffer {
fn parse_buffer(buf: Vec<u8>) -> Self;
}

trait SerializeToBuffer {
fn serialize_to_buffer(&self) -> Vec<u8>;
}

trait AssertParsesFrom {
fn assert_parses_from(&self, serialized: Vec<u8>);
}

trait AssertSerializesTo {
fn assert_serializes_to(&self, serialized: Vec<u8>);
}

trait AssertSerThenParse {
fn assert_ser_then_parse(&self);
}

trait AssertParseThenSer {
fn assert_parse_then_ser(serialized: Vec<u8>);
}

impl<Message> AssertSerThenParse for Message
where
Message: SerializeToBuffer + ParseBuffer + Debug + Eq,
{
fn assert_ser_then_parse(&self) {
let serialized = self.serialize_to_buffer();
let parsed = Message::parse_buffer(serialized);
assert_eq!(parsed, *self);
}
}

impl<Message> AssertParseThenSer for Message
where
Message: SerializeToBuffer + ParseBuffer + Debug + Eq,
{
fn assert_parse_then_ser(serialized: Vec<u8>) {
let parsed = Message::parse_buffer(serialized.clone());
let reserialized = parsed.serialize_to_buffer();
assert_eq!(reserialized, serialized);
}
}

impl<Message> AssertParsesFrom for Message
where
Message: ParseBuffer + Debug + Eq,
{
fn assert_parses_from(&self, serialized: Vec<u8>) {
assert_eq!(self, &Message::parse_buffer(serialized));
}
}

impl<Message> AssertSerializesTo for Message
where
Message: SerializeToBuffer + Debug + Eq,
{
fn assert_serializes_to(&self, serialized: Vec<u8>) {
assert_eq!(self.serialize_to_buffer(), serialized);
}
}

impl<Message> SerializeToBuffer for Message
where
Message: Emitable,
{
fn serialize_to_buffer(&self) -> Vec<u8> {
let mut buffer = vec![0; self.buffer_len()];
self.emit(&mut buffer);
buffer
}
}

impl ParseBuffer for TcActionMessage {
fn parse_buffer(buf: Vec<u8>) -> TcActionMessage {
TcActionMessage::parse(
&TcActionMessageBuffer::new_checked(&buf).unwrap(),
)
.unwrap()
}
}

mod list {
use crate::tc::TcActionAttribute;
use crate::tc::TcActionAttribute::{InHwCount, Options, Stats};
use crate::tc::TcActionMessageAttribute::RootCount;
use crate::tc::TcActionTunnelKeyOption::{
KeyEncDstPort, KeyEncIpv4Dst, KeyEncIpv4Src, KeyEncKeyId,
KeyNoChecksum, Params, Tm,
};
use crate::tc::TcStats2::{Basic, BasicHw, Queue};
use crate::tc::{TcActionAttribute, TcStatsBasic, TcStatsQueue};

use super::*;

const LIST_REQUEST: &str = "0000000018000100140001000f00010074756e6e656c5f6b657900000c0002000100000001000000";
fn reference_list_request_serialized() -> Vec<u8> {
hex::decode(LIST_REQUEST).unwrap()
struct EquivalentMessage<T> {
pub serialized: Vec<u8>,
pub deserialized: T,
}
fn list_request() -> TcActionMessage {
TcActionMessage {

impl EquivalentMessage<TcActionMessage> {
pub fn assert_serialized_parses_to_deserialized(&self) {
let parsed = TcActionMessage::parse(
&TcActionMessageBuffer::new_checked(&self.serialized)
.unwrap(),
)
.unwrap();
assert_eq!(parsed, self.deserialized);
}

pub fn assert_deserialized_serializes_to_serialized(&self) {
let mut buf = vec![0; self.serialized.len()];
self.deserialized.emit(&mut buf);
assert_eq!(self.serialized, buf);
}
}

fn reference_message_list_request() -> EquivalentMessage<TcActionMessage>
{
const LIST_REQUEST: &str = "0000000018000100140001000f00010074756e6e656c5f6b657900000c0002000100000001000000";
let serialized = hex::decode(LIST_REQUEST).unwrap();
let deserialized = TcActionMessage {
header: TcActionMessageHeader {
family: AddressFamily::Unspec,
},
Expand All @@ -493,15 +429,18 @@ mod tests {
},
),
],
};
EquivalentMessage {
serialized,
deserialized,
}
}

const LIST_RESPONSE: &str = "000000000800030001000000dc000100d80000000f00010074756e6e656c5f6b6579000044000400140001000000000000000000000000000000000014000700000000000000000000000000000000001800030000000000000000000000000000000000000000000c000900000000000300000008000a00000000006c0002001c0002000100000000000000030000000100000000000000010000000800070000000bb808000300ac12010108000400ac1201040600090012b5000005000a000100000024000100e3a5800000000000e3a580000000000000000000000000000000000000000000";
fn reference_list_response_serialized() -> Vec<u8> {
hex::decode(LIST_RESPONSE).unwrap()
}
fn list_response() -> TcActionMessage {
TcActionMessage {
fn reference_message_list_response(
) -> EquivalentMessage<TcActionMessage> {
const LIST_RESPONSE: &str = "000000000800030001000000dc000100d80000000f00010074756e6e656c5f6b6579000044000400140001000000000000000000000000000000000014000700000000000000000000000000000000001800030000000000000000000000000000000000000000000c000900000000000300000008000a00000000006c0002001c0002000100000000000000030000000100000000000000010000000800070000000bb808000300ac12010108000400ac1201040600090012b5000005000a000100000024000100e3a5800000000000e3a580000000000000000000000000000000000000000000";
let serialized = hex::decode(LIST_RESPONSE).unwrap();
let deserialized = TcActionMessage {
header: TcActionMessageHeader {
family: AddressFamily::Unspec,
},
Expand All @@ -512,27 +451,21 @@ mod tests {
attributes: vec![
Kind("tunnel_key".to_string()),
Stats(vec![
crate::tc::TcStats2::Basic(
crate::tc::TcStatsBasic {
bytes: 0,
packets: 0,
},
),
crate::tc::TcStats2::BasicHw(
crate::tc::TcStatsBasic {
bytes: 0,
packets: 0,
},
),
crate::tc::TcStats2::Queue(
crate::tc::TcStatsQueue {
qlen: 0,
backlog: 0,
drops: 0,
requeues: 0,
overlimits: 0,
},
),
Basic(TcStatsBasic {
bytes: 0,
packets: 0,
}),
BasicHw(TcStatsBasic {
bytes: 0,
packets: 0,
}),
Queue(TcStatsQueue {
qlen: 0,
backlog: 0,
drops: 0,
requeues: 0,
overlimits: 0,
}),
]),
// TODO: properly parse whatever this is
TcActionAttribute::Other(DefaultNla::new(
Expand Down Expand Up @@ -580,83 +513,42 @@ mod tests {
],
}]),
],
};
EquivalentMessage {
serialized,
deserialized,
}
}

#[test]
fn parses_reference_request() {
list_request()
.assert_parses_from(reference_list_request_serialized());
reference_message_list_request()
.assert_serialized_parses_to_deserialized();
}

#[test]
fn serializes_to_reference_request() {
list_request()
.assert_serializes_to(reference_list_request_serialized());
reference_message_list_request()
.assert_deserialized_serializes_to_serialized();
}

#[test]
fn parses_reference_response() {
list_response()
.assert_parses_from(reference_list_response_serialized());
reference_message_list_response()
.assert_serialized_parses_to_deserialized();
}

#[test]
fn serializes_to_reference_response() {
list_response()
.assert_serializes_to(reference_list_response_serialized());
}

#[test]
fn ser_then_parse_reference_request() {
list_request().assert_ser_then_parse();
}

#[test]
fn parse_then_ser_reference_request() {
TcActionMessage::assert_parse_then_ser(
reference_list_request_serialized(),
);
reference_message_list_response()
.assert_deserialized_serializes_to_serialized();
}
}

// #[test]
// fn parse_reference_request() {
// let serialized = list::Request.serialized();
// let parsed = list::Request.parse_buffer(serialized);
// assert_eq!(parsed, list::Request.deserialized());
// }
//
// #[test]
// fn serialize_reference_request() {
// let deserialized = list::Request.deserialized();
// let serialized = list::Request.serialized();
// let mut buffer: Vec<u8> =
// std::iter::repeat(0).take(serialized.len()).collect();
// deserialized.emit(&mut buffer);
// assert_eq!(buffer, serialized);
// }
//
// #[test]
// fn parse_reference_reply() {
// use TcActionAttribute::*;
// use TcActionMessageAttribute::*;
// use TcActionTunnelKeyOption::*;
// let data = list::Response.serialized();
// let science = TcActionMessageBuffer::new_checked(&data).unwrap();
// let parsed = TcActionMessage::parse_buffer(&science).unwrap();
//
// let expected = ;
// assert_eq!(parsed, expected);
// }

#[test]
fn u32_from_tunnel_key_action_is_faithful_to_spec() {
assert_eq!(TCA_TUNNEL_KEY_ACT_SET, u32::from(Set));
assert_eq!(
TCA_TUNNEL_KEY_ACT_RELEASE,
u32::from(TcTunnelKeyAction::Release)
);
assert_eq!(TCA_TUNNEL_KEY_ACT_RELEASE, u32::from(Release));
let arbitrary_value = 42;
assert_eq!(
arbitrary_value,
Expand Down Expand Up @@ -705,7 +597,7 @@ mod tests {
index: 4,
refcnt: 5,
},
tunnel_key_action: TcTunnelKeyAction::Release,
tunnel_key_action: Release,
};
let mut bytes = vec![0; params.buffer_len()];
params.emit(&mut bytes);
Expand Down

0 comments on commit cf53d1d

Please sign in to comment.