UNIT TEEEESTS

Author: sum-catnip

readme.md

@@ -8,13 +8,11 @@
 - config:  ✔️
 - event:   ✔️
 - image:   ✔️
-- insn:    ❌
-- packet:  ❌
+- insn:    ✔️
+- packet:  ✔️
 - asid:    ✔️️
-- encoder: ❌
-- error:   ❌
-- flags:   ❌
-- query:   ❌
+- encoder: ✔️
+- query:   ✔️
 - version: ✔️
 
 # Integration Tests

src/encoder.rs

@@ -1,5 +1,9 @@
+use super::error::{
+    PtError, ensure_ptok,
+    extract_pterr, deref_ptresult,
+    deref_ptresult_mut
+};
 use super::config::Config;
-use super::error::{PtError, ensure_ptok, extract_pterr, deref_ptresult};
 
 use std::marker::PhantomData;
 
@@ -14,26 +18,43 @@ use libipt_sys::{
     pt_enc_sync_set
 };
 
+#[cfg(test)]
 mod tests {
+    use super::*;
+    use crate::packet::mnt::Mnt;
+
     #[test]
-    fn can_allocate_encoder() {
+    fn test_pktdec_alloc() {
+        Encoder::new(&mut Config::<()>::new(&mut [0; 0])).unwrap();
+    }
+
+    #[test ]
+    fn test_pktdec_props() {
+        // this just checks memory safety for property access
+        // usage can be found in the integration tests
+        let mut p = Encoder::new(&mut Config::<()>::new(&mut [0; 0]))
+            .unwrap();
 
+        assert!(p.config().is_ok());
+        assert_eq!(p.offset().unwrap(), 0);
+        assert!(p.set_offset(6).is_err());
+        assert!(p.next(Mnt::new(5)).is_err());
     }
 }
 
-pub struct Encoder<T>(pt_encoder, PhantomData<T>);
-impl<T> Encoder<T> {
+pub struct Encoder<'a, T>(&'a mut pt_encoder, PhantomData<T>);
+impl<'a, T> Encoder<'a, T> {
     /// Allocate an Intel PT packet encoder.
     ///
     /// The encoder will work on the buffer defined in @config, it shall contain raw trace data and remain valid for the lifetime of the encoder.
     /// The encoder starts at the beginning of the trace buffer.
     pub fn new(cfg: &mut Config<T>) -> Result<Self, PtError> {
-        deref_ptresult(unsafe { pt_alloc_encoder(cfg.0.to_mut()) })
-            .map(|x| Encoder::<T>(*x, PhantomData))
+        deref_ptresult_mut(unsafe { pt_alloc_encoder(cfg.0.to_mut()) })
+            .map(|x| Encoder::<T>(x, PhantomData))
     }
 
     pub fn config(&self) -> Result<Config<T>, PtError> {
-        deref_ptresult(unsafe{pt_enc_get_config(&self.0)})
+        deref_ptresult(unsafe{pt_enc_get_config(self.0)})
             .map(Config::from)
     }
 
@@ -44,7 +65,7 @@ impl<T> Encoder<T> {
     /// Returns Invalid if @offset is NULL.
     pub fn offset(&self) -> Result<u64, PtError> {
         let mut off = 0;
-        ensure_ptok(unsafe{pt_enc_get_offset(&self.0, &mut off)})
+        ensure_ptok(unsafe{pt_enc_get_offset(self.0, &mut off)})
             .map(|_| off)
     }
 
@@ -59,7 +80,7 @@ impl<T> Encoder<T> {
     /// Returns Eos if the encoder reached the end of the Intel PT buffer.
     /// Returns Invalid if @packet is NULL.
     pub fn next(&mut self, pck: impl Into<pt_packet>) -> Result<u32, PtError> {
-        extract_pterr(unsafe{pt_enc_next(&mut self.0, &pck.into())})
+        extract_pterr(unsafe{ pt_enc_next(self.0, &pck.into()) })
     }
 
     /// Hard set synchronization point of an Intel PT packet encoder.
@@ -69,10 +90,10 @@ impl<T> Encoder<T> {
     /// Returns Eos if the given offset is behind the end of the trace buffer.
     /// Returns Invalid if the encoder is NULL.
     pub fn set_offset(&mut self, offset: u64) -> Result<(), PtError> {
-        ensure_ptok(unsafe{pt_enc_sync_set(&mut self.0, offset)})
+        ensure_ptok(unsafe{pt_enc_sync_set(self.0, offset)})
     }
 }
 
-impl<T> Drop for Encoder<T> {
-    fn drop(&mut self) { unsafe { pt_free_encoder(&mut self.0) } }
+impl<'a, T> Drop for Encoder<'a, T> {
+    fn drop(&mut self) { unsafe { pt_free_encoder(self.0) } }
 }

src/event/mod.rs

@@ -83,7 +83,7 @@ mod test {
         assert_eq!(evt.lost_cyc(), 3);
 
         match evt.payload() {
-            Payload::Stop => assert!(true),
+            Payload::Stop => (),
             _ => unreachable!()
         }
     }

src/image/image.rs

@@ -92,19 +92,7 @@ mod test {
 
     #[test]
     fn test_img_copy() {
-        let file: PathBuf = [
-            env!("CARGO_MANIFEST_DIR"), "testfiles", "garbage.txt"
-        ].iter().collect();
-    
-        let mut i = Image::new(None).unwrap();
-        let asid = Asid::new(Some(3), Some(4));
-        i.add_file(file.to_str().unwrap(), 3, 10, Some(asid), 0x666)
-            .unwrap();
- 
-        assert_eq!(
-            img_with_file().copy(&i).unwrap(),
-            1
-        )
+        assert_eq!(img_with_file().copy(&img_with_file()).unwrap(), 0)
     }
 
     #[test]

src/insn/decoder.rs

@@ -1,6 +1,6 @@
 use crate::error::{
     PtError, deref_ptresult,
-    deref_ptresult_mut,
+    deref_ptresult_mut, PtErrorCode,
     ensure_ptok, extract_pterr
 };
 use crate::Config;
@@ -41,19 +41,20 @@ mod test {
     use super::*;
 
     #[test]
-    fn test_blkdec_alloc() {
+    fn test_insndec_alloc() {
         InsnDecoder::new(&Config::<()>::new(&mut [0; 0])).unwrap();
     }
 
     #[test ]
-    fn test_blkdec_props() {
+    fn test_insndec_props() {
         // this just checks memory safety for property access
         // usage can be found in the integration tests
         let mut b = InsnDecoder::new(&Config::<()>::new(&mut [0; 0])).unwrap();
         let a = b.asid().unwrap();
         assert!(a.cr3().is_none());
         assert!(a.vmcs().is_none());
 
+        assert!(b.event().is_err());
         assert!(b.core_bus_ratio().is_err());
         assert!(b.event().is_err());
         assert!(b.config().is_ok());
@@ -67,6 +68,9 @@ mod test {
     }
 }
 
+/// The decoder will work on the buffer defined in the Config,
+/// it shall contain raw trace data and remain valid for the lifetime of the decoder.
+/// The decoder needs to be synchronized before it can be used.
 pub struct InsnDecoder<'a, T>(&'a mut pt_insn_decoder, PhantomData<T>);
 impl<'a, T> InsnDecoder<'a, T> {
     /// Allocate an Intel PT instruction flow decoder.
@@ -240,6 +244,18 @@ impl<'a, T> InsnDecoder<'a, T> {
     }
 }
 
+impl<'a, T> Iterator for InsnDecoder<'a, T> {
+    type Item = Result<(Insn, Status), PtError>;
+
+    fn next(&mut self) -> Option<Result<(Insn, Status), PtError>> {
+        match self.next() {
+            // eos to stop iterating
+            Err(x) if x.code() == PtErrorCode::Eos => None,
+            x => Some(x)
+        }
+    }
+}
+
 impl<'a, T> Drop for InsnDecoder<'a, T> {
     fn drop(&mut self) { unsafe { pt_insn_free_decoder(self.0) } }
 }

src/packet/decoder.rs

@@ -1,5 +1,9 @@
+use crate::error::{
+    PtError, PtErrorCode,
+    deref_ptresult, deref_ptresult_mut,
+    ensure_ptok
+};
 use super::Packet;
-use crate::error::{PtError, deref_ptresult, ensure_ptok};
 use crate::Config;
 
 use std::mem;
@@ -19,20 +23,43 @@ use libipt_sys::{
     pt_pkt_sync_set
 };
 
-pub struct PacketDecoder<T>(pt_packet_decoder, PhantomData<T>);
-impl<T> PacketDecoder<T> {
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_pktdec_alloc() {
+        PacketDecoder::new(&Config::<()>::new(&mut [0; 0])).unwrap();
+    }
+
+    #[test ]
+    fn test_pktdec_props() {
+        // this just checks memory safety for property access
+        // usage can be found in the integration tests
+        let mut p = PacketDecoder::new(&Config::<()>::new(&mut [0; 0])).unwrap();
+        assert!(p.config().is_ok());
+        assert!(p.offset().is_err());
+        assert!(p.sync_offset().is_err());
+        assert!(p.next().is_err());
+        assert!(p.sync_backward().is_err());
+        assert!(p.sync_forward().is_err());
+    }
+}
+
+pub struct PacketDecoder<'a, T>(&'a mut pt_packet_decoder, PhantomData<T>);
+impl<'a, T> PacketDecoder<'a, T> {
     /// Allocate an Intel PT packet decoder.
     ///
     /// The decoder will work on the buffer defined in @config,
     /// it shall contain raw trace data and remain valid for the lifetime of the decoder.
     /// The decoder needs to be synchronized before it can be used.
     pub fn new(cfg: &Config<T>) -> Result<Self, PtError> {
-        deref_ptresult(unsafe { pt_pkt_alloc_decoder(cfg.0.as_ref()) })
-            .map(|d| PacketDecoder::<T>(*d, PhantomData))
+        deref_ptresult_mut(unsafe { pt_pkt_alloc_decoder(cfg.0.as_ref()) })
+            .map(|d| PacketDecoder::<T>(d, PhantomData))
     }
 
     pub fn config(&self) -> Result<Config<T>, PtError> {
-        deref_ptresult(unsafe { pt_pkt_get_config(&self.0) })
+        deref_ptresult(unsafe { pt_pkt_get_config(self.0) })
             .map(Config::from)
     }
 
@@ -41,7 +68,7 @@ impl<T> PacketDecoder<T> {
     /// Returns Nosync if decoder is out of sync.
     pub fn offset(&self) -> Result<u64, PtError> {
         let mut off: u64 = 0;
-        ensure_ptok(unsafe { pt_pkt_get_offset(&self.0, &mut off) })
+        ensure_ptok(unsafe { pt_pkt_get_offset(self.0, &mut off) })
             .map(|_| off)
     }
 
@@ -51,7 +78,7 @@ impl<T> PacketDecoder<T> {
     /// Returns Nosync if decoder is out of sync.
     pub fn sync_offset(&self) -> Result<u64, PtError> {
         let mut off: u64 = 0;
-        ensure_ptok(unsafe { pt_pkt_get_sync_offset(&self.0, &mut off) })
+        ensure_ptok(unsafe { pt_pkt_get_sync_offset(self.0, &mut off) })
             .map(|_| off)
     }
 
@@ -66,14 +93,14 @@ impl<T> PacketDecoder<T> {
     pub fn next(&mut self) -> Result<Packet<T>, PtError> {
         let mut pkt: pt_packet = unsafe { mem::zeroed() };
         ensure_ptok(unsafe {
-            pt_pkt_next(&mut self.0,
+            pt_pkt_next(self.0,
                         &mut pkt,
                         mem::size_of::<pt_packet>())
         }).map(|_| pkt.into())
     }
 
     pub fn sync_backward(&mut self) -> Result<(), PtError> {
-        ensure_ptok(unsafe { pt_pkt_sync_backward(&mut self.0) })
+        ensure_ptok(unsafe { pt_pkt_sync_backward(self.0) })
     }
 
     /// Synchronize an Intel PT packet decoder.
@@ -84,18 +111,30 @@ impl<T> PacketDecoder<T> {
     /// and at the end of the trace buffer in case of backward synchronization.
     /// Returns Eos if no further synchronization point is found.
     pub fn sync_forward(&mut self) -> Result<(), PtError> {
-        ensure_ptok(unsafe { pt_pkt_sync_forward(&mut self.0) })
+        ensure_ptok(unsafe { pt_pkt_sync_forward(self.0) })
     }
 
     /// Hard set synchronization point of an Intel PT decoder.
     ///
     /// Synchronize decoder to @offset within the trace buffer.
     /// Returns Eos if the given offset is behind the end of the trace buffer.
     pub fn sync_set(&mut self, offset: u64) -> Result<(), PtError> {
-        ensure_ptok(unsafe { pt_pkt_sync_set(&mut self.0, offset) })
+        ensure_ptok(unsafe { pt_pkt_sync_set(self.0, offset) })
+    }
+}
+
+impl<'a, T> Iterator for PacketDecoder<'a, T> {
+    type Item = Result<Packet<T>, PtError>;
+
+    fn next(&mut self) -> Option<Result<Packet<T>, PtError>> {
+        match self.next() {
+            // eos to stop iterating
+            Err(x) if x.code() == PtErrorCode::Eos => None,
+            x => Some(x)
+        }
     }
 }
 
-impl<T> Drop for PacketDecoder<T> {
-    fn drop(&mut self) { unsafe { pt_pkt_free_decoder(&mut self.0) }}
+impl<'a, T> Drop for PacketDecoder<'a, T> {
+    fn drop(&mut self) { unsafe { pt_pkt_free_decoder(self.0) }}
 }

src/packet/mod.rs

@@ -60,6 +60,28 @@ pub mod unknown;
 pub mod decoder;
 pub use decoder::PacketDecoder;
 
+#[cfg(test)]
+mod test {
+    use super::*;
+    use libipt_sys::pt_packet_mnt;
+    use libipt_sys::pt_packet__bindgen_ty_1;
+
+    #[test]
+    fn test_pkt_from() {
+        let p1 = pt_packet_mnt { payload: 666 };
+        let p2 = pt_packet {
+            type_: PT_PACKET_TYPE_PPT_MNT,
+            size: std::mem::size_of::<pt_packet_mnt>() as u8,
+            payload: pt_packet__bindgen_ty_1 { mnt: p1 }
+        };
+        let p3: Packet::<()> = p2.into();
+        match p3 {
+            Packet::Mnt(m) => assert_eq!(m.payload(), p1.payload),
+            _ => unreachable!()
+        };
+    }
+}
+
 pub enum Packet<T> {
     Invalid(invalid::Invalid),
     Psbend(psbend::Psbend),