feat: 更新版本号至 0.1.4，优化节点遍历和删除逻辑，增强测试用例

Author: ZR233

fdt-edit/Cargo.toml

@@ -11,7 +11,7 @@ license = "MIT OR Apache-2.0"
 name = "fdt-edit"
 readme = "README.md"
 repository = "https://github.com/drivercraft/fdt-parser"
-version = "0.1.3"
+version = "0.1.4"
 
 [dependencies]
 enum_dispatch = "0.3.13"

fdt-edit/src/ctx.rs

@@ -134,7 +134,7 @@ impl<'a> Context<'a> {
         if let Some(phandle) = node.phandle() {
             map.insert(phandle, node);
         }
-        for child in &node.children {
+        for child in node.children() {
             Self::build_phandle_map_from_node(child, map);
         }
     }

fdt-edit/src/fdt.rs

@@ -124,7 +124,7 @@ impl Fdt {
         }
 
         // 递归处理子节点
-        for child in &node.children {
+        for child in node.children() {
             let child_name = child.name();
             let child_path = if current_path == "/" {
                 format!("/{}", child_name)
@@ -211,7 +211,7 @@ impl Fdt {
     /// ```
     pub fn apply_overlay(&mut self, overlay: &Fdt) -> Result<(), FdtError> {
         // 遍历 overlay 根节点的所有子节点
-        for child in &overlay.root.children {
+        for child in overlay.root.children() {
             if child.name().starts_with("fragment@") || child.name() == "fragment" {
                 // fragment 格式
                 self.apply_fragment(child)?;
@@ -515,7 +515,7 @@ impl core::fmt::Debug for Fdt {
                 .field("boot_cpuid_phys", &self.boot_cpuid_phys)
                 .field("memory_reservations_count", &self.memory_reservations.len())
                 .field("root_node_name", &self.root.name)
-                .field("total_nodes", &self.root.children.len())
+                .field("total_nodes", &self.root.children().len())
                 .field("phandle_cache_size", &self.phandle_cache.len())
                 .finish()
         }

fdt-edit/src/node/mod.rs

@@ -41,8 +41,8 @@ pub struct Node {
     pub(crate) properties: Vec<Property>,
     /// 属性名到索引的映射（用于快速查找）
     pub(crate) prop_cache: BTreeMap<String, usize>,
-    pub(crate) children: Vec<Node>,
-    pub(crate) name_cache: BTreeMap<String, usize>,
+    children: Vec<Node>,
+    name_cache: BTreeMap<String, usize>,
 }
 
 impl Node {
@@ -64,8 +64,8 @@ impl Node {
         self.properties.iter()
     }
 
-    pub fn children(&self) -> impl Iterator<Item = &Node> {
-        self.children.iter()
+    pub fn children(&self) -> &[Node] {
+        &self.children
     }
 
     pub fn children_mut(&mut self) -> impl Iterator<Item = &mut Node> {
@@ -87,27 +87,41 @@ impl Node {
 
     pub fn get_child(&self, name: &str) -> Option<&Node> {
         if let Some(&index) = self.name_cache.get(name) {
-            self.children.get(index)
-        } else {
-            None
+            if let Some(child) = self.children.get(index) {
+                return Some(child);
+            }
         }
+
+        // Fallback if the cache is stale
+        self.children.iter().find(|c| c.name == name)
     }
 
     pub fn get_child_mut(&mut self, name: &str) -> Option<&mut Node> {
         if let Some(&index) = self.name_cache.get(name) {
-            self.children.get_mut(index)
-        } else {
-            None
+            if index < self.children.len() && self.children[index].name == name {
+                return self.children.get_mut(index);
+            }
         }
+
+        // Cache miss or mismatch: search and rebuild cache to keep indices in sync
+        let pos = self.children.iter().position(|c| c.name == name)?;
+        self.rebuild_name_cache();
+        self.children.get_mut(pos)
     }
 
     pub fn remove_child(&mut self, name: &str) -> Option<Node> {
-        if let Some(&index) = self.name_cache.get(name) {
-            self.name_cache.remove(name);
-            Some(self.children.remove(index))
-        } else {
-            None
-        }
+        let index = self
+            .name_cache
+            .get(name)
+            .copied()
+            .filter(|&idx| self.children.get(idx).map(|c| c.name.as_str()) == Some(name))
+            .or_else(|| self.children.iter().position(|c| c.name == name));
+
+        let Some(idx) = index else { return None };
+
+        let removed = self.children.remove(idx);
+        self.rebuild_name_cache();
+        Some(removed)
     }
 
     pub fn set_property(&mut self, prop: Property) {
@@ -208,6 +222,13 @@ impl Node {
         Some(entries)
     }
 
+    fn rebuild_name_cache(&mut self) {
+        self.name_cache.clear();
+        for (idx, child) in self.children.iter().enumerate() {
+            self.name_cache.insert(child.name.clone(), idx);
+        }
+    }
+
     pub fn compatible(&self) -> Option<StrIter<'_>> {
         let prop = self.get_property("compatible")?;
         Some(prop.as_str_iter())
@@ -259,11 +280,10 @@ impl Node {
         if parts.is_empty() {
             return Err(fdt_raw::FdtError::InvalidInput);
         }
-
         if parts.len() == 1 {
             // 删除直接子节点（精确匹配）
             let child_name = parts[0];
-            Ok(self.remove_child_exact(child_name))
+            Ok(self.remove_child(child_name))
         } else {
             // 需要递归到父节点进行删除
             self.remove_child_recursive(&parts, 0)
@@ -280,7 +300,7 @@ impl Node {
         if index >= parts.len() - 1 {
             // 已经到达要删除节点的父级
             let child_name_to_remove = parts[index];
-            Ok(self.remove_child_exact(child_name_to_remove))
+            Ok(self.remove_child(child_name_to_remove))
         } else {
             // 继续向下递归
             let current_part = parts[index];
@@ -294,17 +314,6 @@ impl Node {
             }
         }
     }
-
-    /// 精确删除子节点，不支持部分匹配
-    fn remove_child_exact(&mut self, name: &str) -> Option<Node> {
-        if let Some(&index) = self.name_cache.get(name) {
-            let child = self.children.remove(index);
-            self.name_cache.remove(name);
-            Some(child)
-        } else {
-            None
-        }
-    }
 }
 
 impl From<&fdt_raw::Node<'_>> for Node {

fdt-edit/tests/remove_node.rs

@@ -1,10 +1,23 @@
 #[cfg(test)]
 mod tests {
+    use std::sync::Once;
+
     use dtb_file::fdt_qemu;
     use fdt_edit::*;
 
+    fn init_logging() {
+        static INIT: Once = Once::new();
+        INIT.call_once(|| {
+            let _ = env_logger::builder()
+                .is_test(true)
+                .filter_level(log::LevelFilter::Trace)
+                .try_init();
+        });
+    }
+
     #[test]
     fn test_remove_node_exact_path() {
+        init_logging();
         // 解析原始 DTB
         let raw_data = fdt_qemu();
         let mut fdt = Fdt::from_bytes(&raw_data).unwrap();
@@ -23,6 +36,39 @@ mod tests {
         assert!(node_after.is_none(), "psci 节点应该已被删除");
     }
 
+    #[test]
+    fn test_remove_node_exact_path_parts() {
+        init_logging();
+        // 解析原始 DTB
+        let raw_data = fdt_qemu();
+        let mut fdt = Fdt::from_bytes(&raw_data).unwrap();
+
+        let memory = fdt.find_by_path("/memory").next().unwrap();
+        fdt.remove_node(&memory.path()).unwrap();
+
+        let cpus = fdt.find_by_path("/cpus/cpu").collect::<Vec<_>>();
+        let path = cpus[0].path();
+        println!("Removing node at path: {}", path);
+        // drop(node);
+
+        // 删除节点
+        let removed = fdt.remove_node(&path);
+        assert!(removed.is_ok(), "删除应该成功");
+        assert!(removed.unwrap().is_some(), "应该返回被删除的节点");
+
+        // 验证节点已被删除
+        let node_after = fdt.get_by_path("/cpus/cpu@0");
+        assert!(node_after.is_none(), "cpu 节点应该已被删除");
+
+        let raw = fdt.encode();
+        let fdt2 = Fdt::from_bytes(&raw).unwrap();
+        let node_after_reload = fdt2.get_by_path("/cpus/cpu@0");
+        assert!(
+            node_after_reload.is_none(),
+            "重新加载后 cpu 节点应该已被删除"
+        );
+    }
+
     #[test]
     fn test_remove_nested_node() {
         // 使用手动创建的树测试嵌套删除