Merge pull request #873 from epage/test

test: Sync between toml/toml_edit

Author: epage

Cargo.lock

@@ -1,6 +1,6 @@
 [files]
 extend-exclude = [
-    "crates/toml_edit/tests/snapshots/**",
+    "crates/*/tests/snapshots/**",
     "crates/benchmarks/src/Cargo.*.toml",
 ]
 

_typos.toml

@@ -59,6 +59,7 @@ serde_json = "1.0.116"
 toml-test-harness = { version = "1.3.0", features = ["snapshot"] }
 toml-test-data = "2.3.0"
 snapbox = "0.6.0"
+walkdir = "2.5.0"
 
 [[test]]
 name = "decoder_compliance"

crates/toml/Cargo.toml

@@ -7,16 +7,16 @@ pub(crate) mod de {
 pub(crate) mod de {
     /// Errors that can occur when deserializing a type.
     #[derive(Debug, Clone, PartialEq, Eq)]
-    pub struct Error {
+    pub(crate) struct Error {
         inner: String,
     }
 
     impl Error {
         /// Add key while unwinding
-        pub fn add_key(&mut self, _key: String) {}
+        pub(crate) fn add_key(&mut self, _key: String) {}
 
         /// What went wrong
-        pub fn message(&self) -> &str {
+        pub(crate) fn message(&self) -> &str {
             self.inner.as_str()
         }
     }

crates/toml/src/edit.rs

@@ -1,5 +1,3 @@
-use std::fmt;
-
 use serde::de;
 use serde::ser;
 
@@ -42,8 +40,8 @@ impl Table {
 }
 
 #[cfg(feature = "display")]
-impl fmt::Display for Table {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl std::fmt::Display for Table {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         crate::ser::to_string(self)
             .expect("Unable to represent value as string")
             .fmt(f)

crates/toml/src/table.rs

@@ -0,0 +1,177 @@
+use snapbox::assert_data_eq;
+use snapbox::prelude::*;
+use snapbox::str;
+
+#[track_caller]
+fn t(toml: &str, expected: impl IntoData) {
+    dbg!(toml);
+    match toml.parse::<crate::RustDocument>() {
+        Ok(s) => panic!("parsed to: {s:#?}"),
+        Err(e) => assert_data_eq!(e.to_string(), expected.raw()),
+    }
+}
+
+#[test]
+fn basic_string_escape() {
+    t(
+        "a = \"\u{7f}\"",
+        str![[r#"
+TOML parse error at line 1, column 6
+  |
+1 | a = ""
+  |      ^
+invalid basic string
+
+"#]],
+    );
+}
+
+#[test]
+fn literal_escape() {
+    t(
+        "a = '\u{7f}'",
+        str![[r#"
+TOML parse error at line 1, column 6
+  |
+1 | a = ''
+  |      ^
+invalid literal string
+
+"#]],
+    );
+}
+
+#[test]
+fn stray_cr() {
+    t(
+        "\r",
+        str![[r#"
+TOML parse error at line 1, column 1
+  |
+1 | 
+  | ^
+
+
+"#]],
+    );
+    t(
+        "a = [ \r ]",
+        str![[r#"
+TOML parse error at line 1, column 8
+  |
+1 | a = [ 
+ ]
+  |        ^
+
+
+"#]],
+    );
+    t(
+        "a = \"\"\"\r\"\"\"",
+        str![[r#"
+TOML parse error at line 1, column 8
+  |
+1 | a = """
+"""
+  |        ^
+invalid multiline basic string
+
+"#]],
+    );
+    t(
+        "a = \"\"\"\\  \r  \"\"\"",
+        str![[r#"
+TOML parse error at line 1, column 10
+  |
+1 | a = """\  
+  """
+  |          ^
+invalid escape sequence
+expected `b`, `f`, `n`, `r`, `t`, `u`, `U`, `\`, `"`
+
+"#]],
+    );
+    t(
+        "a = '''\r'''",
+        str![[r#"
+TOML parse error at line 1, column 8
+  |
+1 | a = '''
+'''
+  |        ^
+invalid multiline literal string
+
+"#]],
+    );
+    t(
+        "a = '\r'",
+        str![[r#"
+TOML parse error at line 1, column 6
+  |
+1 | a = '
+'
+  |      ^
+invalid literal string
+
+"#]],
+    );
+    t(
+        "a = \"\r\"",
+        str![[r#"
+TOML parse error at line 1, column 6
+  |
+1 | a = "
+"
+  |      ^
+invalid basic string
+
+"#]],
+    );
+}
+
+#[test]
+fn duplicate_key_with_crlf() {
+    t(
+        "\r\n\
+         [t1]\r\n\
+         [t2]\r\n\
+         a = 1\r\n\
+         a = 2\r\n\
+         ",
+        str![[r#"
+TOML parse error at line 5, column 1
+  |
+5 | a = 2
+  | ^
+duplicate key `a` in table `t2`
+
+"#]],
+    );
+}
+
+#[test]
+fn emoji_error_span() {
+    let input = "😀";
+    let err = input.parse::<crate::RustDocument>().unwrap_err();
+    dbg!(err.span());
+    let actual = &input[err.span().unwrap()];
+    assert_eq!(actual, input);
+}
+
+#[test]
+fn text_error_span() {
+    let input = "asdf";
+    let err = input.parse::<crate::RustDocument>().unwrap_err();
+    dbg!(err.span());
+    let actual = &input[err.span().unwrap()];
+    assert_eq!(actual, "");
+}
+
+#[test]
+fn fuzzed_68144_error_span() {
+    let input = "\"\\ᾂr\"";
+    let err = input.parse::<crate::RustDocument>().unwrap_err();
+    dbg!(err.span());
+    let actual = &input[err.span().unwrap()];
+    assert_eq!(actual, "ᾂ");
+}

crates/toml/tests/compliance/invalid.rs

@@ -0,0 +1,27 @@
+#![recursion_limit = "256"]
+#![allow(clippy::dbg_macro)]
+#![cfg(all(feature = "parse", feature = "display"))]
+
+macro_rules! parse_value {
+    ($s:expr) => {{
+        use serde::Deserialize;
+        let v = toml::Value::deserialize(toml::de::ValueDeserializer::new($s));
+        assert!(
+            v.is_ok(),
+            "Failed with `{}` when parsing:
+```
+{}
+```
+",
+            v.unwrap_err(),
+            $s
+        );
+        v.unwrap()
+    }};
+}
+
+mod invalid;
+mod parse;
+
+use toml::Table as RustDocument;
+use toml::Value as RustValue;