(tests) data-driven tests with macros

src/main.rs

@@ -1,3 +1,4 @@
+#![feature(concat_idents)]
 use std::net::UdpSocket;
 use std::sync::mpsc;
 use std::thread::{self, JoinHandle};

src/proto.rs

@@ -140,10 +140,10 @@ pub struct DNSHeader {
     pub recursion_desired: bool,
     /// denotes whether recursive query support is available in the name server
     pub recursion_available: bool,
-    // no support of rfc4035 at the moment
+    /// TODO: add documuentation about this flag
-    //pub authentic_data: bool,
+    pub authentic_data: bool,
-    // no support of rfc4035 at the moment
+    /// TODO: add documuentation about this flag
-    //pub checking_disabled: bool,
+    pub checking_disabled: bool,
     pub response_code: DNSRCode,
     /// TODO: add documuentation about this count
     pub query_count: u16,
@@ -171,9 +171,8 @@ impl DNSHeader {
     const RD_MASK: u8 = 0b00000001;
 
     const RA_MASK: u8 = 0b10000000;
-    // no support of rfc4035 at the moment
+    const AD_MASK: u8 = 0b00100000;
-    //const AD_MASK: u8 = 0b00100000;
+    const CD_MASK: u8 = 0b00010000;
-    //const CD_MASK: u8 = 0b00010000;
     const RCODE_MASK: u8 = 0b00001111;
 
     const OPCODE_OFFSET: u8 = 3;
@@ -187,17 +186,15 @@ impl DNSHeader {
 
         let message_type = DNSMessageType::from(datagram[2] & Self::QR_MASK != 0);
         let opcode = DNSOpCode::try_from((datagram[2] & Self::OPCODE_MASK) >> Self::OPCODE_OFFSET)?;
-
         let authorative_answer = (datagram[2] & Self::AA_MASK) != 0;
         let truncated = (datagram[2] & Self::TC_MASK) != 0;
         let recursion_desired = (datagram[2] & Self::RD_MASK) != 0;
-        let recursion_available = (datagram[3] & Self::RA_MASK) != 0;
-
-        // no support for rfc4035 at the moment
-        //let authentic_data = (datagram[2] & Self::AD_MASK) != 0;
-        //let checking_disabled = (datagram[2] & Self::CD_MASK) != 0;
 
+        let recursion_available = (datagram[2] & Self::RA_MASK) != 0;
+        let authentic_data = (datagram[2] & Self::AD_MASK) != 0;
+        let checking_disabled = (datagram[2] & Self::CD_MASK) != 0;
         let response_code = DNSRCode::try_from(datagram[3] & Self::RCODE_MASK)?;
+
         let query_count = u16::from_be_bytes((datagram[4..6]).try_into().unwrap());
         let answer_count = u16::from_be_bytes((datagram[6..8]).try_into().unwrap());
         let name_server_count = u16::from_be_bytes((datagram[8..10]).try_into().unwrap());
@@ -211,8 +208,8 @@ impl DNSHeader {
             truncated,
             recursion_desired,
             recursion_available,
-            //authentic_data,    // no support of rfc4035 at the moment
+            authentic_data,
-            //checking_disabled, // no support of rfc4035 at the moment
+            checking_disabled,
             response_code,
             query_count,
             answer_count,
@@ -231,9 +228,19 @@ pub enum DNSParseError {
 
 #[cfg(test)]
 mod tests {
+    macro_rules! data_driven_test {
+        ($name:expr, $func:expr, $input:literal, $output:literal) => {
+            #[test]
+            fn concat_idents!($name, _test) {
+                assert_eq!($input, $output);
+            }
+        }
+    }
 
     mod from_udp_datagram {
 
+        data_driven_test!("my_macro_test", somefunc, 5, 5);
+
         mod header_length {
             use super::super::super::*;
 
@@ -332,7 +339,7 @@ mod tests {
                 let invalid_rcodes = [11, 12, 13, 14, 15];
 
                 for rcode in invalid_rcodes {
-                    dns_query[3] = rcode;
+                    dns_query[3] = (rcode as u8) << 0;
 
                     let parse_result = DNSHeader::from_udp_datagram(&dns_query);
 
@@ -368,7 +375,7 @@ mod tests {
                 ];
 
                 for (rcode, parsed_rcode) in valid_rcodes {
-                    dns_query[3] = rcode;
+                    dns_query[3] = rcode << 0;
                     let parse_result = DNSHeader::from_udp_datagram(&dns_query);
                     assert_eq!(
                         parse_result?.response_code, parsed_rcode,
@@ -379,237 +386,5 @@ mod tests {
                 Ok(())
             }
         }
-
-        mod query_count {
-            use super::super::super::*;
-
-            #[test]
-            fn zero() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.query_count, 0);
-                Ok(())
-            }
-
-            #[test]
-            fn one() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.query_count, 1);
-                Ok(())
-            }
-
-            #[test]
-            fn max_value() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.query_count, 65535);
-                Ok(())
-            }
-        }
-
-        mod answer_count {
-            use super::super::super::*;
-
-            #[test]
-            fn zero() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.answer_count, 0);
-                Ok(())
-            }
-
-            #[test]
-            fn one() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.answer_count, 1);
-                Ok(())
-            }
-
-            #[test]
-            fn max_value() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.answer_count, 65535);
-                Ok(())
-            }
-        }
-
-        mod name_server_count {
-            use super::super::super::*;
-
-            #[test]
-            fn zero() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.name_server_count, 0);
-                Ok(())
-            }
-
-            #[test]
-            fn one() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.name_server_count, 1);
-                Ok(())
-            }
-
-            #[test]
-            fn max_value() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.name_server_count, 65535);
-                Ok(())
-            }
-        }
-
-        mod additional_count {
-            use super::super::super::*;
-
-            #[test]
-            fn zero() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.additional_count, 0);
-                Ok(())
-            }
-
-            #[test]
-            fn one() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.additional_count, 1);
-                Ok(())
-            }
-
-            #[test]
-            fn max_value() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert_eq!(parse_result?.additional_count, 65535);
-                Ok(())
-            }
-        }
-
-        mod authorative_answer {
-            use super::super::super::*;
-
-            #[test]
-            fn yes() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert!(parse_result?.authorative_answer);
-                Ok(())
-            }
-
-            #[test]
-            fn no() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert!(!parse_result?.authorative_answer);
-                Ok(())
-            }
-        }
-
-        mod truncated {
-            use super::super::super::*;
-
-            #[test]
-            fn yes() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert!(parse_result?.truncated);
-                Ok(())
-            }
-
-            #[test]
-            fn no() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert!(!parse_result?.truncated);
-                Ok(())
-            }
-        }
-
-        mod recursion_desired {
-            use super::super::super::*;
-
-            #[test]
-            fn yes() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert!(parse_result?.recursion_desired);
-                Ok(())
-            }
-
-            #[test]
-            fn no() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert!(!parse_result?.recursion_desired);
-                Ok(())
-            }
-        }
-
-        mod recursion_available {
-            use super::super::super::*;
-
-            #[test]
-            fn yes() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert!(parse_result?.recursion_available);
-                Ok(())
-            }
-
-            #[test]
-            fn no() -> Result<(), DNSParseError> {
-                let dns_query = [
-                    0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                ];
-                let parse_result = DNSHeader::from_udp_datagram(&dns_query);
-                assert!(!parse_result?.recursion_available);
-                Ok(())
-            }
-        }
     }
 }