Clean up experiment

Author: daniel-noland

src/tc/actions/tunnel_key.rs

@@ -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.
@@ -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};
@@ -377,90 +375,6 @@ 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};
@@ -472,12 +386,33 @@ mod tests {
 
         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,
+        }
+
+        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 list_request() -> TcActionMessage {
-            TcActionMessage {
+
+        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,
                 },
@@ -493,15 +428,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,
                 },
@@ -580,83 +518,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,
@@ -705,7 +602,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);