Added packet parsing unit tests.

Author: Alex Helfet

src/decoder.rs

@@ -62,10 +62,103 @@ impl<R: Read> Decoder<R> {
     }
 }
 
-// TODO: Parse tests.
 /// Decode a single packet from a slice of bytes.
 pub fn from_slice(s: &[u8]) -> Result<Packet> {
     let mut d = Decoder::new(Cursor::new(Vec::from(s)));
     d.read_packet()
 }
 
+#[cfg(test)]
+mod tests {
+    use super::from_slice;
+    use error::{Error, ErrorKind, Result};
+    use packet::{Kind, Packet};
+    use std::io;
+
+    #[test]
+    fn header() {
+        let p = decode_one(&[0x01, 0x11]);
+        assert_eq!(p.header, 0x01);
+    }
+
+    #[test]
+    fn instrumentation_payload_1_byte() {
+        let p = decode_one(&[0x01, 0x11]);
+        match p.kind {
+            Kind::Instrumentation(ref i) => {
+                assert_eq!(*i.payload, [0x11]);
+            },
+            _ => panic!()
+        }
+    }
+
+    #[test]
+    fn instrumentation_payload_2_bytes() {
+        let p = decode_one(&[0x02, 0x11, 0x12]);
+        match p.kind {
+            Kind::Instrumentation(ref i) => {
+                assert_eq!(*i.payload, [0x11, 0x12]);
+            },
+            _ => panic!()
+        }
+    }
+
+    #[test]
+    fn instrumentation_payload_4_bytes() {
+        let p = decode_one(&[0x03, 0x11, 0x12, 0x13, 0x14]);
+        match p.kind {
+            Kind::Instrumentation(ref i) => {
+                assert_eq!(*i.payload, [0x11, 0x12, 0x13, 0x14]);
+            },
+            _ => panic!()
+        }
+    }
+
+    #[test]
+    fn instrumentation_stim_port() {
+        let p = decode_one(&[0b00000_001, 0x11]);
+        match p.kind {
+            Kind::Instrumentation(ref i) => {
+                assert_eq!(i.port, 0);
+            },
+            _ => panic!()
+        }
+
+        let p = decode_one(&[0b11111_001, 0x11]);
+        match p.kind {
+            Kind::Instrumentation(ref i) => {
+                assert_eq!(i.port, 31);
+            },
+            _ => panic!()
+        }
+    }
+
+    #[test]
+    fn unknown_header() {
+        let p = try_decode_one(&[0x00]);
+        match p {
+            Err(Error(ErrorKind::UnknownHeader(0x00), _)) => (),
+            _ => panic!(),
+        }
+    }
+
+    #[test]
+    fn eof_before_payload() {
+        let p = try_decode_one(&[0x01 /* Missing payload bytes */ ]);
+        match p {
+            Err(Error(ErrorKind::Io(ref e), _))
+            if e.kind() == io::ErrorKind::UnexpectedEof => (),
+            _ => panic!(),
+        }
+    }
+
+    fn decode_one(data: &[u8]) -> Packet {
+        try_decode_one(data).unwrap()
+    }
+
+    fn try_decode_one(data: &[u8]) -> Result<Packet> {
+        let p = from_slice(data);
+        println!("{:#?}", p);
+        p
+    }
+}

src/packet.rs

@@ -1,10 +1,12 @@
 //! Defines ITM packets and their possible contents.
 
 use heapless::Vec as HVec;
+use std::fmt::{self, Debug, Formatter};
 
 pub const MAX_PAYLOAD_SIZE: usize = 4;
 
 /// Represents a complete received packet.
+#[derive(Debug)]
 pub struct Packet {
     /// The header byte received for this packet.
     pub header: u8,
@@ -14,6 +16,7 @@ pub struct Packet {
 }
 
 /// The type of a packet.
+#[derive(Debug)]
 pub enum Kind {
     /// Data from a software application
     Instrumentation(Instrumentation),
@@ -32,3 +35,15 @@ pub struct Instrumentation {
     /// Stimulus port this packet was sent from.
     pub port: u8,
 }
+
+impl Debug for Instrumentation {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+        // TODO: impl Debug for heapless::Vec, then this can just be derived.
+        //       Eq, PartialEq, Clone would be good too.
+
+        f.debug_struct("Instrumentation")
+         .field("payload", &&*self.payload)
+         .field("port", &self.port)
+         .finish()
+    }
+}