diff --git a/libs/libfdt/src/lib.rs b/libs/libfdt/src/lib.rs
index 0a97141..96ac3f4 100644
--- a/libs/libfdt/src/lib.rs
+++ b/libs/libfdt/src/lib.rs
@@ -499,6 +499,12 @@
     }
 }
 
+impl<'a> PartialEq for FdtNode<'a> {
+    fn eq(&self, other: &Self) -> bool {
+        self.fdt.as_ptr() == other.fdt.as_ptr() && self.offset == other.offset
+    }
+}
+
 /// Phandle of a FDT node
 #[repr(transparent)]
 #[derive(Debug, Copy, Clone, PartialEq)]
@@ -535,6 +541,7 @@
 }
 
 /// Mutable FDT node.
+#[derive(Debug)]
 pub struct FdtNodeMut<'a> {
     fdt: &'a mut Fdt,
     offset: c_int,
diff --git a/libs/libfdt/tests/api_test.rs b/libs/libfdt/tests/api_test.rs
index bd2b306..78bb618 100644
--- a/libs/libfdt/tests/api_test.rs
+++ b/libs/libfdt/tests/api_test.rs
@@ -42,7 +42,7 @@
     const EXPECTED_FIRST_MEMORY_RANGE: Range<usize> = 0..256;
     let mut memory = fdt.memory().unwrap();
     assert_eq!(memory.next(), Some(EXPECTED_FIRST_MEMORY_RANGE));
-    assert!(memory.next().is_none());
+    assert_eq!(memory.next(), None);
     assert_eq!(fdt.first_memory_range(), Ok(EXPECTED_FIRST_MEMORY_RANGE));
 }
 
@@ -56,7 +56,7 @@
     let mut memory = fdt.memory().unwrap();
     assert_eq!(memory.next(), Some(EXPECTED_FIRST_MEMORY_RANGE));
     assert_eq!(memory.next(), Some(EXPECTED_SECOND_MEMORY_RANGE));
-    assert!(memory.next().is_none());
+    assert_eq!(memory.next(), None);
     assert_eq!(fdt.first_memory_range(), Ok(EXPECTED_FIRST_MEMORY_RANGE));
 }
 
@@ -66,7 +66,7 @@
     let fdt = Fdt::from_slice(&data).unwrap();
 
     let mut memory = fdt.memory().unwrap();
-    assert!(memory.next().is_none());
+    assert_eq!(memory.next(), None);
     assert_eq!(fdt.first_memory_range(), Err(FdtError::NotFound));
 }
 
@@ -85,14 +85,14 @@
     let fdt = Fdt::from_slice(&data).unwrap();
 
     let root = fdt.root().unwrap();
-    assert_eq!(root.name().unwrap().to_str().unwrap(), "");
+    assert_eq!(root.name(), Ok(cstr!("")));
 
     let chosen = fdt.chosen().unwrap().unwrap();
-    assert_eq!(chosen.name().unwrap().to_str().unwrap(), "chosen");
+    assert_eq!(chosen.name(), Ok(cstr!("chosen")));
 
     let nested_node_path = cstr!("/cpus/PowerPC,970@0");
     let nested_node = fdt.node(nested_node_path).unwrap().unwrap();
-    assert_eq!(nested_node.name().unwrap().to_str().unwrap(), "PowerPC,970@0");
+    assert_eq!(nested_node.name(), Ok(cstr!("PowerPC,970@0")));
 }
 
 #[test]
@@ -100,10 +100,10 @@
     let data = fs::read(TEST_TREE_WITH_NO_MEMORY_NODE_PATH).unwrap();
     let fdt = Fdt::from_slice(&data).unwrap();
     let root = fdt.root().unwrap();
-    let expected: Vec<&str> = vec!["cpus", "randomnode", "chosen"];
+    let expected = [cstr!("cpus"), cstr!("randomnode"), cstr!("chosen")];
 
     for (node, name) in root.subnodes().unwrap().zip(expected) {
-        assert_eq!(node.name().unwrap().to_str().unwrap(), name);
+        assert_eq!(node.name(), Ok(name));
     }
 }
 
@@ -113,17 +113,17 @@
     let fdt = Fdt::from_slice(&data).unwrap();
     let root = fdt.root().unwrap();
     let one_be = 0x1_u32.to_be_bytes();
-    let expected: Vec<(&str, &[u8])> = vec![
-        ("model", b"MyBoardName\0"),
-        ("compatible", b"MyBoardName\0MyBoardFamilyName\0"),
-        ("#address-cells", &one_be),
-        ("#size-cells", &one_be),
-        ("empty_prop", b""),
+    let expected = [
+        (cstr!("model"), b"MyBoardName\0".as_ref()),
+        (cstr!("compatible"), b"MyBoardName\0MyBoardFamilyName\0".as_ref()),
+        (cstr!("#address-cells"), &one_be),
+        (cstr!("#size-cells"), &one_be),
+        (cstr!("empty_prop"), &[]),
     ];
 
-    for (prop, (name, value)) in root.properties().unwrap().zip(expected) {
-        assert_eq!(prop.name().unwrap().to_str().unwrap(), name);
-        assert_eq!(prop.value().unwrap(), value);
+    let properties = root.properties().unwrap();
+    for (prop, (name, value)) in properties.zip(expected.into_iter()) {
+        assert_eq!((prop.name(), prop.value()), (Ok(name), Ok(value)));
     }
 }
 
@@ -132,11 +132,11 @@
     let data = fs::read(TEST_TREE_WITH_NO_MEMORY_NODE_PATH).unwrap();
     let fdt = Fdt::from_slice(&data).unwrap();
     let node = fdt.node(cstr!("/cpus/PowerPC,970@1")).unwrap().unwrap();
-    let expected = &["", "cpus", "PowerPC,970@1"];
+    let expected = [cstr!(""), cstr!("cpus"), cstr!("PowerPC,970@1")];
 
-    for (depth, expect) in expected.iter().enumerate() {
+    for (depth, name) in expected.into_iter().enumerate() {
         let supernode = node.supernode_at_depth(depth).unwrap();
-        assert_eq!(supernode.name().unwrap().to_str().unwrap(), *expect);
+        assert_eq!(supernode.name(), Ok(name));
     }
 }
 
@@ -172,8 +172,9 @@
 fn max_phandle() {
     let data = fs::read(TEST_TREE_PHANDLE_PATH).unwrap();
     let fdt = Fdt::from_slice(&data).unwrap();
+    let phandle = Phandle::new(0xFF).unwrap();
 
-    assert_eq!(fdt.max_phandle().unwrap(), Phandle::new(0xFF).unwrap());
+    assert_eq!(fdt.max_phandle(), Ok(phandle));
 }
 
 #[test]
@@ -182,32 +183,36 @@
     let fdt = Fdt::from_slice(&data).unwrap();
 
     // Test linux,phandle
-    let node = fdt.node_with_phandle(Phandle::new(0xFF).unwrap()).unwrap().unwrap();
-    assert_eq!(node.name().unwrap().to_str().unwrap(), "node_zz");
+    let phandle = Phandle::new(0xFF).unwrap();
+    let node = fdt.node_with_phandle(phandle).unwrap().unwrap();
+    assert_eq!(node.name(), Ok(cstr!("node_zz")));
 
     // Test phandle
-    let node = fdt.node_with_phandle(Phandle::new(0x22).unwrap()).unwrap().unwrap();
-    assert_eq!(node.name().unwrap().to_str().unwrap(), "node_abc");
+    let phandle = Phandle::new(0x22).unwrap();
+    let node = fdt.node_with_phandle(phandle).unwrap().unwrap();
+    assert_eq!(node.name(), Ok(cstr!("node_abc")));
 }
 
 #[test]
 fn node_nop() {
     let mut data = fs::read(TEST_TREE_PHANDLE_PATH).unwrap();
     let fdt = Fdt::from_mut_slice(&mut data).unwrap();
+    let phandle = Phandle::new(0xFF).unwrap();
+    let path = cstr!("/node_z/node_zz");
 
-    fdt.node_with_phandle(Phandle::new(0xFF).unwrap()).unwrap().unwrap();
-    let node = fdt.node_mut(cstr!("/node_z/node_zz")).unwrap().unwrap();
+    fdt.node_with_phandle(phandle).unwrap().unwrap();
+    let node = fdt.node_mut(path).unwrap().unwrap();
 
     node.nop().unwrap();
 
-    assert!(fdt.node_with_phandle(Phandle::new(0xFF).unwrap()).unwrap().is_none());
-    assert!(fdt.node(cstr!("/node_z/node_zz")).unwrap().is_none());
+    assert_eq!(fdt.node_with_phandle(phandle), Ok(None));
+    assert_eq!(fdt.node(path), Ok(None));
 
     fdt.unpack().unwrap();
     fdt.pack().unwrap();
 
-    assert!(fdt.node_with_phandle(Phandle::new(0xFF).unwrap()).unwrap().is_none());
-    assert!(fdt.node(cstr!("/node_z/node_zz")).unwrap().is_none());
+    assert_eq!(fdt.node_with_phandle(phandle), Ok(None));
+    assert_eq!(fdt.node(path), Ok(None));
 }
 
 #[test]
@@ -236,7 +241,8 @@
     for len in 1..subnode_name.to_bytes().len() {
         let name = String::from_utf8(subnode_name.to_bytes()[..len].to_vec()).unwrap();
         let path = CString::new(format!("{node_path}/{name}")).unwrap();
+        let name = CString::new(name).unwrap();
         let subnode = fdt.node(&path).unwrap().unwrap();
-        assert_eq!(subnode.name().unwrap().to_str().unwrap(), name);
+        assert_eq!(subnode.name(), Ok(name.as_c_str()));
     }
 }