lib: refactor logic for adding custom_root to decoded registers

lib/src/record/decode.rs

@@ -147,28 +147,25 @@ impl Record {
 
     /// Decodes the [Record] header into a [Node] tree.
     pub fn decode_without_cm(&self) -> Node {
-        let root_path = self.get_root_path();
-        self.decode_header(&root_path)
-    }
+        let header = self.decode_header();
 
-    #[cfg(feature = "collateral_manager")]
-    fn decode_header_using_cm<T: CollateralTree>(&self, cm: &mut CollateralManager<T>) -> Node {
-        let root_path = self.get_root_path_using_cm(cm);
-        self.decode_header(&root_path)
+        let mut root = Node::root();
+        let record_root = if let Some(custom_root) = self.get_root_path() {
+            root.create_hierarchy(&custom_root)
+        } else {
+            &mut root
+        };
+
+        record_root.merge(header);
+        root
     }
 
-    fn decode_header(&self, root_path: &Option<String>) -> Node {
+    fn decode_header(&self) -> Node {
         let mut record = Node::record(self.header.record_type().unwrap_or("record"));
         record.add(Node::from(&self.header));
 
         let mut root = Node::root();
-        let record_root = if let Some(custom_root) = root_path {
-            root.create_hierarchy(custom_root)
-        } else {
-            &mut root
-        };
-
-        record_root.add(record);
+        root.add(record);
         root
     }
 
@@ -216,18 +213,13 @@ impl Record {
         let paths = self.header.decode_definitions_paths(cm)?;
 
         let mut root = Node::root();
-        let record_root = if let Some(custom_root) = self.get_root_path_using_cm(cm) {
-            root.create_hierarchy(&custom_root)
-        } else {
-            &mut root
-        };
 
         for mut path in paths {
             path.push(decode_def);
             let Ok(layout) = cm.get_item_with_header(&self.header, path) else {
                 continue;
             };
-            record_root.merge(self.decode_with_csv(layout, offset)?);
+            root.merge(self.decode_with_csv(layout, offset)?);
             return Ok(root);
         }
 
@@ -238,19 +230,29 @@ impl Record {
     /// collateral tree.
     #[cfg(feature = "collateral_manager")]
     pub fn decode<T: CollateralTree>(&self, cm: &mut CollateralManager<T>) -> Node {
-        let root =
+        let record =
             if let record_types::PCORE | record_types::ECORE = self.header.version.record_type {
                 self.decode_as_core_record(cm)
             } else {
                 self.decode_with_decode_def(cm, "layout.csv", 0)
             };
 
-        match root {
+        let record_node = match record {
             Ok(node) => node,
             Err(err) => {
                 log::warn!("Cannot decode record: {err}. Only the header fields will be decoded.");
-                self.decode_header_using_cm(cm)
+                self.decode_header()
             }
-        }
+        };
+
+        let mut root = Node::root();
+        let record_root = if let Some(custom_root) = self.get_root_path_using_cm(cm) {
+            root.create_hierarchy(&custom_root)
+        } else {
+            &mut root
+        };
+
+        record_root.merge(record_node);
+        root
     }
 }

lib/tests/crashlog.rs

@@ -36,3 +36,39 @@ fn invalid_box_record() {
     let crashlog = CrashLog::from_slice(&data);
     assert!(crashlog.is_ok());
 }
+
+#[test]
+fn core_box_header_type6() {
+    let data = std::fs::read("tests/samples/three_strike_timeout_box.crashlog").unwrap();
+    let crashlog = CrashLog::from_slice(&data).unwrap();
+
+    let mut cm = CollateralManager::embedded_tree().unwrap();
+    let root = crashlog.decode(&mut cm);
+
+    let entry0 = root
+        .get_by_path("processors.cpu0.die8.core0.sq.entry0")
+        .unwrap();
+
+    assert_eq!(
+        entry0.kind,
+        NodeType::Field {
+            value: 0x47bcc051082
+        }
+    );
+
+    let record_type_box = root
+        .get_by_path("processors.cpu0.die8.box.hdr.version.record_type")
+        .unwrap();
+    assert_eq!(record_type_box.kind, NodeType::Field { value: 0x3d });
+
+    let bank3 = root
+        .get_by_path("processors.cpu0.die8.core0.thread.arch_state.mca.bank3.status")
+        .unwrap();
+
+    assert_eq!(
+        bank3.kind,
+        NodeType::Field {
+            value: 0xbe000000e1840400
+        }
+    );
+}