Use pretty_assertions_sorted

Cargo.toml

@@ -13,3 +13,6 @@ rust-version = "1.72.0"
 nom = "7.1"
 nom-span = "0.1.1"
 thiserror = "1.0.50"
+
+[dev-dependencies]
+pretty_assertions_sorted = "1.2.3"

src/tests/blocks/block.rs

@@ -3,6 +3,7 @@ mod simple {
         error::{Error, ErrorKind},
         Err,
     };
+    use pretty_assertions_sorted::assert_eq;
 
     use crate::{
         blocks::Block,

src/tests/blocks/simple.rs

@@ -2,6 +2,7 @@ use nom::{
     error::{Error, ErrorKind},
     Err,
 };
+use pretty_assertions_sorted::assert_eq;
 
 use crate::{
     blocks::SimpleBlock,

src/tests/document.rs

@@ -1,3 +1,5 @@
+use pretty_assertions_sorted::assert_eq;
+
 use crate::{
     tests::fixtures::{
         blocks::{TBlock, TSimpleBlock},

src/tests/fixtures/blocks/simple.rs

@@ -1,10 +1,23 @@
+use std::fmt;
+
 use crate::{blocks::SimpleBlock, tests::fixtures::TSpan};
 
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Eq, PartialEq)]
 pub(crate) struct TSimpleBlock {
     pub inlines: Vec<TSpan>,
 }
 
+impl fmt::Debug for TSimpleBlock {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Intentionally mimic the output of nom_span::Spanned
+        // so diffs point the unit test author to the important
+        // differences.
+        f.debug_struct("SimpleBlock")
+            .field("inlines", &self.inlines)
+            .finish()
+    }
+}
+
 impl<'a> PartialEq<SimpleBlock<'a>> for TSimpleBlock {
     fn eq(&self, other: &SimpleBlock<'a>) -> bool {
         tsimple_block_eq(self, other)

src/tests/fixtures/document.rs

@@ -1,4 +1,4 @@
-use std::cmp::PartialEq;
+use std::{cmp::PartialEq, fmt};
 
 use crate::{
     tests::fixtures::{blocks::TBlock, TSpan},
@@ -10,12 +10,24 @@ use crate::{
 //
 // Primary difference is that the data members are public
 // so we can declare them inline.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Eq, PartialEq)]
 pub(crate) struct TDocument {
     pub blocks: Vec<TBlock>,
     pub source: TSpan,
 }
 
+impl fmt::Debug for TDocument {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Intentionally mimic the output of nom_span::Spanned
+        // so diffs point the unit test author to the important
+        // differences.
+        f.debug_struct("Document")
+            .field("blocks", &self.blocks)
+            .field("source", &self.source)
+            .finish()
+    }
+}
+
 impl<'a> PartialEq<Document<'a>> for TDocument {
     fn eq(&self, other: &Document<'a>) -> bool {
         tdocument_eq(self, other)

src/tests/fixtures/span.rs

@@ -1,4 +1,4 @@
-use std::cmp::PartialEq;
+use std::{cmp::PartialEq, fmt};
 
 use crate::Span;
 
@@ -7,14 +7,29 @@ use crate::Span;
 //
 // Primary difference is that the data members are public
 // so we can declare them inline.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Eq, PartialEq)]
 pub(crate) struct TSpan {
     pub data: &'static str,
     pub line: usize,
     pub col: usize,
     pub offset: usize,
 }
 
+impl fmt::Debug for TSpan {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Intentionally mimic the output of nom_span::Spanned
+        // so diffs point the unit test author to the important
+        // differences.
+        f.debug_struct("Spanned")
+            .field("data", &self.data)
+            .field("line", &self.line)
+            .field("col", &self.col)
+            .field("offset", &self.offset)
+            .field("handle_utf8", &true)
+            .finish()
+    }
+}
+
 impl<'a> PartialEq<Span<'a>> for TSpan {
     fn eq(&self, other: &Span<'a>) -> bool {
         tspan_eq(self, other)

src/tests/primitives/line.rs

@@ -1,4 +1,6 @@
 mod fn_line {
+    use pretty_assertions_sorted::assert_eq;
+
     use crate::{primitives::line, tests::fixtures::TSpan, Span};
 
     #[test]
@@ -186,6 +188,8 @@ mod fn_line {
 }
 
 mod normalized_line {
+    use pretty_assertions_sorted::assert_eq;
+
     use crate::{primitives::normalized_line, tests::fixtures::TSpan, Span};
 
     #[test]
@@ -402,6 +406,7 @@ mod non_empty_line {
         error::{Error, ErrorKind},
         Err,
     };
+    use pretty_assertions_sorted::assert_eq;
 
     use crate::{primitives::non_empty_line, tests::fixtures::TSpan, Span};
 
@@ -589,6 +594,7 @@ mod empty_line {
         error::{Error, ErrorKind},
         Err,
     };
+    use pretty_assertions_sorted::assert_eq;
 
     use crate::{primitives::empty_line, tests::fixtures::TSpan, Span};
 
@@ -786,6 +792,8 @@ mod empty_line {
 }
 
 mod consume_empty_lines {
+    use pretty_assertions_sorted::assert_eq;
+
     use crate::{primitives::consume_empty_lines, tests::fixtures::TSpan, Span};
 
     #[test]