Show more error details in parse tests failures

Author: epage

gix-actor/src/signature/decode.rs

@@ -86,9 +86,7 @@ mod tests {
 
         use crate::{signature, SignatureRef, Time};
 
-        fn decode<'i>(
-            i: &mut &'i [u8],
-        ) -> PResult<SignatureRef<'i>, winnow::error::VerboseError<&'i [u8], &'static str>> {
+        fn decode<'i>(i: &mut &'i [u8]) -> PResult<SignatureRef<'i>, winnow::error::TreeError<&'i [u8], &'static str>> {
             signature::decode.parse_next(i)
         }
 
@@ -165,7 +163,7 @@ mod tests {
                             .map_err(to_bstr_err)
                             .expect_err("parse fails as > is missing")
                             .to_string(),
-                        "Parse error:\nslice at:  12345 -1215\nin section '<email>', at:  12345 -1215\nin section '<name> <<email>>', at:  12345 -1215\nin section '<name> <<email>> <timestamp> <+|-><HHMM>', at:  12345 -1215\n"
+                        "in slice at ' 12345 -1215'\n  0: <email> at ' 12345 -1215'\n  1: <name> <<email>> at ' 12345 -1215'\n  2: <name> <<email>> <timestamp> <+|-><HHMM> at ' 12345 -1215'\n"
                     );
         }
 
@@ -176,7 +174,7 @@ mod tests {
                             .map_err(to_bstr_err)
                             .expect_err("parse fails as > is missing")
                             .to_string(),
-                        "Parse error:\npredicate verification at: abc -1215\nin section '<timestamp>', at: abc -1215\nin section '<name> <<email>> <timestamp> <+|-><HHMM>', at: abc -1215\n"
+                        "in predicate verification at 'abc -1215'\n  0: <timestamp> at 'abc -1215'\n  1: <name> <<email>> <timestamp> <+|-><HHMM> at 'abc -1215'\n"
                     );
         }
     }

gix-ref/src/store/file/log/line.rs

@@ -181,14 +181,14 @@ pub mod decode {
 
         mod invalid {
             use gix_testtools::to_bstr_err;
-            use winnow::error::VerboseError;
+            use winnow::error::TreeError;
             use winnow::prelude::*;
 
             use super::one;
 
             #[test]
             fn completely_bogus_shows_error_with_context() {
-                let err = one::<VerboseError<&[u8], &'static str>>
+                let err = one::<TreeError<&[u8], &'static str>>
                     .parse_peek(b"definitely not a log entry")
                     .map_err(to_bstr_err)
                     .expect_err("this should fail");
@@ -198,7 +198,7 @@ pub mod decode {
             #[test]
             fn missing_whitespace_between_signature_and_message() {
                 let line = "0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 one <[email protected]> 1234567890 -0000message";
-                let err = one::<VerboseError<&[u8], &'static str>>
+                let err = one::<TreeError<&[u8], &'static str>>
                     .parse_peek(line.as_bytes())
                     .map_err(to_bstr_err)
                     .expect_err("this should fail");

gix-ref/src/store/packed/decode/tests.rs

@@ -1,7 +1,7 @@
 type Result = std::result::Result<(), Box<dyn std::error::Error>>;
 
 mod reference {
-    use winnow::error::VerboseError;
+    use winnow::error::TreeError;
     use winnow::prelude::*;
 
     use super::Result;
@@ -32,7 +32,7 @@ mod reference {
     fn two_refs_in_a_row() -> Result {
         let input: &[u8] = b"d53c4b0f91f1b29769c9430f2d1c0bcab1170c75 refs/heads/alternates-after-packs-and-loose
 ^e9cdc958e7ce2290e2d7958cdb5aa9323ef35d37\neaae9c1bc723209d793eb93f5587fa2604d5cd92 refs/heads/avoid-double-lookup\n";
-        let (input, parsed) = decode::reference::<VerboseError<_>>.parse_peek(input).unwrap();
+        let (input, parsed) = decode::reference::<TreeError<_>>.parse_peek(input).unwrap();
 
         assert_eq!(
             parsed,
@@ -45,7 +45,7 @@ mod reference {
         assert_eq!(parsed.target(), hex_to_id("d53c4b0f91f1b29769c9430f2d1c0bcab1170c75"));
         assert_eq!(parsed.object(), hex_to_id("e9cdc958e7ce2290e2d7958cdb5aa9323ef35d37"));
 
-        let (input, parsed) = decode::reference::<VerboseError<_>>.parse_peek(input).unwrap();
+        let (input, parsed) = decode::reference::<TreeError<_>>.parse_peek(input).unwrap();
         assert!(input.is_empty(), "exhausted");
         assert_eq!(
             parsed.name,
@@ -87,7 +87,7 @@ mod header {
     #[test]
     fn valid_fully_peeled_stored() -> Result {
         let input: &[u8] = b"# pack-refs with: peeled fully-peeled sorted  \nsomething else";
-        let (rest, header) = decode::header::<winnow::error::VerboseError<_, &'static str>>
+        let (rest, header) = decode::header::<winnow::error::TreeError<_, &'static str>>
             .parse_peek(input)
             .map_err(to_bstr_err)?;
 

tests/tools/src/lib.rs

@@ -19,7 +19,7 @@ pub use once_cell;
 use once_cell::sync::Lazy;
 use parking_lot::Mutex;
 pub use tempfile;
-use winnow::error::VerboseError;
+use winnow::error::TreeError;
 
 /// A result type to allow using the try operator `?` in unit tests.
 ///
@@ -693,8 +693,8 @@ fn extract_archive(
 
 /// Transform a verbose bom errors from raw bytes into a `BStr` to make printing/debugging human-readable.
 pub fn to_bstr_err<'i>(
-    err: winnow::error::ErrMode<VerboseError<&'i [u8], &'static str>>,
-) -> VerboseError<&'i BStr, &'static str> {
+    err: winnow::error::ErrMode<TreeError<&'i [u8], &'static str>>,
+) -> TreeError<&'i BStr, &'static str> {
     let err = err.into_inner().expect("not a streaming parser");
     err.map_input(ByteSlice::as_bstr)
 }