implement insta testing

Author: rbran

Cargo.toml

@@ -15,6 +15,7 @@ num_enum = "0.7.3"
 num-traits = "0.2.19"
 zstd = "0.13.3"
 rstest = "0.25.0"
+insta = "1.43.1"
 
 [features]
 default = []
@@ -26,3 +27,7 @@ path = "src/tools/tools.rs"
 
 [dev-dependencies]
 insta = { version = "1.43.1", features = ["yaml"] }
+
+[profile.dev.package]
+insta.opt-level = 3
+similar.opt-level = 3

build.rs

@@ -0,0 +1,5 @@
+pub fn main() {
+    // recompile so new til/idb files are included to tests
+    println!("cargo::rerun-if-changed=resources/idbs");
+    println!("cargo::rerun-if-changed=resources/tils");
+}

src/addr_info.rs

@@ -1,5 +1,3 @@
-use std::borrow::Cow;
-
 use crate::bytes_info::BytesInfo;
 use crate::id0::entry_iter::EntryTagContinuousSubkeys;
 use crate::id0::flag::nalt::x::NALT_DREF_FROM;
@@ -12,7 +10,7 @@ use crate::id0::{
 use crate::id1::{ByteDataType, ByteInfo, ByteType, ID1Section};
 use crate::id2::ID2Section;
 use crate::til::Type;
-use crate::{Address, IDAKind};
+use crate::{Address, IDAKind, IDBStr, IDBString};
 
 use anyhow::{anyhow, Result};
 
@@ -76,32 +74,32 @@ impl<'a, K: IDAKind> AddressInfo<'a, K> {
     // the function `get_cmt` search for the next non-tail entry in id1,
     // maybe that's for compatibility reasons, but maybe the `has_comment`
     // flag should be ignored in tail id1 entries
-    pub fn comment(&self) -> Option<&'a [u8]> {
+    pub fn comment(&self) -> Option<IDBStr<'a>> {
         self.id0.comment_at(self.netnode())
     }
 
-    pub fn comment_repeatable(&self) -> Option<&'a [u8]> {
+    pub fn comment_repeatable(&self) -> Option<IDBStr<'a>> {
         if !self.byte_info.has_comment() {
             return None;
         }
         self.id0.comment_repeatable_at(self.netnode())
     }
 
-    pub fn comment_pre(&self) -> Option<impl Iterator<Item = &[u8]>> {
+    pub fn comment_pre(&self) -> Option<impl Iterator<Item = IDBStr<'a>>> {
         if !self.byte_info.has_comment_ext() {
             return None;
         }
         Some(self.id0.comment_pre_at(self.netnode()))
     }
 
-    pub fn comment_post(&self) -> Option<impl Iterator<Item = &[u8]>> {
+    pub fn comment_post(&self) -> Option<impl Iterator<Item = IDBStr<'a>>> {
         if !self.byte_info.has_comment_ext() {
             return None;
         }
         Some(self.id0.comment_post_at(self.netnode()))
     }
 
-    pub fn label(&self) -> Result<Option<Cow<'a, [u8]>>> {
+    pub fn label(&self) -> Result<Option<IDBString>> {
         if !self.byte_info.has_name() {
             if !self.byte_info.has_dummy_name() {
                 return Ok(None);
@@ -121,15 +119,15 @@ impl<'a, K: IDAKind> AddressInfo<'a, K> {
                     anyhow!("Label is not a valid CStr or ID0 Ref")
                 })?;
             match value {
-                ID0CStr::CStr(label) => Ok(Some(Cow::Borrowed(label))),
+                ID0CStr::CStr(label) => Ok(Some(label.to_idb_string())),
                 ID0CStr::Ref(label_ref) => {
                     let entries = self.id0.address_info_value(label_ref)?;
-                    let label = entries
+                    let label: Vec<u8> = entries
                         .iter()
                         .flat_map(|x| &x.value[..])
                         .copied()
                         .collect();
-                    Ok(Some(Cow::Owned(label)))
+                    Ok(Some(IDBString::new(label)))
                 }
             }
         }

src/id0.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 use std::num::NonZeroU32;
 
-use crate::ida_reader::IdbRead;
 use crate::IDAKind;
+use crate::{ida_reader::IdbRead, IDBStr};
 
 use anyhow::{anyhow, ensure};
 
@@ -110,7 +110,7 @@ pub(crate) fn parse_maybe_cstr(data: &[u8]) -> Option<&[u8]> {
 }
 
 pub(crate) enum ID0CStr<'a, K: IDAKind> {
-    CStr(&'a [u8]),
+    CStr(IDBStr<'a>),
     Ref(K::Usize),
 }
 
@@ -123,7 +123,7 @@ impl<'a, K: IDAKind> ID0CStr<'a, K> {
             [b'\x00', rest @ ..] => {
                 K::usize_try_from_be_bytes(rest).map(ID0CStr::Ref)
             }
-            _ => parse_maybe_cstr(data).map(ID0CStr::CStr),
+            _ => parse_maybe_cstr(data).map(IDBStr::new).map(ID0CStr::CStr),
         }
     }
 }

src/id0/db.rs

@@ -8,7 +8,7 @@ use num_traits::{AsPrimitive, CheckedAdd, PrimInt, ToBytes};
 use crate::addr_info::SubtypeId;
 use crate::id0::flag::nsup::NSUP_LLABEL;
 use crate::ida_reader::{IdbBufRead, IdbReadKind};
-use crate::{til, Address};
+use crate::{til, Address, IDBStr};
 use crate::{IDAVariants, SectionReader, IDA32, IDA64};
 
 use super::entry_iter::{
@@ -503,7 +503,7 @@ impl<K: IDAKind> ID0Section<K> {
     // TODO there is also a "P" entry in patches, it seems to only contains
     // the value 0x01 for each equivalent "A" entry
 
-    pub fn segment_name(&self, idx: SegmentNameIdx<K>) -> Result<&[u8]> {
+    pub fn segment_name(&self, idx: SegmentNameIdx<K>) -> Result<IDBStr<'_>> {
         let seg_idx = self.segment_strings_idx()?;
         // TODO I think this is dependent on the version, and not on availability
         if let Some(seg_idx) = seg_idx {
@@ -523,7 +523,7 @@ impl<K: IDAKind> ID0Section<K> {
     pub(crate) fn name_by_index(
         &self,
         idx: SegmentNameIdx<K>,
-    ) -> Result<&[u8]> {
+    ) -> Result<IDBStr<'_>> {
         // if there is no names, AKA `$ segstrings`, search for the key directly
         let name_idx = self
             .netnode_tag_idx(
@@ -532,6 +532,7 @@ impl<K: IDAKind> ID0Section<K> {
             )
             .ok_or_else(|| anyhow!("Not found name for segment {}", idx.0))?;
         parse_maybe_cstr(&self.entries[name_idx].value)
+            .map(IDBStr::new)
             .ok_or_else(|| anyhow!("Invalid segment name {}", idx.0))
     }
 
@@ -585,8 +586,8 @@ impl<K: IDAKind> ID0Section<K> {
         )
     }
 
-    pub fn input_file(&self, idx: RootNodeIdx<K>) -> Option<&[u8]> {
-        self.netnode_value(idx.into())
+    pub fn input_file(&self, idx: RootNodeIdx<K>) -> Option<IDBStr<'_>> {
+        self.netnode_value(idx.into()).map(IDBStr::new)
     }
 
     // TODO identify the data
@@ -1139,17 +1140,20 @@ impl<K: IDAKind> ID0Section<K> {
         Ok(None)
     }
 
-    pub(crate) fn comment_at(&self, netnode: NetnodeIdx<K>) -> Option<&[u8]> {
+    pub(crate) fn comment_at(
+        &self,
+        netnode: NetnodeIdx<K>,
+    ) -> Option<IDBStr<'_>> {
         let comment = self.sup_value(netnode, 0u8.into(), ARRAY_SUP_TAG)?;
-        Some(parse_maybe_cstr(comment).unwrap_or(comment))
+        Some(IDBStr::new(parse_maybe_cstr(comment).unwrap_or(comment)))
     }
 
     pub(crate) fn comment_repeatable_at(
         &self,
         netnode: NetnodeIdx<K>,
-    ) -> Option<&[u8]> {
+    ) -> Option<IDBStr<'_>> {
         let comment = self.sup_value(netnode, 1u8.into(), ARRAY_SUP_TAG)?;
-        Some(parse_maybe_cstr(comment).unwrap_or(comment))
+        Some(IDBStr::new(parse_maybe_cstr(comment).unwrap_or(comment)))
     }
 
     // TODO: comments have a strange hole in id0
@@ -1162,7 +1166,7 @@ impl<K: IDAKind> ID0Section<K> {
     pub(crate) fn comment_pre_at(
         &self,
         netnode: NetnodeIdx<K>,
-    ) -> impl Iterator<Item = &[u8]> {
+    ) -> impl Iterator<Item = IDBStr<'_>> {
         crate::id0::entry_iter::EntryTagContinuousSubkeys::new(
             self,
             netnode,
@@ -1172,13 +1176,17 @@ impl<K: IDAKind> ID0Section<K> {
         // 1000..2000
         // max number of lines, NOTE this check is not done by IDA
         .take(1000)
-        .map(|entry| parse_maybe_cstr(&entry.value).unwrap_or(&entry.value[..]))
+        .map(|entry| {
+            IDBStr::new(
+                parse_maybe_cstr(&entry.value).unwrap_or(&entry.value[..]),
+            )
+        })
     }
 
     pub(crate) fn comment_post_at(
         &self,
         netnode: NetnodeIdx<K>,
-    ) -> impl Iterator<Item = &[u8]> {
+    ) -> impl Iterator<Item = IDBStr<'_>> {
         crate::id0::entry_iter::EntryTagContinuousSubkeys::new(
             self,
             netnode,
@@ -1188,7 +1196,11 @@ impl<K: IDAKind> ID0Section<K> {
         // 2000..3000
         // max number of lines, NOTE this check is not done by IDA
         .take(1000)
-        .map(|entry| parse_maybe_cstr(&entry.value).unwrap_or(&entry.value[..]))
+        .map(|entry| {
+            IDBStr::new(
+                parse_maybe_cstr(&entry.value).unwrap_or(&entry.value[..]),
+            )
+        })
     }
 
     pub fn struct_at(&self, idx: SubtypeId<K>) -> Result<&[u8]> {

src/id0/dirtree.rs

@@ -2,11 +2,12 @@ use std::collections::HashMap;
 
 use anyhow::{anyhow, ensure, Result};
 use num_traits::WrappingAdd;
+use serde::Serialize;
 
 use crate::ida_reader::{IdbBufRead, IdbReadKind};
 use crate::{IDAKind, IDAUsize};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub struct DirTreeRoot<T> {
     pub entries: Vec<DirTreeEntry<T>>,
 }
@@ -31,7 +32,7 @@ impl<T> DirTreeRoot<T> {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub enum DirTreeEntry<T> {
     Leaf(T),
     Directory {

src/id0/file_region.rs

@@ -1,12 +1,13 @@
 use anyhow::{anyhow, Result};
 use num_traits::CheckedAdd;
+use serde::Serialize;
 
 use crate::ida_reader::IdbReadKind;
 use crate::IDAKind;
 
 use super::{entry_iter::NetnodeSupRangeIter, NetnodeIdx};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub struct FileRegions<K: IDAKind> {
     pub start: K::Usize,
     pub end: K::Usize,

src/id0/function.rs

@@ -2,31 +2,32 @@ use std::ops::Range;
 
 use crate::id0::parse_maybe_cstr;
 use crate::ida_reader::{IdbBufRead, IdbRead, IdbReadKind};
-use crate::{flags_to_struct, til, Address, IDAKind};
+use crate::{flags_to_struct, til, Address, IDAKind, IDBStr};
 
 use super::flag::func::*;
 use super::flag::netnode::nn_res::ARRAY_SUP_TAG;
 use super::{flag, ID0Section, NetnodeIdx};
 
 use anyhow::{anyhow, ensure, Result};
 use num_traits::WrappingSub;
+use serde::Serialize;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub enum Comments<'a> {
-    Comment(&'a [u8]),
-    RepeatableComment(&'a [u8]),
-    PreComment(&'a [u8]),
-    PostComment(&'a [u8]),
+    Comment(IDBStr<'a>),
+    RepeatableComment(IDBStr<'a>),
+    PreComment(IDBStr<'a>),
+    PostComment(IDBStr<'a>),
 }
 
 impl<'a> Comments<'a> {
     /// The message on the comment, NOTE that IDA don't have a default character encoding
-    pub fn message(&self) -> &'a [u8] {
+    pub fn message(&self) -> IDBStr<'a> {
         match self {
             Comments::Comment(x)
             | Comments::RepeatableComment(x)
             | Comments::PreComment(x)
-            | Comments::PostComment(x) => x,
+            | Comments::PostComment(x) => *x,
         }
     }
 }
@@ -63,28 +64,28 @@ pub(crate) fn fchunks<K: IDAKind>(
         .map(move |value| IDBFunction::read(&value.value[..]))
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub struct IDBFunction<K: IDAKind> {
     pub address: Range<Address<K>>,
     pub flags: IDBFunctionFlag,
     pub extra: IDBFunctionType<K>,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub enum IDBFunctionType<K: IDAKind> {
     Tail(IDBFunctionTail<K>),
     NonTail(IDBFunctionNonTail<K>),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub struct IDBFunctionTail<K: IDAKind> {
     /// function owner of the function start
     pub owner: K::Usize,
     pub _unknown4: u16,
     pub _unknown5: Option<u32>,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub struct IDBFunctionNonTail<K: IDAKind> {
     pub frame: K::Usize,
     /// Local variables area
@@ -102,7 +103,7 @@ pub struct IDBFunctionNonTail<K: IDAKind> {
     pub fpd: K::Usize,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub enum FunctionsAndComments<'a, K: IDAKind> {
     // It's just the name "$ funcs"
     Name,
@@ -140,7 +141,7 @@ impl<'a, K: IDAKind> FunctionsAndComments<'a, K> {
                 parse_maybe_cstr(value)
                     .map(|value| Self::Comment {
                         address,
-                        comment: Comments::Comment(value),
+                        comment: Comments::Comment(IDBStr::new(value)),
                     })
                     .ok_or_else(|| anyhow!("Invalid Comment string"))
             }
@@ -152,7 +153,9 @@ impl<'a, K: IDAKind> FunctionsAndComments<'a, K> {
                 parse_maybe_cstr(value)
                     .map(|value| Self::Comment {
                         address,
-                        comment: Comments::RepeatableComment(value),
+                        comment: Comments::RepeatableComment(IDBStr::new(
+                            value,
+                        )),
                     })
                     .ok_or_else(|| anyhow!("Invalid Repetable Comment string"))
             }
@@ -350,7 +353,7 @@ impl<'a, K: IDAKind> EntryPointRaw<'a, K> {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub struct EntryPoint<K: IDAKind> {
     pub name: String,
     pub address: K::Usize,