Fix tests for serde feature

Correct some typos too

Co-authored-by: Giovanni Zaccaria <[email protected]>

Author: cfvescovo

Cargo.toml

@@ -20,5 +20,4 @@ serde = { version = "1.0.209", optional = true }
 
 [dev-dependencies]
 serde = "1.0.209"
-serde_json = "1.0.127"
 serde_test = "1.0.177"

src/lib.rs

@@ -38,20 +38,11 @@
 use std::fmt::{self, Debug, Display, Formatter};
 use std::num::NonZeroUsize;
 
-/// Implement serde traits for Tree
-///
-/// ```
-/// use ego_tree::{tree, Tree};
-///
-/// let tree = tree!("a" => {"b", "c" => {"d", "e"}, "f"});
-/// let repr = serde_json::to_string(&tree).unwrap();
-/// let re_tree: Tree<&str> = serde_json::from_str(&repr).unwrap();
-/// ```
-///
+/// Implement serde::Serialize and serde::Deserialize traits for Tree
 ///
 /// # Warning
 /// Serialize and Deserialize implementations are recursive. They require an amount of stack memory
-/// propotional to the tree depth.
+/// proportional to the tree depth.
 #[cfg(feature = "serde")]
 pub mod serde;
 
@@ -72,7 +63,7 @@ pub struct NodeId(NonZeroUsize);
 impl NodeId {
     // Safety: `n` must not equal `usize::MAX`.
     // (This is never the case for `Vec::len()`, that would mean it owns
-    // the entire address space without leaving space for even the its pointer.)
+    // the entire address space without leaving space even for its pointer.)
     unsafe fn from_index(n: usize) -> Self {
         NodeId(NonZeroUsize::new_unchecked(n + 1))
     }
@@ -92,7 +83,7 @@ struct Node<T> {
 }
 
 fn _static_assert_size_of_node() {
-    // "Instanciating" the generic `transmute` function without calling it
+    // "Instantiating" the generic `transmute` function without calling it
     // still triggers the magic compile-time check
     // that input and output types have the same `size_of()`.
     let _ = std::mem::transmute::<Node<()>, [usize; 5]>;

tests/serde.rs

@@ -1,21 +1,32 @@
 #![cfg(feature = "serde")]
 
-use ego_tree::{tree, Tree};
+use ego_tree::tree;
 use serde_test::{assert_tokens, Token};
 
 #[test]
-fn test_serde_round_trip() {
-    let tree = tree!("a" => {"b", "c" => {"d", "e"}, "f"});
-    let repr = serde_json::to_string(&tree).unwrap();
-    println!("{repr}");
-    let re_tree: Tree<&str> = serde_json::from_str(&repr).unwrap();
-    println!("{re_tree}");
-    assert_eq!(tree, re_tree);
+fn test_internal_serde_repr_trivial() {
+    let tree = tree!("a");
+
+    assert_tokens(
+        &tree,
+        &[
+            Token::Struct {
+                name: "Node",
+                len: 2,
+            },
+            Token::BorrowedStr("value"),
+            Token::BorrowedStr("a"),
+            Token::BorrowedStr("children"),
+            Token::Seq { len: Some(0) },
+            Token::SeqEnd,
+            Token::StructEnd,
+        ],
+    );
 }
 
 #[test]
 fn test_internal_serde_repr() {
-    let tree = tree!("a");
+    let tree = tree!("a" => {"b", "c" => {"d", "e"}, "f"});
 
     assert_tokens(
         &tree,
@@ -24,12 +35,62 @@ fn test_internal_serde_repr() {
                 name: "Node",
                 len: 2,
             },
-            Token::Str("value"),
-            Token::Str("a"),
-            Token::Str("children"),
+            Token::BorrowedStr("value"),
+            Token::BorrowedStr("a"),
+            Token::BorrowedStr("children"),
+            Token::Seq { len: Some(3) },
+            Token::Struct {
+                name: "Node",
+                len: 2,
+            },
+            Token::BorrowedStr("value"),
+            Token::BorrowedStr("b"),
+            Token::BorrowedStr("children"),
+            Token::Seq { len: Some(0) },
+            Token::SeqEnd,
+            Token::StructEnd,
+            Token::Struct {
+                name: "Node",
+                len: 2,
+            },
+            Token::BorrowedStr("value"),
+            Token::BorrowedStr("c"),
+            Token::BorrowedStr("children"),
+            Token::Seq { len: Some(2) },
+            Token::Struct {
+                name: "Node",
+                len: 2,
+            },
+            Token::BorrowedStr("value"),
+            Token::BorrowedStr("d"),
+            Token::BorrowedStr("children"),
             Token::Seq { len: Some(0) },
             Token::SeqEnd,
             Token::StructEnd,
+            Token::Struct {
+                name: "Node",
+                len: 2,
+            },
+            Token::BorrowedStr("value"),
+            Token::BorrowedStr("e"),
+            Token::BorrowedStr("children"),
+            Token::Seq { len: Some(0) },
+            Token::SeqEnd,
+            Token::StructEnd,
+            Token::SeqEnd,
+            Token::StructEnd,
+            Token::Struct {
+                name: "Node",
+                len: 2,
+            },
+            Token::BorrowedStr("value"),
+            Token::BorrowedStr("f"),
+            Token::BorrowedStr("children"),
+            Token::Seq { len: Some(0) },
+            Token::SeqEnd,
+            Token::StructEnd,
+            Token::SeqEnd,
+            Token::StructEnd,
         ],
     );
 }