Increase code coverage

Increase code coverage by exercising a bunch of paths on recently added
ELF relocation related types.

Signed-off-by: Daniel Müller <deso@posteo.net>

Author: d-e-s-o

src/elf/relocations.rs

@@ -77,3 +77,76 @@ impl SectionRelocations {
         self.maps.get(&target_idx).unwrap_or(&self.empty)
     }
 }
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+
+    /// Exercise the `Debug` representation of relocation types.
+    #[test]
+    fn debug_repr() {
+        let map = RelocationMap::default();
+        assert_ne!(format!("{map:?}"), "");
+
+        let entry = RelocationEntry {
+            addend: 42,
+            implicit: false,
+        };
+        assert_ne!(format!("{entry:?}"), "");
+    }
+
+    /// Test explicit (RELA) relocation.
+    #[test]
+    fn relocate_explicit() {
+        let mut map = RelocationMap::default();
+        let () = map.insert(0x100, 0xABCD, false);
+
+        assert_eq!(map.relocate(0x100, 999), 0xABCD);
+        assert_eq!(map.relocate(0x200, 999), 999);
+    }
+
+    /// Test implicit (REL) relocation.
+    #[test]
+    fn relocate_implicit() {
+        let mut map = RelocationMap::default();
+        let () = map.insert(0x100, 0x10, true);
+
+        assert_eq!(map.relocate(0x100, 0x20), 0x30);
+        assert_eq!(map.relocate(0x200, 0x20), 0x20);
+    }
+
+    /// Test wrapping behavior of implicit relocation.
+    #[test]
+    fn relocate_implicit_wrapping() {
+        let mut map = RelocationMap::default();
+        let () = map.insert(0x0, 1, true);
+
+        assert_eq!(map.relocate(0x0, u64::MAX), 0);
+    }
+
+    /// Check that `SectionRelocations::empty()` returns identity maps
+    /// for any index.
+    #[test]
+    fn section_relocations_empty() {
+        let relocs = SectionRelocations::empty();
+        assert_eq!(relocs.get(0).relocate(0x0, 42), 42);
+        assert_eq!(relocs.get(99).relocate(0x0, 42), 42);
+    }
+
+    /// Make sure that `SectionRelocations::new(maps)` returns populated
+    /// map for known index and empty map for unknown.
+    #[test]
+    fn section_relocations_with_maps() {
+        let mut map = RelocationMap::default();
+        let () = map.insert(0x0, 0xFF, false);
+
+        let mut maps = HashMap::new();
+        let _prev = maps.insert(3, map);
+
+        let relocs = SectionRelocations::new(maps);
+        assert_eq!(relocs.get(3).relocate(0x0, 0), 0xFF);
+        assert_eq!(relocs.get(7).relocate(0x0, 42), 42);
+    }
+}

src/elf/types.rs

@@ -850,6 +850,18 @@ mod tests {
 
         let sym = Elf64_Sym::default();
         assert_ne!(format!("{sym:?}"), "");
+
+        let rela64 = Elf64_Rela::default();
+        assert_ne!(format!("{rela64:?}"), "");
+
+        let rela32 = Elf32_Rela::default();
+        assert_ne!(format!("{rela32:?}"), "");
+
+        let rel64 = Elf64_Rel::default();
+        assert_ne!(format!("{rel64:?}"), "");
+
+        let rel32 = Elf32_Rel::default();
+        assert_ne!(format!("{rel32:?}"), "");
     }
 
     /// Exercise some trivial type conversion functions.
@@ -864,6 +876,12 @@ mod tests {
         let sym = Elf32_Sym::default();
         let _sym64 = Elf64_Sym::from(&sym);
 
+        let rela32 = Elf32_Rela::default();
+        let _rela64 = Elf64_Rela::from(&rela32);
+
+        let rel32 = Elf32_Rel::default();
+        let _rel64 = Elf64_Rel::from(&rel32);
+
         let syms = [sym];
         let syms = ElfN_Syms::B32(Cow::Borrowed(&syms));
         let _syms = syms.to_owned();
@@ -898,5 +916,32 @@ mod tests {
         let _val = sym.size();
         let _val = sym.type_();
         let _val = sym.shndx();
+
+        // Test sym() accessor on Rela/Rel types with non-default r_info values.
+        // 32-bit: sym index is r_info >> 8
+        let rela32 = Elf32_Rela {
+            r_info: 0x0000_0500,
+            ..Default::default()
+        };
+        assert_eq!(rela32.sym(), 5);
+
+        // 64-bit: sym index is r_info >> 32
+        let rela64 = Elf64_Rela {
+            r_info: 0x0000_0007_0000_0000,
+            ..Default::default()
+        };
+        assert_eq!(rela64.sym(), 7);
+
+        let rel32 = Elf32_Rel {
+            r_info: 0x0000_0300,
+            ..Default::default()
+        };
+        assert_eq!(rel32.sym(), 3);
+
+        let rel64 = Elf64_Rel {
+            r_info: 0x0000_000A_0000_0000,
+            ..Default::default()
+        };
+        assert_eq!(rel64.sym(), 10);
     }
 }