Vendor dependencies for 0.3.0 release

vendor/ron/tests/117_untagged_tuple_variant.rs

@@ -0,0 +1,59 @@
+use std::borrow::Cow;
+
+use ron::{de::from_str, ser::to_string};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub struct BuildSystem<'m> {
+    version: Cow<'m, str>,
+    flags: Vec<Flag<'m>>,
+}
+
+#[derive(Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(untagged)]
+pub enum Flag<'m> {
+    Value(Cow<'m, str>),
+    If(Cow<'m, str>, Vec<Cow<'m, str>>),
+}
+
+#[test]
+fn test_ebkalderon_case() {
+    let file = r#"BuildSystem(
+    version: "1.0.0",
+    flags: [
+        "--enable-thing",
+        "--enable-other-thing",
+        If("some-conditional", ["--enable-third-thing"]),
+    ]
+)
+"#;
+
+    assert_eq!(
+        from_str::<BuildSystem>(file).unwrap(),
+        BuildSystem {
+            version: "1.0.0".into(),
+            flags: vec![
+                Flag::Value("--enable-thing".into()),
+                Flag::Value("--enable-other-thing".into()),
+                Flag::If(
+                    "some-conditional".into(),
+                    vec!["--enable-third-thing".into()]
+                )
+            ]
+        },
+    );
+}
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
+#[serde(untagged)]
+enum Foo {
+    Bar(usize),
+}
+
+#[test]
+fn test_vessd_case() {
+    let foo_vec = vec![Foo::Bar(0); 5];
+    let foo_str = to_string(&foo_vec).unwrap();
+    assert_eq!(foo_str.as_str(), "[0,0,0,0,0]");
+    assert_eq!(from_str::<Vec<Foo>>(&foo_str).unwrap(), foo_vec);
+}

vendor/ron/tests/123_enum_representation.rs

@@ -0,0 +1,274 @@
+use std::{cmp::PartialEq, fmt::Debug};
+
+use ron::{de::from_str, ser::to_string};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+enum Inner {
+    Foo,
+    Bar,
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+enum EnumStructExternally {
+    VariantA { foo: u32, bar: u32, different: u32 },
+    VariantB { foo: u32, bar: u32 },
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "type")]
+enum EnumStructInternally {
+    VariantA { foo: u32, bar: u32, different: u32 },
+    VariantB { foo: u32, bar: u32 },
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "type", content = "content")]
+enum EnumStructAdjacently {
+    VariantA {
+        foo: u32,
+        bar: u32,
+        different: Inner,
+    },
+    VariantB {
+        foo: u32,
+        bar: u32,
+    },
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(untagged)]
+enum EnumStructUntagged {
+    VariantA { foo: u32, bar: u32, different: u32 },
+    VariantB { foo: u32, bar: u32 },
+}
+
+fn test_ser<T: Serialize>(value: &T, expected: &str) {
+    let actual = to_string(value).expect("Failed to serialize");
+    assert_eq!(actual, expected);
+}
+
+fn test_de<T>(s: &str, expected: T)
+where
+    T: for<'a> Deserialize<'a> + Debug + PartialEq,
+{
+    let actual: Result<T, _> = from_str(s);
+    assert_eq!(actual, Ok(expected));
+}
+
+fn test_roundtrip<T>(value: T)
+where
+    T: Serialize + for<'a> Deserialize<'a> + Debug + PartialEq,
+{
+    let s = to_string(&value).expect("Failed to serialize");
+    let actual: Result<T, _> = from_str(&s);
+    assert_eq!(actual, Ok(value));
+}
+
+#[test]
+fn test_externally_a_ser() {
+    let v = EnumStructExternally::VariantA {
+        foo: 1,
+        bar: 2,
+        different: 3,
+    };
+    let e = "VariantA(foo:1,bar:2,different:3)";
+    test_ser(&v, e);
+}
+
+#[test]
+fn test_externally_b_ser() {
+    let v = EnumStructExternally::VariantB { foo: 1, bar: 2 };
+    let e = "VariantB(foo:1,bar:2)";
+    test_ser(&v, e);
+}
+
+#[test]
+fn test_internally_a_ser() {
+    let v = EnumStructInternally::VariantA {
+        foo: 1,
+        bar: 2,
+        different: 3,
+    };
+    let e = "(type:\"VariantA\",foo:1,bar:2,different:3)";
+    test_ser(&v, e);
+}
+
+#[test]
+fn test_internally_b_ser() {
+    let v = EnumStructInternally::VariantB { foo: 1, bar: 2 };
+    let e = "(type:\"VariantB\",foo:1,bar:2)";
+    test_ser(&v, e);
+}
+
+#[test]
+fn test_adjacently_a_ser() {
+    let v = EnumStructAdjacently::VariantA {
+        foo: 1,
+        bar: 2,
+        different: Inner::Foo,
+    };
+    let e = "(type:VariantA,content:(foo:1,bar:2,different:Foo))";
+    test_ser(&v, e);
+}
+
+#[test]
+fn test_adjacently_b_ser() {
+    let v = EnumStructAdjacently::VariantB { foo: 1, bar: 2 };
+    let e = "(type:VariantB,content:(foo:1,bar:2))";
+    test_ser(&v, e);
+}
+
+#[test]
+fn test_untagged_a_ser() {
+    let v = EnumStructUntagged::VariantA {
+        foo: 1,
+        bar: 2,
+        different: 3,
+    };
+    let e = "(foo:1,bar:2,different:3)";
+    test_ser(&v, e);
+}
+
+#[test]
+fn test_untagged_b_ser() {
+    let v = EnumStructUntagged::VariantB { foo: 1, bar: 2 };
+    let e = "(foo:1,bar:2)";
+    test_ser(&v, e);
+}
+
+#[test]
+fn test_externally_a_de() {
+    let s = "VariantA(foo:1,bar:2,different:3)";
+    let e = EnumStructExternally::VariantA {
+        foo: 1,
+        bar: 2,
+        different: 3,
+    };
+    test_de(s, e);
+}
+
+#[test]
+fn test_externally_b_de() {
+    let s = "VariantB(foo:1,bar:2)";
+    let e = EnumStructExternally::VariantB { foo: 1, bar: 2 };
+    test_de(s, e);
+}
+
+#[test]
+fn test_internally_a_de() {
+    let s = "(type:\"VariantA\",foo:1,bar:2,different:3)";
+    let e = EnumStructInternally::VariantA {
+        foo: 1,
+        bar: 2,
+        different: 3,
+    };
+    test_de(s, e);
+}
+
+#[test]
+fn test_internally_b_de() {
+    let s = "(type:\"VariantB\",foo:1,bar:2)";
+    let e = EnumStructInternally::VariantB { foo: 1, bar: 2 };
+    test_de(s, e);
+}
+
+#[test]
+fn test_adjacently_a_de() {
+    let s = "(type:VariantA,content:(foo:1,bar:2,different:Foo))";
+    let e = EnumStructAdjacently::VariantA {
+        foo: 1,
+        bar: 2,
+        different: Inner::Foo,
+    };
+    test_de(s, e);
+}
+
+#[test]
+fn test_adjacently_b_de() {
+    let s = "(type:VariantB,content:(foo:1,bar:2))";
+    let e = EnumStructAdjacently::VariantB { foo: 1, bar: 2 };
+    test_de(s, e);
+}
+
+#[test]
+fn test_untagged_a_de() {
+    let s = "(foo:1,bar:2,different:3)";
+    let e = EnumStructUntagged::VariantA {
+        foo: 1,
+        bar: 2,
+        different: 3,
+    };
+    test_de(s, e);
+}
+
+#[test]
+fn test_untagged_b_de() {
+    let s = "(foo:1,bar:2)";
+    let e = EnumStructUntagged::VariantB { foo: 1, bar: 2 };
+    test_de(s, e);
+}
+
+#[test]
+fn test_externally_a_roundtrip() {
+    let v = EnumStructExternally::VariantA {
+        foo: 1,
+        bar: 2,
+        different: 3,
+    };
+    test_roundtrip(v);
+}
+
+#[test]
+fn test_externally_b_roundtrip() {
+    let v = EnumStructExternally::VariantB { foo: 1, bar: 2 };
+    test_roundtrip(v);
+}
+
+#[test]
+fn test_internally_a_roundtrip() {
+    let v = EnumStructInternally::VariantA {
+        foo: 1,
+        bar: 2,
+        different: 3,
+    };
+    test_roundtrip(v);
+}
+
+#[test]
+fn test_internally_b_roundtrip() {
+    let v = EnumStructInternally::VariantB { foo: 1, bar: 2 };
+    test_roundtrip(v);
+}
+
+#[test]
+fn test_adjacently_a_roundtrip() {
+    let v = EnumStructAdjacently::VariantA {
+        foo: 1,
+        bar: 2,
+        different: Inner::Foo,
+    };
+    test_roundtrip(v);
+}
+
+#[test]
+fn test_adjacently_b_roundtrip() {
+    let v = EnumStructAdjacently::VariantB { foo: 1, bar: 2 };
+    test_roundtrip(v);
+}
+
+#[test]
+fn test_untagged_a_roundtrip() {
+    let v = EnumStructUntagged::VariantA {
+        foo: 1,
+        bar: 2,
+        different: 3,
+    };
+    test_roundtrip(v);
+}
+
+#[test]
+fn test_untagged_b_roundtrip() {
+    let v = EnumStructUntagged::VariantB { foo: 1, bar: 2 };
+    test_roundtrip(v);
+}

vendor/ron/tests/129_indexmap.rs

@@ -0,0 +1,76 @@
+#[cfg(feature = "indexmap")]
+use ron::{de::from_str, Value};
+
+#[test]
+#[cfg(feature = "indexmap")]
+fn test_order_preserved() {
+    let file = r#"(
+tasks: {
+    "debug message": Dbg(
+      msg: "test message. some text after it."
+    ),
+    "shell command": Shell(
+      command: "ls",
+      args: Some([
+        "-l",
+        "-h",
+      ]),
+      ch_dir: Some("/"),
+    ),
+},
+)
+"#;
+
+    let value: Value = from_str(file).unwrap();
+    match value {
+        Value::Map(map) => match &map[&Value::String("tasks".to_owned())] {
+            Value::Map(map) => {
+                assert_eq!(
+                    *map.keys().next().unwrap(),
+                    Value::String("debug message".to_string())
+                );
+                assert_eq!(
+                    *map.keys().nth(1).unwrap(),
+                    Value::String("shell command".to_string())
+                );
+            }
+            _ => panic!(), // GRCOV_EXCL_LINE
+        },
+        _ => panic!(), // GRCOV_EXCL_LINE
+    }
+
+    let file = r#"(
+tasks: {
+    "shell command": Shell(
+      command: "ls",
+      args: Some([
+        "-l",
+        "-h",
+      ]),
+      ch_dir: Some("/")
+    ),
+    "debug message": Dbg(
+      msg: "test message. some text after it."
+    ),
+}
+)
+"#;
+
+    let value: Value = from_str(file).unwrap();
+    match value {
+        Value::Map(map) => match &map[&Value::String("tasks".to_owned())] {
+            Value::Map(map) => {
+                assert_eq!(
+                    *map.keys().next().unwrap(),
+                    Value::String("shell command".to_string())
+                );
+                assert_eq!(
+                    *map.keys().nth(1).unwrap(),
+                    Value::String("debug message".to_string())
+                );
+            }
+            _ => panic!(), // GRCOV_EXCL_LINE
+        },
+        _ => panic!(), // GRCOV_EXCL_LINE
+    }
+}

vendor/ron/tests/147_empty_sets_serialisation.rs

@@ -0,0 +1,63 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct UnitStruct;
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct NewType(f32);
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct TupleStruct(UnitStruct, i8);
+
+#[derive(Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+struct Key(u32);
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct Struct {
+    tuple: ((), NewType, TupleStruct),
+    vec: Vec<Option<UnitStruct>>,
+    map: HashMap<Key, i32>,
+    deep_vec: HashMap<Key, Vec<()>>,
+    deep_map: HashMap<Key, HashMap<Key, i32>>,
+}
+
+#[test]
+fn empty_sets_arrays() {
+    let value = Struct {
+        tuple: ((), NewType(0.5), TupleStruct(UnitStruct, -5)),
+        vec: vec![],
+        map: vec![].into_iter().collect(),
+        deep_vec: vec![(Key(0), vec![])].into_iter().collect(),
+        deep_map: vec![(Key(0), vec![].into_iter().collect())]
+            .into_iter()
+            .collect(),
+    };
+
+    let pretty = ron::ser::PrettyConfig::new()
+        .enumerate_arrays(true)
+        .new_line("\n".to_string());
+    let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
+
+    println!("Serialized: {}", serial);
+
+    assert_eq!(
+        "(
+    tuple: ((), (0.5), ((), -5)),
+    vec: [],
+    map: {},
+    deep_vec: {
+        (0): [],
+    },
+    deep_map: {
+        (0): {},
+    },
+)",
+        serial
+    );
+
+    let deserial = ron::de::from_str(&serial);
+
+    assert_eq!(Ok(value), deserial);
+}

vendor/ron/tests/152_bitflags.rs

@@ -0,0 +1,57 @@
+use bitflags::bitflags;
+use option_set::option_set;
+
+bitflags! {
+    #[derive(
+        Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash,
+        serde::Serialize, serde::Deserialize,
+    )]
+    struct TestGood: u8 {
+        const ONE = 1;
+        const TWO = 1 << 1;
+        const THREE  = 1 << 2;
+    }
+}
+
+option_set! {
+    struct TestBad: UpperCamel + u8 {
+        const ONE = 1;
+        const TWO = 1 << 1;
+        const THREE  = 1 << 2;
+    }
+}
+
+#[test]
+fn test_bitflags() {
+    // Test case provided by jaynus in
+    // https://github.com/ron-rs/ron/issues/152#issue-421298302
+
+    let flag_good = TestGood::ONE | TestGood::TWO;
+
+    let json_ser_good = serde_json::ser::to_string(&flag_good).unwrap();
+    let ron_ser_good = ron::ser::to_string(&flag_good).unwrap();
+
+    assert_eq!(json_ser_good, "\"ONE | TWO\"");
+    assert_eq!(ron_ser_good, "(\"ONE | TWO\")");
+
+    let json_de_good: TestGood = serde_json::de::from_str(json_ser_good.as_str()).unwrap();
+    let ron_de_good: TestGood = ron::de::from_str(ron_ser_good.as_str()).unwrap();
+
+    assert_eq!(json_de_good, flag_good);
+    assert_eq!(ron_de_good, flag_good);
+
+    // option_set
+    let flag_bad = TestBad::ONE | TestBad::TWO;
+
+    let json_ser_bad = serde_json::ser::to_string(&flag_bad).unwrap();
+    let ron_ser_bad = ron::ser::to_string(&flag_bad).unwrap();
+
+    assert_eq!(json_ser_bad, "[\"One\",\"Two\"]");
+    assert_eq!(ron_ser_bad, "[\"One\",\"Two\"]");
+
+    let json_de_bad: TestBad = serde_json::de::from_str(json_ser_bad.as_str()).unwrap();
+    let ron_de_bad: TestBad = ron::de::from_str(ron_ser_bad.as_str()).unwrap();
+
+    assert_eq!(json_de_bad, flag_bad);
+    assert_eq!(ron_de_bad, flag_bad);
+}

vendor/ron/tests/203_error_positions.rs

@@ -0,0 +1,105 @@
+use std::num::NonZeroU32;
+
+use ron::error::{Error, Position, SpannedError};
+use serde::{
+    de::{Deserialize, Error as DeError, Unexpected},
+    Deserializer,
+};
+
+#[derive(Debug, serde::Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+enum Test {
+    TupleVariant(i32, String),
+    StructVariant { a: bool, b: NonZeroU32, c: i32 },
+}
+
+#[derive(Debug, PartialEq)] // GRCOV_EXCL_LINE
+struct TypeError;
+
+impl<'de> Deserialize<'de> for TypeError {
+    fn deserialize<D: Deserializer<'de>>(_deserializer: D) -> Result<Self, D::Error> {
+        Err(D::Error::invalid_type(Unexpected::Unit, &"impossible"))
+    }
+}
+
+#[test]
+fn test_error_positions() {
+    assert_eq!(
+        ron::from_str::<TypeError>("  ()"),
+        Err(SpannedError {
+            code: Error::InvalidValueForType {
+                expected: String::from("impossible"),
+                found: String::from("a unit value"),
+            },
+            position: Position { line: 1, col: 3 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<Test>("StructVariant(a: true, b: 0, c: -42)"),
+        Err(SpannedError {
+            code: Error::InvalidValueForType {
+                expected: String::from("a nonzero u32"),
+                found: String::from("the unsigned integer `0`"),
+            },
+            position: Position { line: 1, col: 28 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<Test>("TupleVariant(42)"),
+        Err(SpannedError {
+            code: Error::ExpectedDifferentLength {
+                expected: String::from("tuple variant Test::TupleVariant with 2 elements"),
+                found: 1,
+            },
+            position: Position { line: 1, col: 16 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<Test>("NotAVariant"),
+        Err(SpannedError {
+            code: Error::NoSuchEnumVariant {
+                expected: &["TupleVariant", "StructVariant"],
+                found: String::from("NotAVariant"),
+                outer: Some(String::from("Test")),
+            },
+            position: Position { line: 1, col: 12 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<Test>("StructVariant(a: true, b: 1, c: -42, d: \"gotcha\")"),
+        Err(SpannedError {
+            code: Error::NoSuchStructField {
+                expected: &["a", "b", "c"],
+                found: String::from("d"),
+                outer: Some(String::from("StructVariant")),
+            },
+            position: Position { line: 1, col: 39 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<Test>("StructVariant(a: true, c: -42)"),
+        Err(SpannedError {
+            code: Error::MissingStructField {
+                field: "b",
+                outer: Some(String::from("StructVariant")),
+            },
+            position: Position { line: 1, col: 30 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<Test>("StructVariant(a: true, b: 1, a: false, c: -42)"),
+        Err(SpannedError {
+            code: Error::DuplicateStructField {
+                field: "a",
+                outer: Some(String::from("StructVariant")),
+            },
+            position: Position { line: 1, col: 31 },
+        })
+    );
+}

vendor/ron/tests/207_adjacently_tagged_enum.rs

@@ -0,0 +1,22 @@
+use ron::{de::from_str, ser::to_string};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type", content = "data")]
+enum TestEnum {
+    Name(String),
+    Index(u32),
+}
+
+#[test]
+fn test_adjacently_tagged() {
+    let source = TestEnum::Index(1);
+
+    let ron_string = to_string(&source).unwrap();
+
+    assert_eq!(ron_string, "(type:Index,data:1)");
+
+    let deserialized = from_str::<TestEnum>(&ron_string).unwrap();
+
+    assert_eq!(deserialized, source);
+}

vendor/ron/tests/238_array.rs

@@ -0,0 +1,51 @@
+use ron::{
+    error::{Error, Position, SpannedError},
+    value::{Number, Value},
+};
+
+#[test]
+fn test_array() {
+    let array: [i32; 3] = [1, 2, 3];
+
+    let ser = ron::to_string(&array).unwrap();
+    assert_eq!(ser, "(1,2,3)");
+
+    let de: [i32; 3] = ron::from_str(&ser).unwrap();
+    assert_eq!(de, array);
+
+    let value: Value = ron::from_str(&ser).unwrap();
+    assert_eq!(
+        value,
+        Value::Seq(vec![
+            Value::Number(Number::from(1)),
+            Value::Number(Number::from(2)),
+            Value::Number(Number::from(3)),
+        ])
+    );
+
+    let ser = ron::to_string(&value).unwrap();
+    assert_eq!(ser, "[1,2,3]");
+
+    let de: [i32; 3] = value.into_rust().unwrap();
+    assert_eq!(de, array);
+
+    // FIXME: fails and hence arrays do not roundtrip
+    let de: SpannedError = ron::from_str::<[i32; 3]>(&ser).unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::ExpectedStructLike,
+            position: Position { line: 1, col: 1 },
+        }
+    );
+
+    let value: Value = ron::from_str(&ser).unwrap();
+    assert_eq!(
+        value,
+        Value::Seq(vec![
+            Value::Number(Number::from(1)),
+            Value::Number(Number::from(2)),
+            Value::Number(Number::from(3)),
+        ])
+    );
+}

vendor/ron/tests/240_array_pretty.rs

@@ -0,0 +1,52 @@
+use ron::ser::{to_string_pretty, PrettyConfig};
+
+#[test]
+fn small_array() {
+    let arr = &[(), (), ()][..];
+    assert_eq!(
+        to_string_pretty(&arr, PrettyConfig::new().new_line("\n".to_string())).unwrap(),
+        "[
+    (),
+    (),
+    (),
+]"
+    );
+    assert_eq!(
+        to_string_pretty(
+            &arr,
+            PrettyConfig::new()
+                .new_line("\n".to_string())
+                .compact_arrays(true)
+        )
+        .unwrap(),
+        "[(), (), ()]"
+    );
+    assert_eq!(
+        to_string_pretty(
+            &arr,
+            PrettyConfig::new()
+                .new_line("\n".to_string())
+                .compact_arrays(true)
+                .separator("".to_string())
+        )
+        .unwrap(),
+        "[(),(),()]"
+    );
+    assert_eq!(
+        to_string_pretty(
+            &vec![(1, 2), (3, 4)],
+            PrettyConfig::new()
+                .new_line("\n".to_string())
+                .separate_tuple_members(true)
+                .compact_arrays(true)
+        )
+        .unwrap(),
+        "[(
+    1,
+    2,
+), (
+    3,
+    4,
+)]"
+    );
+}

vendor/ron/tests/250_variant_newtypes.rs

@@ -0,0 +1,410 @@
+use std::collections::HashMap;
+
+use ron::{
+    de::from_str,
+    error::Error,
+    extensions::Extensions,
+    ser::{to_string_pretty, PrettyConfig},
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
+enum TestEnum {
+    Unit,
+    PrimitiveNewtype(String),
+    Tuple(u32, bool),
+    Struct { a: u32, b: bool },
+    TupleNewtypeUnit(Unit),
+    TupleNewtypeNewtype(Newtype),
+    TupleNewtypeTuple((u32, bool)),
+    TupleNewtypeTupleStruct(TupleStruct),
+    TupleNewtypeStruct(Struct),
+    TupleNewtypeEnum(Enum),
+    TupleNewtypeOption(Option<Struct>),
+    TupleNewtypeSeq(Vec<Struct>),
+    TupleNewtypeMap(HashMap<u32, Struct>),
+}
+
+#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
+struct Unit;
+
+#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
+struct Newtype(i32);
+
+#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
+struct TupleStruct(u32, bool);
+
+#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
+struct Struct {
+    a: u32,
+    b: bool,
+}
+
+#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
+enum Enum {
+    A,
+    B(Struct),
+    C(u32, bool),
+    D { a: u32, b: bool },
+}
+
+#[test]
+fn test_deserialise_non_newtypes() {
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] Unit"#).unwrap(),
+        TestEnum::Unit,
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] PrimitiveNewtype("hi")"#)
+            .unwrap(),
+        TestEnum::PrimitiveNewtype(String::from("hi")),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] Tuple(4, false)"#).unwrap(),
+        TestEnum::Tuple(4, false),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] Struct(a: 4, b: false)"#)
+            .unwrap(),
+        TestEnum::Struct { a: 4, b: false },
+    );
+}
+
+#[test]
+fn test_deserialise_tuple_newtypes() {
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeUnit(Unit)"#)
+            .unwrap_err()
+            .code,
+        Error::ExpectedStructLikeEnd,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeUnit(())"#)
+            .unwrap_err()
+            .code,
+        Error::ExpectedStructLikeEnd,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeUnit()"#).unwrap(),
+        TestEnum::TupleNewtypeUnit(Unit),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeNewtype(Newtype(4))"#
+        )
+        .unwrap_err()
+        .code,
+        Error::ExpectedInteger,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeNewtype((4))"#)
+            .unwrap_err()
+            .code,
+        Error::ExpectedInteger,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeNewtype(4)"#)
+            .unwrap(),
+        TestEnum::TupleNewtypeNewtype(Newtype(4)),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_newtypes)] TupleNewtypeNewtype(4)"#).unwrap(),
+        TestEnum::TupleNewtypeNewtype(Newtype(4)),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_newtypes)] #![enable(unwrap_variant_newtypes)] TupleNewtypeNewtype(4)"#).unwrap(),
+        TestEnum::TupleNewtypeNewtype(Newtype(4)),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeTuple((4, false))"#
+        )
+        .unwrap_err()
+        .code,
+        Error::ExpectedInteger,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeTuple(4, false)"#)
+            .unwrap(),
+        TestEnum::TupleNewtypeTuple((4, false)),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeTupleStruct(TupleStruct(4, false))"#
+        )
+        .unwrap_err()
+        .code,
+        Error::ExpectedInteger,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeTupleStruct((4, false))"#
+        )
+        .unwrap_err()
+        .code,
+        Error::ExpectedInteger,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeTupleStruct(4, false)"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeTupleStruct(TupleStruct(4, false)),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeStruct(Struct(a: 4, b: false))"#
+        )
+        .unwrap_err()
+        .code,
+        Error::ExpectedMapColon,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeStruct((a: 4, b: false))"#
+        )
+        .unwrap_err()
+        .code,
+        Error::ExpectedIdentifier,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeStruct(a: 4, b: false)"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeStruct(Struct { a: 4, b: false }),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeEnum(A)"#).unwrap(),
+        TestEnum::TupleNewtypeEnum(Enum::A),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeEnum(B(a: 4, b: false))"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeEnum(Enum::B(Struct { a: 4, b: false })),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeEnum(C 4, false)"#)
+            .unwrap_err()
+            .code,
+        Error::ExpectedStructLike,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeEnum(C(4, false))"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeEnum(Enum::C(4, false)),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeEnum(D a: 4, b: false)"#
+        )
+        .unwrap_err()
+        .code,
+        Error::ExpectedStructLike,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeEnum(D(a: 4, b: false))"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeEnum(Enum::D { a: 4, b: false }),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeOption(None)"#)
+            .unwrap(),
+        TestEnum::TupleNewtypeOption(None),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeOption(Some(a: 4, b: false))"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeOption(Some(Struct { a: 4, b: false })),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeOption(a: 4, b: false)"#
+        )
+        .unwrap_err()
+        .code,
+        Error::ExpectedOption,
+    );
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes, implicit_some)] TupleNewtypeOption(a: 4, b: false)"#).unwrap(),
+        TestEnum::TupleNewtypeOption(Some(Struct { a: 4, b: false })),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeSeq([])"#).unwrap(),
+        TestEnum::TupleNewtypeSeq(vec![]),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeSeq([(a: 4, b: false)])"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeSeq(vec![Struct { a: 4, b: false }]),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeSeq([Struct(a: 4, b: false)])"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeSeq(vec![Struct { a: 4, b: false }]),
+    );
+
+    assert_eq!(
+        from_str::<TestEnum>(r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeMap({})"#).unwrap(),
+        TestEnum::TupleNewtypeMap(vec![].into_iter().collect()),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeMap({2: (a: 4, b: false)})"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeMap(vec![(2, Struct { a: 4, b: false })].into_iter().collect()),
+    );
+    assert_eq!(
+        from_str::<TestEnum>(
+            r#"#![enable(unwrap_variant_newtypes)] TupleNewtypeMap({8: Struct(a: 4, b: false)})"#
+        )
+        .unwrap(),
+        TestEnum::TupleNewtypeMap(vec![(8, Struct { a: 4, b: false })].into_iter().collect()),
+    );
+}
+
+#[test]
+fn test_serialise_non_newtypes() {
+    assert_eq_serialize_roundtrip(TestEnum::Unit, Extensions::UNWRAP_VARIANT_NEWTYPES);
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::PrimitiveNewtype(String::from("hi")),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::Tuple(4, false),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::Struct { a: 4, b: false },
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+}
+
+#[test]
+fn test_serialise_tuple_newtypes() {
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeUnit(Unit),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeNewtype(Newtype(4)),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeNewtype(Newtype(4)),
+        Extensions::UNWRAP_NEWTYPES,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeNewtype(Newtype(4)),
+        Extensions::UNWRAP_VARIANT_NEWTYPES | Extensions::UNWRAP_NEWTYPES,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeTuple((4, false)),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeTupleStruct(TupleStruct(4, false)),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeStruct(Struct { a: 4, b: false }),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeEnum(Enum::A),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeEnum(Enum::B(Struct { a: 4, b: false })),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeEnum(Enum::C(4, false)),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeEnum(Enum::D { a: 4, b: false }),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeOption(None),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeOption(Some(Struct { a: 4, b: false })),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeOption(Some(Struct { a: 4, b: false })),
+        Extensions::IMPLICIT_SOME,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeOption(Some(Struct { a: 4, b: false })),
+        Extensions::UNWRAP_VARIANT_NEWTYPES | Extensions::IMPLICIT_SOME,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeSeq(vec![]),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeSeq(vec![Struct { a: 4, b: false }]),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeMap(vec![].into_iter().collect()),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+    assert_eq_serialize_roundtrip(
+        TestEnum::TupleNewtypeMap(vec![(2, Struct { a: 4, b: false })].into_iter().collect()),
+        Extensions::UNWRAP_VARIANT_NEWTYPES,
+    );
+}
+
+fn assert_eq_serialize_roundtrip<
+    S: Serialize + serde::de::DeserializeOwned + PartialEq + std::fmt::Debug,
+>(
+    value: S,
+    extensions: Extensions,
+) {
+    assert_eq!(
+        from_str::<S>(
+            &to_string_pretty(&value, PrettyConfig::default().extensions(extensions)).unwrap()
+        )
+        .unwrap(),
+        value,
+    );
+}

vendor/ron/tests/256_comma_error.rs

@@ -0,0 +1,72 @@
+#![allow(dead_code)]
+
+use ron::error::{Error, Position, SpannedError};
+
+#[derive(Debug, serde::Deserialize)]
+struct Test {
+    a: i32,
+    b: i32,
+}
+
+#[test]
+fn test_missing_comma_error() {
+    let tuple_string = r#"(
+        1 // <-- forgotten comma here
+        2
+    )"#;
+
+    assert_eq!(
+        ron::from_str::<(i32, i32)>(tuple_string).unwrap_err(),
+        SpannedError {
+            code: Error::ExpectedComma,
+            position: Position { line: 3, col: 9 }
+        }
+    );
+
+    let list_string = r#"[
+        0,
+        1 // <-- forgotten comma here
+        2
+    ]"#;
+
+    assert_eq!(
+        ron::from_str::<Vec<i32>>(list_string).unwrap_err(),
+        SpannedError {
+            code: Error::ExpectedComma,
+            position: Position { line: 4, col: 9 }
+        }
+    );
+
+    let struct_string = r#"Test(
+        a: 1 // <-- forgotten comma here
+        b: 2
+    )"#;
+
+    assert_eq!(
+        ron::from_str::<Test>(struct_string).unwrap_err(),
+        SpannedError {
+            code: Error::ExpectedComma,
+            position: Position { line: 3, col: 9 }
+        }
+    );
+
+    let map_string = r#"{
+        "a": 1 // <-- forgotten comma here
+        "b": 2
+    }"#;
+
+    assert_eq!(
+        ron::from_str::<std::collections::HashMap<String, i32>>(map_string).unwrap_err(),
+        SpannedError {
+            code: Error::ExpectedComma,
+            position: Position { line: 3, col: 9 }
+        }
+    );
+}
+
+#[test]
+fn test_comma_end() {
+    assert_eq!(ron::from_str::<(i32, i32)>("(0, 1)").unwrap(), (0, 1));
+    assert_eq!(ron::from_str::<(i32, i32)>("(0, 1,)").unwrap(), (0, 1));
+    assert_eq!(ron::from_str::<()>("()"), Ok(()));
+}

vendor/ron/tests/289_enumerate_arrays.rs

@@ -0,0 +1,47 @@
+const EXPTECTED: &str = "[
+    /*[0]*/ None,
+    /*[1]*/ Some([]),
+    /*[2]*/ Some([
+        /*[0]*/ 42,
+    ]),
+    /*[3]*/ Some([
+        /*[0]*/ 4,
+        /*[1]*/ 2,
+    ]),
+    /*[4]*/ None,
+]";
+
+const EXPTECTED_COMPACT: &str = "[/*[0]*/ None, /*[1]*/ Some([]), /*[2]*/ Some([/*[0]*/ 42]), \
+/*[3]*/ Some([/*[0]*/ 4, /*[1]*/ 2]), /*[4]*/ None]";
+
+#[test]
+fn enumerate_arrays() {
+    let v: Vec<Option<Vec<u8>>> = vec![None, Some(vec![]), Some(vec![42]), Some(vec![4, 2]), None];
+
+    let pretty = ron::ser::PrettyConfig::new().enumerate_arrays(true);
+
+    let ser = ron::ser::to_string_pretty(&v, pretty).unwrap();
+
+    assert_eq!(ser, EXPTECTED);
+
+    let de: Vec<Option<Vec<u8>>> = ron::from_str(&ser).unwrap();
+
+    assert_eq!(v, de)
+}
+
+#[test]
+fn enumerate_compact_arrays() {
+    let v: Vec<Option<Vec<u8>>> = vec![None, Some(vec![]), Some(vec![42]), Some(vec![4, 2]), None];
+
+    let pretty = ron::ser::PrettyConfig::new()
+        .enumerate_arrays(true)
+        .compact_arrays(true);
+
+    let ser = ron::ser::to_string_pretty(&v, pretty).unwrap();
+
+    assert_eq!(ser, EXPTECTED_COMPACT);
+
+    let de: Vec<Option<Vec<u8>>> = ron::from_str(&ser).unwrap();
+
+    assert_eq!(v, de)
+}

vendor/ron/tests/301_struct_name_mismatch.rs

@@ -0,0 +1,130 @@
+use ron::error::{Error, Position, SpannedError};
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, PartialEq)]
+struct MyUnitStruct;
+
+#[derive(Debug, Deserialize, PartialEq)]
+struct MyTupleStruct(bool, i32);
+
+#[derive(Debug, Deserialize, PartialEq)]
+struct MyNewtypeStruct(MyTupleStruct);
+
+#[derive(Debug, Deserialize, PartialEq)]
+struct MyStruct {
+    a: bool,
+    b: i32,
+}
+
+#[test]
+fn test_unit_struct_name_mismatch() {
+    assert_eq!(ron::from_str::<MyUnitStruct>("()"), Ok(MyUnitStruct),);
+    assert_eq!(
+        ron::from_str::<MyUnitStruct>("MyUnitStruct"),
+        Ok(MyUnitStruct),
+    );
+    assert_eq!(
+        ron::from_str::<MyUnitStruct>("MyUnit Struct"),
+        Err(SpannedError {
+            code: Error::ExpectedDifferentStructName {
+                expected: "MyUnitStruct",
+                found: String::from("MyUnit")
+            },
+            position: Position { line: 1, col: 7 }
+        }),
+    );
+    assert_eq!(
+        ron::from_str::<MyUnitStruct>("42"),
+        Err(SpannedError {
+            code: Error::ExpectedNamedStructLike("MyUnitStruct"),
+            position: Position { line: 1, col: 1 }
+        }),
+    );
+}
+
+#[test]
+fn test_tuple_struct_name_mismatch() {
+    assert_eq!(
+        ron::from_str::<MyTupleStruct>("(true, 42)"),
+        Ok(MyTupleStruct(true, 42)),
+    );
+    assert_eq!(
+        ron::from_str::<MyTupleStruct>("MyTupleStruct(true, 42)"),
+        Ok(MyTupleStruct(true, 42)),
+    );
+    assert_eq!(
+        ron::from_str::<MyTupleStruct>("MyTypleStruct(true, 42)"),
+        Err(SpannedError {
+            code: Error::ExpectedDifferentStructName {
+                expected: "MyTupleStruct",
+                found: String::from("MyTypleStruct")
+            },
+            position: Position { line: 1, col: 14 }
+        }),
+    );
+    assert_eq!(
+        ron::from_str::<MyTupleStruct>("42"),
+        Err(SpannedError {
+            code: Error::ExpectedNamedStructLike("MyTupleStruct"),
+            position: Position { line: 1, col: 1 }
+        }),
+    );
+}
+
+#[test]
+fn test_newtype_struct_name_mismatch() {
+    assert_eq!(
+        ron::from_str::<MyNewtypeStruct>("((true, 42))"),
+        Ok(MyNewtypeStruct(MyTupleStruct(true, 42))),
+    );
+    assert_eq!(
+        ron::from_str::<MyNewtypeStruct>("MyNewtypeStruct((true, 42))"),
+        Ok(MyNewtypeStruct(MyTupleStruct(true, 42))),
+    );
+    assert_eq!(
+        ron::from_str::<MyNewtypeStruct>("MyNewtypeStrucl((true, 42))"),
+        Err(SpannedError {
+            code: Error::ExpectedDifferentStructName {
+                expected: "MyNewtypeStruct",
+                found: String::from("MyNewtypeStrucl")
+            },
+            position: Position { line: 1, col: 16 }
+        }),
+    );
+    assert_eq!(
+        ron::from_str::<MyNewtypeStruct>("42"),
+        Err(SpannedError {
+            code: Error::ExpectedNamedStructLike("MyNewtypeStruct"),
+            position: Position { line: 1, col: 1 }
+        }),
+    );
+}
+
+#[test]
+fn test_struct_name_mismatch() {
+    assert_eq!(
+        ron::from_str::<MyStruct>("(a: true, b: 42)"),
+        Ok(MyStruct { a: true, b: 42 }),
+    );
+    assert_eq!(
+        ron::from_str::<MyStruct>("MyStruct(a: true, b: 42)"),
+        Ok(MyStruct { a: true, b: 42 }),
+    );
+    assert_eq!(
+        ron::from_str::<MyStruct>("MuStryct(a: true, b: 42)"),
+        Err(SpannedError {
+            code: Error::ExpectedDifferentStructName {
+                expected: "MyStruct",
+                found: String::from("MuStryct")
+            },
+            position: Position { line: 1, col: 9 }
+        }),
+    );
+    assert_eq!(
+        ron::from_str::<MyStruct>("42"),
+        Err(SpannedError {
+            code: Error::ExpectedNamedStructLike("MyStruct"),
+            position: Position { line: 1, col: 1 }
+        }),
+    );
+}

vendor/ron/tests/322_escape_idents.rs

@@ -0,0 +1,34 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum MyEnumWithDashes {
+    ThisIsMyUnitVariant,
+    ThisIsMyTupleVariant(bool, i32),
+}
+
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "kebab-case")]
+struct MyStructWithDashes {
+    my_enum: MyEnumWithDashes,
+    #[serde(rename = "2nd")]
+    my_enum2: MyEnumWithDashes,
+    will_be_renamed: u32,
+}
+
+#[test]
+fn roundtrip_ident_with_dash() {
+    let value = MyStructWithDashes {
+        my_enum: MyEnumWithDashes::ThisIsMyUnitVariant,
+        my_enum2: MyEnumWithDashes::ThisIsMyTupleVariant(false, -3),
+        will_be_renamed: 32,
+    };
+
+    let serial = ron::ser::to_string(&value).unwrap();
+
+    println!("Serialized: {}", serial);
+
+    let deserial = ron::de::from_str(&serial);
+
+    assert_eq!(Ok(value), deserial);
+}

vendor/ron/tests/337_value_float_roundtrip.rs

@@ -0,0 +1,29 @@
+#[test]
+fn roundtrip_value_float_with_decimals() {
+    let v: ron::Value = ron::from_str("1.0").unwrap();
+
+    assert_eq!(v, ron::Value::Number(1.0_f64.into()));
+
+    let ser = ron::ser::to_string(&v).unwrap();
+
+    let roundtrip = ron::from_str(&ser).unwrap();
+
+    assert_eq!(v, roundtrip);
+}
+
+#[test]
+#[allow(clippy::float_cmp)]
+fn roundtrip_value_float_into() {
+    let v: ron::Value = ron::from_str("1.0").unwrap();
+    assert_eq!(v, ron::Value::Number(1.0_f64.into()));
+
+    let ser = ron::ser::to_string(&v).unwrap();
+
+    let f1: f64 = ron::from_str(&ser).unwrap();
+    assert_eq!(f1, 1.0_f64);
+
+    let roundtrip: ron::Value = ron::from_str(&ser).unwrap();
+
+    let f2: f64 = roundtrip.into_rust().unwrap();
+    assert_eq!(f2, 1.0_f64);
+}

vendor/ron/tests/359_deserialize_seed.rs

@@ -0,0 +1,57 @@
+#[test]
+fn test_deserialize_seed() {
+    // Test adapted from David Tolnay's serde-yaml:
+    // https://github.com/dtolnay/serde-yaml/blob/8a806e316302fd2e6541dccee6d166dd51b689d6/tests/test_de.rs#L357-L392
+
+    struct Seed(i64);
+
+    impl<'de> serde::de::DeserializeSeed<'de> for Seed {
+        type Value = i64;
+
+        fn deserialize<D>(self, deserializer: D) -> Result<i64, D::Error>
+        where
+            D: serde::de::Deserializer<'de>,
+        {
+            struct Visitor(i64);
+
+            impl<'de> serde::de::Visitor<'de> for Visitor {
+                type Value = i64;
+
+                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                    write!(formatter, "an integer")
+                }
+
+                fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<i64, E> {
+                    Ok(v * self.0)
+                }
+
+                fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<i64, E> {
+                    Ok(v as i64 * self.0)
+                }
+            }
+
+            deserializer.deserialize_any(Visitor(self.0))
+        }
+    }
+
+    let cases = [("3", 5, 15), ("6", 7, 42), ("-5", 9, -45)];
+
+    for &(ron, seed, expected) in &cases {
+        let deserialized = ron::Options::default()
+            .from_str_seed(ron, Seed(seed))
+            .unwrap();
+
+        assert_eq!(expected, deserialized);
+    }
+
+    assert_eq!(
+        ron::Options::default().from_str_seed("'a'", Seed(42)),
+        Err(ron::error::SpannedError {
+            code: ron::Error::InvalidValueForType {
+                expected: String::from("an integer"),
+                found: String::from("the string \"a\""),
+            },
+            position: ron::error::Position { line: 1, col: 4 },
+        })
+    );
+}

vendor/ron/tests/367_implicit_some.rs

@@ -0,0 +1,108 @@
+#[derive(Debug, PartialEq, serde::Deserialize, serde::Serialize)]
+struct MaybeFields {
+    f1: i64,
+    f2: Option<i64>,
+    f3: Option<Option<i64>>,
+}
+
+#[test]
+fn test_recursive_implicit_some() {
+    // Test case provided by d86leader in
+    //  https://github.com/ron-rs/ron/issues/367#issue-1147920589
+
+    let x1: std::result::Result<MaybeFields, _> =
+        ron::from_str("#![enable(implicit_some)]\n(f1: 1)");
+    let x2: std::result::Result<MaybeFields, _> =
+        ron::from_str("#![enable(implicit_some)]\n(f1: 1, f2: None, f3: None)");
+    let x3: std::result::Result<MaybeFields, _> =
+        ron::from_str("#![enable(implicit_some)]\n(f1: 1, f2: 2, f3: 3)");
+    let x4: std::result::Result<MaybeFields, _> =
+        ron::from_str("#![enable(implicit_some)]\n(f1: 1, f2: 2, f3: Some(3))");
+    let x5: std::result::Result<MaybeFields, _> =
+        ron::from_str("#![enable(implicit_some)]\n(f1: 1, f2: 2, f3: Some(Some(3)))");
+    let x6: std::result::Result<MaybeFields, _> =
+        ron::from_str("#![enable(implicit_some)]\n(f1: 1, f2: 2, f3: Some(None))");
+
+    assert_eq!(
+        x1,
+        Ok(MaybeFields {
+            f1: 1,
+            f2: None,
+            f3: None
+        })
+    );
+    assert_eq!(
+        x2,
+        Ok(MaybeFields {
+            f1: 1,
+            f2: None,
+            f3: None
+        })
+    );
+    assert_eq!(
+        x3,
+        Ok(MaybeFields {
+            f1: 1,
+            f2: Some(2),
+            f3: Some(Some(3))
+        })
+    );
+    assert_eq!(
+        x4,
+        Ok(MaybeFields {
+            f1: 1,
+            f2: Some(2),
+            f3: Some(Some(3))
+        })
+    );
+    assert_eq!(
+        x5,
+        Ok(MaybeFields {
+            f1: 1,
+            f2: Some(2),
+            f3: Some(Some(3))
+        })
+    );
+    assert_eq!(
+        x6,
+        Ok(MaybeFields {
+            f1: 1,
+            f2: Some(2),
+            f3: Some(None)
+        })
+    );
+}
+
+#[test]
+fn test_nested_implicit_some() {
+    assert_eq!(
+        ron::from_str::<Option<Option<Option<u32>>>>("#![enable(implicit_some)]\n5"),
+        Ok(Some(Some(Some(5))))
+    );
+    assert_eq!(
+        ron::from_str::<Option<Option<Option<u32>>>>("#![enable(implicit_some)]\nNone"),
+        Ok(None)
+    );
+    assert_eq!(
+        ron::from_str::<Option<Option<Option<u32>>>>("#![enable(implicit_some)]\nSome(5)"),
+        Ok(Some(Some(Some(5))))
+    );
+    assert_eq!(
+        ron::from_str::<Option<Option<Option<u32>>>>("#![enable(implicit_some)]\nSome(None)"),
+        Ok(Some(None))
+    );
+    assert_eq!(
+        ron::from_str::<Option<Option<Option<u32>>>>("#![enable(implicit_some)]\nSome(Some(5))"),
+        Ok(Some(Some(Some(5))))
+    );
+    assert_eq!(
+        ron::from_str::<Option<Option<Option<u32>>>>("#![enable(implicit_some)]\nSome(Some(None))"),
+        Ok(Some(Some(None)))
+    );
+    assert_eq!(
+        ron::from_str::<Option<Option<Option<u32>>>>(
+            "#![enable(implicit_some)]\nSome(Some(Some(5)))"
+        ),
+        Ok(Some(Some(Some(5))))
+    );
+}

vendor/ron/tests/370_float_parsing.rs

@@ -0,0 +1,66 @@
+use ron::{
+    de::{Position, SpannedError},
+    Error,
+};
+
+#[test]
+fn test_float_literal_parsing() {
+    assert_eq!(ron::from_str("inf"), Ok(f64::INFINITY));
+    assert_eq!(ron::from_str("+inf"), Ok(f64::INFINITY));
+    assert_eq!(ron::from_str("-inf"), Ok(f64::NEG_INFINITY));
+
+    assert!(ron::from_str::<f64>("NaN").unwrap().is_nan());
+    assert!(ron::from_str::<f64>("+NaN").unwrap().is_nan());
+    assert!(ron::from_str::<f64>("-NaN").unwrap().is_nan());
+
+    assert_eq!(ron::from_str("1"), Ok(1.0_f64));
+    assert_eq!(ron::from_str("+1"), Ok(1.0_f64));
+    assert_eq!(ron::from_str("-1"), Ok(-1.0_f64));
+    assert_eq!(ron::from_str("1e3"), Ok(1000.0_f64));
+    assert_eq!(ron::from_str("1e+1"), Ok(10.0_f64));
+    assert_eq!(ron::from_str("7E-1"), Ok(0.7_f64));
+
+    assert_eq!(ron::from_str("1."), Ok(1.0_f64));
+    assert_eq!(ron::from_str("+1.1"), Ok(1.1_f64));
+    assert_eq!(ron::from_str("-1.42"), Ok(-1.42_f64));
+    assert_eq!(ron::from_str("-1.5e3"), Ok(-1500.0_f64));
+    assert_eq!(ron::from_str("1.e+1"), Ok(10.0_f64));
+    assert_eq!(ron::from_str("7.4E-1"), Ok(0.74_f64));
+
+    assert_eq!(ron::from_str(".1"), Ok(0.1_f64));
+    assert_eq!(ron::from_str("+.1"), Ok(0.1_f64));
+    assert_eq!(ron::from_str("-.42"), Ok(-0.42_f64));
+    assert_eq!(ron::from_str("-.5e3"), Ok(-500.0_f64));
+    assert_eq!(ron::from_str(".3e+1"), Ok(3.0_f64));
+    assert_eq!(ron::from_str(".4E-1"), Ok(0.04_f64));
+
+    assert_eq!(
+        ron::from_str::<f64>("1_0.1_0"),
+        Err(SpannedError {
+            code: Error::FloatUnderscore,
+            position: Position { line: 1, col: 2 },
+        })
+    );
+    assert_eq!(
+        ron::from_str::<f64>("1_0.10"),
+        Err(SpannedError {
+            code: Error::FloatUnderscore,
+            position: Position { line: 1, col: 2 },
+        })
+    );
+    assert_eq!(
+        ron::from_str::<f64>("10.1_0"),
+        Err(SpannedError {
+            code: Error::FloatUnderscore,
+            position: Position { line: 1, col: 5 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<f64>("1.0e1.0"),
+        Err(SpannedError {
+            code: Error::ExpectedFloat,
+            position: Position { line: 1, col: 8 },
+        })
+    );
+}

vendor/ron/tests/393_serde_errors.rs

@@ -0,0 +1,215 @@
+use ron::error::{Error, Position, SpannedError};
+
+#[derive(Debug, serde::Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+enum TestEnum {
+    StructVariant { a: bool, b: char, c: i32 },
+    NewtypeVariant(TestStruct),
+}
+
+#[derive(Debug, serde::Deserialize, PartialEq)]
+#[serde(tag = "type")]
+enum TestEnumInternal {
+    StructVariant { a: bool },
+}
+
+#[derive(Debug, serde::Deserialize, PartialEq)]
+#[serde(tag = "type", content = "content")]
+enum TestEnumAdjacent {
+    StructVariant { a: bool },
+}
+
+#[derive(Debug, serde::Deserialize, PartialEq)]
+#[serde(untagged)]
+enum TestEnumUntagged {
+    StructVariant { a: bool },
+}
+
+#[derive(Debug, serde::Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct TestStruct {
+    a: bool,
+    b: char,
+    c: i32,
+}
+
+#[test]
+fn test_unknown_enum_variant() {
+    assert_eq!(
+        ron::from_str::<TestEnum>("NotAVariant"),
+        Err(SpannedError {
+            code: Error::NoSuchEnumVariant {
+                expected: &["StructVariant", "NewtypeVariant"],
+                found: String::from("NotAVariant"),
+                outer: Some(String::from("TestEnum")),
+            },
+            position: Position { line: 1, col: 12 },
+        })
+    );
+}
+
+#[test]
+fn test_struct_enum_fields() {
+    assert_eq!(
+        ron::from_str::<TestEnum>("StructVariant(a: true, b: 'b', c: -42, d: \"gotcha\")"),
+        Err(SpannedError {
+            code: Error::NoSuchStructField {
+                expected: &["a", "b", "c"],
+                found: String::from("d"),
+                outer: Some(String::from("StructVariant")),
+            },
+            position: Position { line: 1, col: 41 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<TestEnum>("StructVariant(a: true, c: -42)"),
+        Err(SpannedError {
+            code: Error::MissingStructField {
+                field: "b",
+                outer: Some(String::from("StructVariant")),
+            },
+            position: Position { line: 1, col: 30 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<TestEnum>("StructVariant(a: true, b: 'b', a: false, c: -42)"),
+        Err(SpannedError {
+            code: Error::DuplicateStructField {
+                field: "a",
+                outer: Some(String::from("StructVariant")),
+            },
+            position: Position { line: 1, col: 33 },
+        })
+    );
+}
+
+#[test]
+fn test_newtype_enum_fields() {
+    assert_eq!(
+        ron::from_str::<TestEnum>("#![enable(unwrap_variant_newtypes)] NewtypeVariant(a: true, b: 'b', c: -42, d: \"gotcha\")"),
+        Err(SpannedError {
+            code: Error::NoSuchStructField {
+                expected: &["a", "b", "c"],
+                found: String::from("d"),
+                outer: Some(String::from("NewtypeVariant")),
+            },
+            position: Position { line: 1, col: 78 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<TestEnum>(
+            "#![enable(unwrap_variant_newtypes)] NewtypeVariant(a: true, c: -42)"
+        ),
+        Err(SpannedError {
+            code: Error::MissingStructField {
+                field: "b",
+                outer: Some(String::from("NewtypeVariant")),
+            },
+            position: Position { line: 1, col: 67 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<TestEnum>(
+            "#![enable(unwrap_variant_newtypes)] NewtypeVariant(a: true, b: 'b', a: false, c: -42)"
+        ),
+        Err(SpannedError {
+            code: Error::DuplicateStructField {
+                field: "a",
+                outer: Some(String::from("NewtypeVariant")),
+            },
+            position: Position { line: 1, col: 70 },
+        })
+    );
+}
+
+#[test]
+fn test_struct_fields() {
+    assert_eq!(
+        ron::from_str::<TestStruct>("TestStruct(a: true, b: 'b', c: -42, d: \"gotcha\")"),
+        Err(SpannedError {
+            code: Error::NoSuchStructField {
+                expected: &["a", "b", "c"],
+                found: String::from("d"),
+                outer: Some(String::from("TestStruct")),
+            },
+            position: Position { line: 1, col: 38 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<TestStruct>("TestStruct(a: true, c: -42)"),
+        Err(SpannedError {
+            code: Error::MissingStructField {
+                field: "b",
+                outer: Some(String::from("TestStruct")),
+            },
+            position: Position { line: 1, col: 27 },
+        })
+    );
+
+    assert_eq!(
+        ron::from_str::<TestStruct>("TestStruct(a: true, b: 'b', a: false, c: -42)"),
+        Err(SpannedError {
+            code: Error::DuplicateStructField {
+                field: "a",
+                outer: Some(String::from("TestStruct")),
+            },
+            position: Position { line: 1, col: 30 },
+        })
+    );
+}
+
+#[test]
+fn test_internally_tagged_enum() {
+    // Note: Not extracting the variant type is not great,
+    //        but at least not wrong either
+    //       Since the error occurs in serde-generated user code,
+    //        after successfully deserialising, we cannot annotate
+
+    assert_eq!(
+        ron::from_str::<TestEnumInternal>("(type: \"StructVariant\")"),
+        Err(SpannedError {
+            code: Error::MissingStructField {
+                field: "a",
+                outer: None,
+            },
+            position: Position { line: 1, col: 24 },
+        })
+    );
+}
+
+#[test]
+fn test_adjacently_tagged_enum() {
+    // Note: TestEnumAdjacent makes sense here since we are now treating
+    //        the enum as a struct
+
+    assert_eq!(
+        ron::from_str::<TestEnumAdjacent>("(type: StructVariant, content: (d: 4))"),
+        Err(SpannedError {
+            code: Error::MissingStructField {
+                field: "a",
+                outer: Some(String::from("TestEnumAdjacent")),
+            },
+            position: Position { line: 1, col: 37 },
+        })
+    );
+}
+
+#[test]
+fn test_untagged_enum() {
+    // Note: Errors inside untagged enums are not bubbled up
+
+    assert_eq!(
+        ron::from_str::<TestEnumUntagged>("(a: true, a: false)"),
+        Err(SpannedError {
+            code: Error::Message(String::from(
+                "data did not match any variant of untagged enum TestEnumUntagged"
+            )),
+            position: Position { line: 1, col: 20 },
+        })
+    );
+}

vendor/ron/tests/401_raw_identifier.rs

@@ -0,0 +1,177 @@
+use ron::error::{Error, Position, SpannedError};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename = "Hello World")]
+struct InvalidStruct;
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename = "")]
+struct EmptyStruct;
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+#[serde(rename = "Hello+World")]
+#[serde(deny_unknown_fields)]
+struct RawStruct {
+    #[serde(rename = "ab.cd-ef")]
+    field: bool,
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+enum RawEnum {
+    #[serde(rename = "Hello-World")]
+    RawVariant,
+}
+
+#[test]
+fn test_invalid_identifiers() {
+    let ser = ron::ser::to_string_pretty(
+        &InvalidStruct,
+        ron::ser::PrettyConfig::default().struct_names(true),
+    );
+    assert_eq!(
+        ser,
+        Err(Error::InvalidIdentifier(String::from("Hello World")))
+    );
+
+    let ser = ron::ser::to_string_pretty(
+        &EmptyStruct,
+        ron::ser::PrettyConfig::default().struct_names(true),
+    );
+    assert_eq!(ser, Err(Error::InvalidIdentifier(String::from(""))));
+
+    let de = ron::from_str::<InvalidStruct>("Hello World").unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::ExpectedDifferentStructName {
+                expected: "Hello World",
+                found: String::from("Hello"),
+            },
+            position: Position { line: 1, col: 6 },
+        }
+    );
+
+    let de = ron::from_str::<EmptyStruct>("").unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::ExpectedUnit,
+            position: Position { line: 1, col: 1 },
+        }
+    );
+
+    let de = ron::from_str::<EmptyStruct>("r#").unwrap_err();
+    assert_eq!(
+        format!("{}", de),
+        "1:1: Expected only opening `(`, no name, for un-nameable struct"
+    );
+
+    let de = ron::from_str::<RawStruct>("").unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::ExpectedNamedStructLike("Hello+World"),
+            position: Position { line: 1, col: 1 },
+        },
+    );
+
+    let de = ron::from_str::<RawStruct>("r#").unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::ExpectedNamedStructLike("Hello+World"),
+            position: Position { line: 1, col: 1 },
+        },
+    );
+
+    let de = ron::from_str::<RawStruct>("Hello+World").unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::SuggestRawIdentifier(String::from("Hello+World")),
+            position: Position { line: 1, col: 1 },
+        }
+    );
+
+    let de = ron::from_str::<RawStruct>(
+        "r#Hello+World(
+        ab.cd-ef: true,
+    )",
+    )
+    .unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::SuggestRawIdentifier(String::from("ab.cd-ef")),
+            position: Position { line: 2, col: 9 },
+        }
+    );
+
+    let de = ron::from_str::<RawStruct>(
+        "r#Hello+World(
+        r#ab.cd+ef: true,
+    )",
+    )
+    .unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::NoSuchStructField {
+                expected: &["ab.cd-ef"],
+                found: String::from("ab.cd+ef"),
+                outer: Some(String::from("Hello+World")),
+            },
+            position: Position { line: 2, col: 19 },
+        }
+    );
+
+    let de = ron::from_str::<RawEnum>("Hello-World").unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::SuggestRawIdentifier(String::from("Hello-World")),
+            position: Position { line: 1, col: 1 },
+        }
+    );
+
+    let de = ron::from_str::<RawEnum>("r#Hello+World").unwrap_err();
+    assert_eq!(
+        de,
+        SpannedError {
+            code: Error::NoSuchEnumVariant {
+                expected: &["Hello-World"],
+                found: String::from("Hello+World"),
+                outer: Some(String::from("RawEnum")),
+            },
+            position: Position { line: 1, col: 14 },
+        }
+    );
+
+    let de = ron::from_str::<EmptyStruct>("r#+").unwrap_err();
+    assert_eq!(
+        format!("{}", de),
+        r#"1:4: Expected struct ""_[invalid identifier] but found `r#+`"#,
+    );
+}
+
+#[test]
+fn test_raw_identifier_roundtrip() {
+    let val = RawStruct { field: true };
+
+    let ser =
+        ron::ser::to_string_pretty(&val, ron::ser::PrettyConfig::default().struct_names(true))
+            .unwrap();
+    assert_eq!(ser, "r#Hello+World(\n    r#ab.cd-ef: true,\n)");
+
+    let de: RawStruct = ron::from_str(&ser).unwrap();
+    assert_eq!(de, val);
+
+    let val = RawEnum::RawVariant;
+
+    let ser = ron::ser::to_string(&val).unwrap();
+    assert_eq!(ser, "r#Hello-World");
+
+    let de: RawEnum = ron::from_str(&ser).unwrap();
+    assert_eq!(de, val);
+}

vendor/ron/tests/410_trailing_comma.rs

@@ -0,0 +1,95 @@
+use std::collections::HashMap;
+
+use ron::from_str;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+struct Newtype(i32);
+
+#[derive(Deserialize)]
+struct Tuple(i32, i32);
+
+#[derive(Deserialize)]
+#[allow(dead_code)]
+struct Struct {
+    a: i32,
+    b: i32,
+}
+
+#[derive(Deserialize)]
+#[allow(dead_code)]
+enum Enum {
+    Newtype(i32),
+    Tuple(i32, i32),
+    Struct { a: i32, b: i32 },
+}
+
+#[test]
+fn test_trailing_comma_some() {
+    assert!(from_str::<Option<i32>>("Some(1)").is_ok());
+    assert!(from_str::<Option<i32>>("Some(1,)").is_ok());
+    assert!(from_str::<Option<i32>>("Some(1,,)").is_err());
+}
+
+#[test]
+fn test_trailing_comma_tuple() {
+    assert!(from_str::<(i32, i32)>("(1,2)").is_ok());
+    assert!(from_str::<(i32, i32)>("(1,2,)").is_ok());
+    assert!(from_str::<(i32, i32)>("(1,2,,)").is_err());
+}
+
+#[test]
+fn test_trailing_comma_list() {
+    assert!(from_str::<Vec<i32>>("[1,2]").is_ok());
+    assert!(from_str::<Vec<i32>>("[1,2,]").is_ok());
+    assert!(from_str::<Vec<i32>>("[1,2,,]").is_err());
+}
+
+#[test]
+fn test_trailing_comma_map() {
+    assert!(from_str::<HashMap<i32, bool>>("{1:false,2:true}").is_ok());
+    assert!(from_str::<HashMap<i32, bool>>("{1:false,2:true,}").is_ok());
+    assert!(from_str::<HashMap<i32, bool>>("{1:false,2:true,,}").is_err());
+}
+
+#[test]
+fn test_trailing_comma_newtype_struct() {
+    assert!(from_str::<Newtype>("(1)").is_ok());
+    assert!(from_str::<Newtype>("(1,)").is_ok());
+    assert!(from_str::<Newtype>("(1,,)").is_err());
+}
+
+#[test]
+fn test_trailing_comma_tuple_struct() {
+    assert!(from_str::<Tuple>("(1,2)").is_ok());
+    assert!(from_str::<Tuple>("(1,2,)").is_ok());
+    assert!(from_str::<Tuple>("(1,2,,)").is_err());
+}
+
+#[test]
+fn test_trailing_comma_struct() {
+    assert!(from_str::<Struct>("(a:1,b:2)").is_ok());
+    assert!(from_str::<Struct>("(a:1,b:2,)").is_ok());
+    assert!(from_str::<Struct>("(a:1,b:2,,)").is_err());
+}
+
+#[test]
+fn test_trailing_comma_enum_newtype_variant() {
+    assert!(from_str::<Enum>("Newtype(1)").is_ok());
+    assert!(from_str::<Enum>("Newtype(1,)").is_ok());
+    assert!(from_str::<Enum>("Newtype(1,,)").is_err());
+}
+
+#[test]
+fn test_trailing_comma_enum_tuple_variant() {
+    assert!(from_str::<Enum>("Tuple(1,2)").is_ok());
+    assert!(from_str::<Enum>("Tuple(1,2,)").is_ok());
+    assert!(from_str::<Enum>("Tuple(1,2,,)").is_err());
+}
+
+#[test]
+fn test_trailing_comma_enum_struct_variant() {
+    assert!(from_str::<Enum>("Struct(a:1,b:2)").is_ok());
+    assert!(from_str::<Enum>("Struct(a:1,b:2,)").is_ok());
+    assert!(from_str::<Enum>("Struct(a:1,b:2,,)").is_err());
+}

vendor/ron/tests/423_de_borrowed_identifier.rs

@@ -0,0 +1,45 @@
+use std::any::Any;
+
+use serde::{
+    de::{MapAccess, Visitor},
+    Deserializer,
+};
+
+#[test]
+fn manually_deserialize_dyn() {
+    let ron = r#"SerializeDyn(
+        type: "engine_utils::types::registry::tests::Player",
+    )"#;
+
+    let mut de = ron::Deserializer::from_bytes(ron.as_bytes()).unwrap();
+
+    let result = de
+        .deserialize_struct("SerializeDyn", &["type"], SerializeDynVisitor)
+        .unwrap();
+
+    assert_eq!(
+        *result.downcast::<Option<(String, String)>>().unwrap(),
+        Some((
+            String::from("type"),
+            String::from("engine_utils::types::registry::tests::Player")
+        ))
+    );
+}
+
+struct SerializeDynVisitor;
+
+impl<'de> Visitor<'de> for SerializeDynVisitor {
+    type Value = Box<dyn Any>;
+
+    // GRCOV_EXCL_START
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(formatter, "a serialize dyn struct")
+    }
+    // GRCOV_EXCL_STOP
+
+    fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
+        let entry = map.next_entry::<&str, String>()?;
+
+        Ok(Box::new(entry.map(|(k, v)| (String::from(k), v))))
+    }
+}

vendor/ron/tests/462_bytes.rs

@@ -0,0 +1,22 @@
+#[test]
+fn test_deserialise_byte_slice() {
+    let val: &[u8] = &[0_u8, 1_u8, 2_u8, 3_u8];
+    let ron = ron::to_string(val).unwrap();
+    assert_eq!(ron, "[0,1,2,3]");
+
+    // deserialising a byte slice from a byte sequence should fail
+    //  with the error that a borrowed slice was expected but a byte
+    //  buffer was provided
+    // NOT with an expected string error, since the byte slice
+    //  serialisation never serialises to a string
+    assert_eq!(
+        ron::from_str::<&[u8]>(&ron),
+        Err(ron::error::SpannedError {
+            code: ron::error::Error::InvalidValueForType {
+                expected: String::from("a borrowed byte array"),
+                found: String::from("the bytes \"AAECAw==\""),
+            },
+            position: ron::error::Position { line: 1, col: 10 },
+        })
+    );
+}

vendor/ron/tests/big_struct.rs

@@ -0,0 +1,79 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+pub struct ImVec2 {
+    pub x: f32,
+    pub y: f32,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct ImColorsSave {
+    pub text: f32,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct ImGuiStyleSave {
+    pub alpha: f32,
+    pub window_padding: ImVec2,
+    pub window_min_size: ImVec2,
+    pub window_rounding: f32,
+    pub window_title_align: ImVec2,
+    pub child_window_rounding: f32,
+    pub frame_padding: ImVec2,
+    pub frame_rounding: f32,
+    pub item_spacing: ImVec2,
+    pub item_inner_spacing: ImVec2,
+    pub touch_extra_padding: ImVec2,
+    pub indent_spacing: f32,
+    pub columns_min_spacing: f32,
+    pub scrollbar_size: f32,
+    pub scrollbar_rounding: f32,
+    pub grab_min_size: f32,
+    pub grab_rounding: f32,
+    pub button_text_align: ImVec2,
+    pub display_window_padding: ImVec2,
+    pub display_safe_area_padding: ImVec2,
+    pub anti_aliased_lines: bool,
+    pub anti_aliased_shapes: bool,
+    pub curve_tessellation_tol: f32,
+    pub colors: ImColorsSave,
+    pub new_type: NewType,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct NewType(i32);
+
+const CONFIG: &str = "(
+    alpha: 1.0,
+    window_padding: (x: 8, y: 8),
+    window_min_size: (x: 32, y: 32),
+    window_rounding: 9.0,
+    window_title_align: (x: 0.0, y: 0.5),
+    child_window_rounding: 0.0,
+    frame_padding: (x: 4, y: 3),
+    frame_rounding: 0.0,
+    item_spacing: (x: 8, y: 4),
+    item_inner_spacing: (x: 4, y: 4),
+    touch_extra_padding: (x: 0, y: 0),
+    indent_spacing: 21.0,
+    columns_min_spacing: 6.0,
+    scrollbar_size: 16,
+    scrollbar_rounding: 9,
+    grab_min_size: 10,
+    grab_rounding: 0,
+    button_text_align: (x: 0.5, y: 0.5),
+    display_window_padding: (x: 22, y: 22),
+    display_safe_area_padding: (x: 4, y: 4),
+    anti_aliased_lines: true,
+    anti_aliased_shapes: true,
+    curve_tessellation_tol: 1.25,
+    colors: (text: 4),
+    new_type: NewType(     1  ),
+
+    ignored_field: \"Totally ignored, not causing a panic. Hopefully.\",
+)";
+
+#[test]
+fn deserialize_big_struct() {
+    ron::de::from_str::<ImGuiStyleSave>(CONFIG).unwrap();
+}

vendor/ron/tests/borrowed_str.rs

@@ -0,0 +1,16 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
+struct Borrowed<'a> {
+    value: &'a str,
+}
+
+const BORROWED: &str = "Borrowed(value: \"test\")";
+
+#[test]
+fn borrowed_str() {
+    assert_eq!(
+        ron::de::from_str(BORROWED).ok(),
+        Some(Borrowed { value: "test" })
+    );
+}

vendor/ron/tests/comments.rs

@@ -0,0 +1,52 @@
+use ron::de::{from_str, Error, Position, SpannedError as RonErr};
+
+#[test]
+fn test_simple() {
+    assert_eq!(
+        from_str(
+            "/*
+ * We got a hexadecimal number here!
+ *
+ */0x507"
+        ),
+        Ok(0x507)
+    );
+}
+
+#[test]
+fn test_nested() {
+    assert_eq!(
+        from_str(
+            "/*
+        /* quite * some * nesting * going * on * /* here /* (yeah, maybe a bit too much) */ */ */
+    */
+    // The actual value comes.. /*
+    // very soon, these are just checks that */
+    // multi-line comments don't trigger in line comments /*
+\"THE VALUE\" /* This is the value /* :) */ */
+    "
+        ),
+        Ok("THE VALUE".to_owned())
+    );
+}
+
+#[test]
+fn test_unclosed() {
+    assert_eq!(
+        from_str::<String>(
+            "/*
+        /* quite * some * nesting * going * on * /* here /* (yeah, maybe a bit too much) */ */ */
+    */
+    // The actual value comes.. /*
+    // very soon, these are just checks that */
+    // multi-line comments don't trigger in line comments /*
+/* Unfortunately, this comment won't get closed :(
+\"THE VALUE (which is invalid)\"
+"
+        ),
+        Err(RonErr {
+            code: Error::UnclosedBlockComment,
+            position: Position { col: 1, line: 9 }
+        })
+    );
+}

vendor/ron/tests/depth_limit.rs

@@ -0,0 +1,60 @@
+use std::collections::HashMap;
+
+use serde::Serialize;
+
+#[derive(Serialize)]
+struct Config {
+    float: (f32, f64),
+    tuple: TupleStruct,
+    map: HashMap<u8, char>,
+    nested: Nested,
+    var: Variant,
+    array: Vec<()>,
+}
+
+#[derive(Serialize)]
+struct TupleStruct((), bool);
+
+#[derive(Serialize)]
+enum Variant {
+    A(u8, &'static str),
+}
+
+#[derive(Serialize)]
+struct Nested {
+    a: String,
+    b: char,
+}
+
+const EXPECTED: &str = "(
+    float: (2.18, -1.1),
+    tuple: ((), false),
+    map: {8: '1'},
+    nested: (a: \"a\", b: 'b'),
+    var: A(255, \"\"),
+    array: [(), (), ()],
+)";
+
+#[test]
+fn depth_limit() {
+    let data = Config {
+        float: (2.18, -1.1),
+        tuple: TupleStruct((), false),
+        map: vec![(8, '1')].into_iter().collect(),
+        nested: Nested {
+            a: "a".to_owned(),
+            b: 'b',
+        },
+        var: Variant::A(!0, ""),
+        array: vec![(); 3],
+    };
+
+    let pretty = ron::ser::PrettyConfig::new()
+        .depth_limit(1)
+        .separate_tuple_members(true)
+        .enumerate_arrays(true)
+        .new_line("\n".to_string());
+    let s = ron::ser::to_string_pretty(&data, pretty);
+
+    assert_eq!(s, Ok(EXPECTED.to_string()));
+}

vendor/ron/tests/escape.rs

@@ -0,0 +1,78 @@
+use std::{char::from_u32, fmt::Debug};
+
+use ron::{de::from_str, ser::to_string};
+use serde::{Deserialize, Serialize};
+
+#[test]
+fn test_escape_basic() {
+    assert_eq!(to_string(&"\x07").unwrap(), "\"\\u{7}\"");
+
+    assert_eq!(from_str::<String>("\"\\x07\"").unwrap(), "\x07");
+    assert_eq!(from_str::<String>("\"\\u{7}\"").unwrap(), "\x07");
+
+    assert_eq!(from_str::<char>("\'\\x07\'").unwrap(), '\x07');
+    assert_eq!(from_str::<char>("\'\\u{7}\'").unwrap(), '\x07');
+}
+
+fn check_same<T>(t: T)
+where
+    T: Debug + for<'a> Deserialize<'a> + PartialEq + Serialize,
+{
+    let s: String = to_string(&t).unwrap();
+
+    println!("Serialized: \n\n{}\n\n", s);
+
+    assert_eq!(from_str(&s), Ok(t));
+}
+
+#[test]
+fn test_ascii_10() {
+    check_same("\u{10}".to_owned());
+}
+
+#[test]
+fn test_ascii_chars() {
+    (1..128).into_iter().flat_map(from_u32).for_each(check_same)
+}
+
+#[test]
+fn test_ascii_string() {
+    let s: String = (1..128).into_iter().flat_map(from_u32).collect();
+
+    check_same(s);
+}
+
+#[test]
+fn test_non_ascii() {
+    assert_eq!(to_string(&"♠").unwrap(), "\"♠\"");
+    assert_eq!(to_string(&"ß").unwrap(), "\"ß\"");
+    assert_eq!(to_string(&"ä").unwrap(), "\"ä\"");
+    assert_eq!(to_string(&"ö").unwrap(), "\"ö\"");
+    assert_eq!(to_string(&"ü").unwrap(), "\"ü\"");
+}
+
+#[test]
+fn test_chars() {
+    assert_eq!(to_string(&'♠').unwrap(), "'♠'");
+    assert_eq!(to_string(&'ß').unwrap(), "'ß'");
+    assert_eq!(to_string(&'ä').unwrap(), "'ä'");
+    assert_eq!(to_string(&'ö').unwrap(), "'ö'");
+    assert_eq!(to_string(&'ü').unwrap(), "'ü'");
+    assert_eq!(to_string(&'\u{715}').unwrap(), "'\u{715}'");
+    assert_eq!(
+        from_str::<char>("'\u{715}'").unwrap(),
+        from_str("'\\u{715}'").unwrap()
+    );
+}
+
+#[test]
+fn test_nul_in_string() {
+    assert_eq!(
+        from_str("\"Hello\0World!\""),
+        Ok(String::from("Hello\0World!"))
+    );
+
+    check_same("Hello\0World!".to_owned());
+    check_same("Hello\x00World!".to_owned());
+    check_same("Hello\u{0}World!".to_owned());
+}

vendor/ron/tests/extensions.rs

@@ -0,0 +1,92 @@
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct UnitStruct;
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct NewType(f32);
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct TupleStruct(UnitStruct, i8);
+
+#[derive(Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+struct Key(u32);
+
+#[derive(Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+enum Enum {
+    Unit,
+    Bool(bool),
+    Chars(char, String),
+}
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct Struct {
+    tuple: ((), NewType, TupleStruct),
+    vec: Vec<Option<UnitStruct>>,
+    map: HashMap<Key, Enum>,
+}
+
+const CONFIG_U_NT: &str = "
+#![enable(unwrap_newtypes)]
+
+(
+    tuple: ((), 0.5, ((), -5)),
+    vec: [
+        None,
+        Some(()),
+    ],
+    map: {
+        7: Bool(true),
+        9: Chars('x', \"\"),
+        6: Bool(false),
+        5: Unit,
+    },
+)
+";
+
+#[test]
+fn unwrap_newtypes() {
+    let d: Struct = ron::de::from_str(CONFIG_U_NT).expect("Failed to deserialize");
+
+    println!("unwrap_newtypes: {:#?}", d);
+
+    let s = ron::ser::to_string_pretty(
+        &d,
+        ron::ser::PrettyConfig::default().extensions(ron::extensions::Extensions::UNWRAP_NEWTYPES),
+    )
+    .expect("Failed to serialize");
+
+    let d2: Struct = ron::de::from_str(&s).expect("Failed to deserialize");
+
+    assert_eq!(d, d2);
+}
+
+const CONFIG_I_S: &str = "
+#![enable(implicit_some)]
+
+(
+    tuple: ((), (0.5), ((), -5)),
+    vec: [
+        None,
+        (),
+        UnitStruct,
+        None,
+        (),
+    ],
+    map: {
+        (7): Bool(true),
+        (9): Chars('x', \"\"),
+        (6): Bool(false),
+        (5): Unit,
+    },
+)
+";
+
+#[test]
+fn implicit_some() {
+    let d: Struct = ron::de::from_str(CONFIG_I_S).expect("Failed to deserialize");
+
+    println!("implicit_some: {:#?}", d);
+}

vendor/ron/tests/floats.rs

@@ -0,0 +1,23 @@
+use ron::{
+    de::from_str,
+    ser::{to_string, to_string_pretty, PrettyConfig},
+};
+
+#[test]
+fn test_inf_and_nan() {
+    assert_eq!(from_str("inf"), Ok(std::f64::INFINITY));
+    assert_eq!(from_str("-inf"), Ok(std::f64::NEG_INFINITY));
+    assert_eq!(from_str::<f64>("NaN").map(|n| n.is_nan()), Ok(true))
+}
+
+#[test]
+fn decimal_floats() {
+    let non_pretty = to_string(&1.0).unwrap();
+    assert_eq!(non_pretty, "1.0");
+
+    let with_pretty = to_string_pretty(&1.0, PrettyConfig::new()).unwrap();
+    assert_eq!(with_pretty, "1.0");
+
+    let tiny_pretty = to_string_pretty(&0.00000000000000005, PrettyConfig::new()).unwrap();
+    assert_eq!(tiny_pretty, "0.00000000000000005");
+}

vendor/ron/tests/large_number.rs

@@ -0,0 +1,28 @@
+use ron::value::{Number, Value};
+
+#[test]
+fn test_large_number() {
+    let test_var = Value::Number(Number::new(10000000000000000000000.0f64));
+    let test_ser = ron::ser::to_string(&test_var).unwrap();
+    let test_deser = ron::de::from_str::<Value>(&test_ser);
+
+    assert_eq!(
+        test_deser.unwrap(),
+        Value::Number(Number::new(10000000000000000000000.0))
+    );
+}
+
+#[test]
+fn test_large_integer_to_float() {
+    use ron::value::Float;
+    let test_var = std::i64::MAX as u64 + 1;
+    let expected = test_var as f64; // Is exactly representable by f64
+    let test_ser = ron::ser::to_string(&test_var).unwrap();
+    assert_eq!(test_ser, test_var.to_string());
+    let test_deser = ron::de::from_str::<Value>(&test_ser);
+
+    assert_eq!(
+        test_deser.unwrap(),
+        Value::Number(Number::Float(Float::new(expected))),
+    );
+}

vendor/ron/tests/min_max.rs

@@ -0,0 +1,69 @@
+use ron::{de::*, ser::*};
+
+#[test]
+fn test_i32_min() {
+    assert_eq!(
+        std::i32::MIN,
+        from_str(&to_string(&std::i32::MIN).unwrap()).unwrap()
+    );
+}
+
+#[test]
+fn test_i32_max() {
+    assert_eq!(
+        std::i32::MAX,
+        from_str(&to_string(&std::i32::MAX).unwrap()).unwrap()
+    );
+}
+
+#[test]
+fn test_i64_min() {
+    assert_eq!(
+        std::i64::MIN,
+        from_str(&to_string(&std::i64::MIN).unwrap()).unwrap()
+    );
+}
+
+#[test]
+fn test_i64_max() {
+    assert_eq!(
+        std::i64::MAX,
+        from_str(&to_string(&std::i64::MAX).unwrap()).unwrap()
+    );
+}
+
+#[cfg(feature = "integer128")]
+#[test]
+fn test_i128_min() {
+    assert_eq!(
+        std::i128::MIN,
+        from_str(&to_string(&std::i128::MIN).unwrap()).unwrap()
+    );
+}
+
+#[cfg(feature = "integer128")]
+#[test]
+fn test_i128_max() {
+    assert_eq!(
+        std::i128::MAX,
+        from_str(&to_string(&std::i128::MAX).unwrap()).unwrap()
+    );
+}
+
+#[cfg(feature = "integer128")]
+#[test]
+fn test_u128_min() {
+    assert_eq!(
+        std::u128::MIN,
+        from_str(&to_string(&std::u128::MIN).unwrap()).unwrap()
+    );
+}
+
+#[cfg(feature = "integer128")]
+#[test]
+fn test_u128_max() {
+    assert_eq!(
+        std::u128::MAX,
+        from_str(&to_string(&std::u128::MAX).unwrap()).unwrap()
+    );
+}

vendor/ron/tests/non_identifier_identifier.rs

@@ -0,0 +1,94 @@
+macro_rules! test_non_identifier {
+    ($test_name:ident => $deserialize_method:ident($($deserialize_param:expr),*)) => {
+        #[test]
+        fn $test_name() {
+            use serde::{Deserialize, Deserializer, de::Visitor, de::MapAccess};
+
+            struct FieldVisitor;
+
+            impl<'de> Visitor<'de> for FieldVisitor {
+                type Value = FieldName;
+
+                // GRCOV_EXCL_START
+                fn expecting(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+                    fmt.write_str("an error")
+                }
+                // GRCOV_EXCL_STOP
+            }
+
+            struct FieldName;
+
+            impl<'de> Deserialize<'de> for FieldName {
+                fn deserialize<D: Deserializer<'de>>(deserializer: D)
+                    -> Result<Self, D::Error>
+                {
+                    deserializer.$deserialize_method($($deserialize_param,)* FieldVisitor)
+                }
+            }
+
+            struct StructVisitor;
+
+            impl<'de> Visitor<'de> for StructVisitor {
+                type Value = Struct;
+
+                // GRCOV_EXCL_START
+                fn expecting(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+                    fmt.write_str("a struct")
+                }
+                // GRCOV_EXCL_STOP
+
+                fn visit_map<A: MapAccess<'de>>(self, mut map: A)
+                    -> Result<Self::Value, A::Error>
+                {
+                    map.next_key::<FieldName>().map(|_| Struct)
+                }
+            }
+
+            #[derive(Debug)]
+            struct Struct;
+
+            impl<'de> Deserialize<'de> for Struct {
+                fn deserialize<D: Deserializer<'de>>(deserializer: D)
+                    -> Result<Self, D::Error>
+                {
+                    deserializer.deserialize_struct("Struct", &[], StructVisitor)
+                }
+            }
+
+            assert_eq!(
+                ron::from_str::<Struct>("(true: 4)").unwrap_err().code,
+                ron::Error::ExpectedIdentifier
+            )
+        }
+    };
+}
+
+test_non_identifier! { test_bool => deserialize_bool() }
+test_non_identifier! { test_i8 => deserialize_i8() }
+test_non_identifier! { test_i16 => deserialize_i16() }
+test_non_identifier! { test_i32 => deserialize_i32() }
+test_non_identifier! { test_i64 => deserialize_i64() }
+#[cfg(feature = "integer128")]
+test_non_identifier! { test_i128 => deserialize_i128() }
+test_non_identifier! { test_u8 => deserialize_u8() }
+test_non_identifier! { test_u16 => deserialize_u16() }
+test_non_identifier! { test_u32 => deserialize_u32() }
+test_non_identifier! { test_u64 => deserialize_u64() }
+#[cfg(feature = "integer128")]
+test_non_identifier! { test_u128 => deserialize_u128() }
+test_non_identifier! { test_f32 => deserialize_f32() }
+test_non_identifier! { test_f64 => deserialize_f64() }
+test_non_identifier! { test_char => deserialize_char() }
+test_non_identifier! { test_string => deserialize_string() }
+test_non_identifier! { test_bytes => deserialize_bytes() }
+test_non_identifier! { test_byte_buf => deserialize_byte_buf() }
+test_non_identifier! { test_option => deserialize_option() }
+test_non_identifier! { test_unit => deserialize_unit() }
+test_non_identifier! { test_unit_struct => deserialize_unit_struct("") }
+test_non_identifier! { test_newtype_struct => deserialize_newtype_struct("") }
+test_non_identifier! { test_seq => deserialize_seq() }
+test_non_identifier! { test_tuple => deserialize_tuple(0) }
+test_non_identifier! { test_tuple_struct => deserialize_tuple_struct("", 0) }
+test_non_identifier! { test_map => deserialize_map() }
+test_non_identifier! { test_struct => deserialize_struct("", &[]) }
+test_non_identifier! { test_enum => deserialize_enum("", &[]) }

vendor/ron/tests/numbers.rs

@@ -0,0 +1,113 @@
+use ron::{
+    de::from_str,
+    error::{Error, Position, SpannedError},
+};
+
+#[test]
+fn test_hex() {
+    assert_eq!(from_str("0x507"), Ok(0x507));
+    assert_eq!(from_str("0x1A5"), Ok(0x1A5));
+    assert_eq!(from_str("0x53C537"), Ok(0x53C537));
+
+    assert_eq!(
+        from_str::<u8>("0x"),
+        Err(SpannedError {
+            code: Error::ExpectedInteger,
+            position: Position { line: 1, col: 3 },
+        })
+    );
+    assert_eq!(
+        from_str::<u8>("0x_1"),
+        Err(SpannedError {
+            code: Error::UnderscoreAtBeginning,
+            position: Position { line: 1, col: 3 },
+        })
+    );
+    assert_eq!(
+        from_str::<u8>("0xFFF"),
+        Err(SpannedError {
+            code: Error::IntegerOutOfBounds,
+            position: Position { line: 1, col: 6 },
+        })
+    );
+}
+
+#[test]
+fn test_bin() {
+    assert_eq!(from_str("0b101"), Ok(0b101));
+    assert_eq!(from_str("0b001"), Ok(0b001));
+    assert_eq!(from_str("0b100100"), Ok(0b100100));
+
+    assert_eq!(
+        from_str::<u8>("0b"),
+        Err(SpannedError {
+            code: Error::ExpectedInteger,
+            position: Position { line: 1, col: 3 },
+        })
+    );
+    assert_eq!(
+        from_str::<u8>("0b_1"),
+        Err(SpannedError {
+            code: Error::UnderscoreAtBeginning,
+            position: Position { line: 1, col: 3 },
+        })
+    );
+    assert_eq!(
+        from_str::<u8>("0b111111111"),
+        Err(SpannedError {
+            code: Error::IntegerOutOfBounds,
+            position: Position { line: 1, col: 12 },
+        })
+    );
+}
+
+#[test]
+fn test_oct() {
+    assert_eq!(from_str("0o1461"), Ok(0o1461));
+    assert_eq!(from_str("0o051"), Ok(0o051));
+    assert_eq!(from_str("0o150700"), Ok(0o150700));
+
+    assert_eq!(
+        from_str::<u8>("0o"),
+        Err(SpannedError {
+            code: Error::ExpectedInteger,
+            position: Position { line: 1, col: 3 },
+        })
+    );
+    assert_eq!(
+        from_str::<u8>("0o_1"),
+        Err(SpannedError {
+            code: Error::UnderscoreAtBeginning,
+            position: Position { line: 1, col: 3 },
+        })
+    );
+    assert_eq!(
+        from_str::<u8>("0o77777"),
+        Err(SpannedError {
+            code: Error::IntegerOutOfBounds,
+            position: Position { line: 1, col: 8 },
+        })
+    );
+}
+
+#[test]
+fn test_dec() {
+    assert_eq!(from_str("1461"), Ok(1461));
+    assert_eq!(from_str("51"), Ok(51));
+    assert_eq!(from_str("150700"), Ok(150700));
+
+    assert_eq!(
+        from_str::<i8>("-_1"),
+        Err(SpannedError {
+            code: Error::UnderscoreAtBeginning,
+            position: Position { line: 1, col: 2 },
+        })
+    );
+    assert_eq!(
+        from_str::<u8>("256"),
+        Err(SpannedError {
+            code: Error::IntegerOutOfBounds,
+            position: Position { line: 1, col: 4 },
+        })
+    );
+}

vendor/ron/tests/options.rs

@@ -0,0 +1,52 @@
+use ron::{extensions::Extensions, ser::PrettyConfig, Options};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+struct Newtype(f64);
+
+#[derive(Serialize, Deserialize)]
+struct Struct(Option<u32>, Newtype);
+
+#[test]
+fn default_options() {
+    let ron = Options::default();
+
+    let de: Struct = ron.from_str("(Some(42),(4.2))").unwrap();
+    let ser = ron.to_string(&de).unwrap();
+
+    assert_eq!(ser, "(Some(42),(4.2))")
+}
+
+#[test]
+fn single_default_extension() {
+    let ron = Options::default().with_default_extension(Extensions::IMPLICIT_SOME);
+
+    let de: Struct = ron.from_str("(42,(4.2))").unwrap();
+    let ser = ron.to_string(&de).unwrap();
+
+    assert_eq!(ser, "(42,(4.2))");
+
+    let de: Struct = ron.from_str("#![enable(implicit_some)](42,(4.2))").unwrap();
+    let ser = ron.to_string(&de).unwrap();
+
+    assert_eq!(ser, "(42,(4.2))");
+
+    let de: Struct = ron
+        .from_str("#![enable(implicit_some)]#![enable(unwrap_newtypes)](42,4.2)")
+        .unwrap();
+    let ser = ron.to_string(&de).unwrap();
+
+    assert_eq!(ser, "(42,(4.2))");
+
+    let de: Struct = ron
+        .from_str("#![enable(implicit_some)]#![enable(unwrap_newtypes)](42,4.2)")
+        .unwrap();
+    let ser = ron
+        .to_string_pretty(
+            &de,
+            PrettyConfig::default().extensions(Extensions::UNWRAP_NEWTYPES),
+        )
+        .unwrap();
+
+    assert_eq!(ser, "#![enable(unwrap_newtypes)]\n(42, 4.2)");
+}

vendor/ron/tests/preserve_sequence.rs

@@ -0,0 +1,48 @@
+use std::collections::BTreeMap;
+
+use ron::{
+    de::from_str,
+    ser::{to_string_pretty, PrettyConfig},
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+struct Config {
+    boolean: bool,
+    float: f32,
+    map: BTreeMap<u8, char>,
+    nested: Nested,
+    tuple: (u32, u32),
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+struct Nested {
+    a: String,
+    b: char,
+}
+
+fn read_original(source: &str) -> String {
+    source.to_string().replace("\r\n", "\n")
+}
+
+fn make_roundtrip(source: &str) -> String {
+    let config: Config = from_str(source).unwrap();
+    let pretty = PrettyConfig::new()
+        .depth_limit(3)
+        .separate_tuple_members(true)
+        .enumerate_arrays(true)
+        .new_line("\n".into());
+    to_string_pretty(&config, pretty).expect("Serialization failed")
+}
+
+#[test]
+fn test_sequence_ex1() {
+    let file = include_str!("preserve_sequence_ex1.ron");
+    assert_eq!(read_original(file), make_roundtrip(file));
+}
+
+#[test]
+fn test_sequence_ex2() {
+    let file = include_str!("preserve_sequence_ex2.ron");
+    assert_eq!(read_original(file), make_roundtrip(file));
+}

vendor/ron/tests/preserve_sequence_ex1.ron

@@ -0,0 +1,20 @@
+(
+    boolean: true,
+    float: 8.2,
+    map: {
+        1: '1',
+        2: '4',
+        3: '9',
+        4: '1',
+        5: '2',
+        6: '3',
+    },
+    nested: (
+        a: "Decode me!",
+        b: 'z',
+    ),
+    tuple: (
+        3,
+        7,
+    ),
+)

vendor/ron/tests/preserve_sequence_ex2.ron

@@ -0,0 +1,15 @@
+(
+    boolean: true,
+    float: 8.2,
+    map: {
+        1: '1',
+    },
+    nested: (
+        a: "Decode me!",
+        b: 'z',
+    ),
+    tuple: (
+        3,
+        7,
+    ),
+)

vendor/ron/tests/roundtrip.rs

@@ -0,0 +1,121 @@
+use std::collections::HashMap;
+
+use ron::extensions::Extensions;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct UnitStruct;
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct NewType(f32);
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct TupleStruct(UnitStruct, i8);
+
+#[derive(Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+struct Key(u32);
+
+#[derive(Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+enum Enum {
+    Unit,
+    Bool(bool),
+    Chars(char, String),
+}
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct Struct {
+    tuple: ((), NewType, TupleStruct),
+    vec: Vec<Option<UnitStruct>>,
+    map: HashMap<Key, Enum>,
+}
+
+#[test]
+fn roundtrip() {
+    let value = Struct {
+        tuple: ((), NewType(0.5), TupleStruct(UnitStruct, -5)),
+        vec: vec![None, Some(UnitStruct)],
+        map: vec![
+            (Key(5), Enum::Unit),
+            (Key(6), Enum::Bool(false)),
+            (Key(7), Enum::Bool(true)),
+            (Key(9), Enum::Chars('x', "".to_string())),
+        ]
+        .into_iter()
+        .collect(),
+    };
+
+    let serial = ron::ser::to_string(&value).unwrap();
+
+    println!("Serialized: {}", serial);
+
+    let deserial = ron::de::from_str(&serial);
+
+    assert_eq!(Ok(value), deserial);
+}
+
+#[test]
+fn roundtrip_pretty() {
+    let value = Struct {
+        tuple: ((), NewType(0.5), TupleStruct(UnitStruct, -5)),
+        vec: vec![None, Some(UnitStruct)],
+        map: vec![
+            (Key(5), Enum::Unit),
+            (Key(6), Enum::Bool(false)),
+            (Key(7), Enum::Bool(true)),
+            (Key(9), Enum::Chars('x', "".to_string())),
+        ]
+        .into_iter()
+        .collect(),
+    };
+
+    let pretty = ron::ser::PrettyConfig::new()
+        .enumerate_arrays(true)
+        .extensions(Extensions::IMPLICIT_SOME);
+    let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
+
+    println!("Serialized: {}", serial);
+
+    let deserial = ron::de::from_str(&serial);
+
+    assert_eq!(Ok(value), deserial);
+}
+
+#[test]
+fn roundtrip_sep_tuple_members() {
+    #[derive(Debug, Deserialize, PartialEq, Eq, Serialize)]
+    pub enum FileOrMem {
+        File(String),
+        Memory,
+    }
+
+    #[derive(Debug, Deserialize, PartialEq, Serialize)]
+    struct Both {
+        a: Struct,
+        b: FileOrMem,
+    }
+
+    let a = Struct {
+        tuple: ((), NewType(0.5), TupleStruct(UnitStruct, -5)),
+        vec: vec![None, Some(UnitStruct)],
+        map: vec![
+            (Key(5), Enum::Unit),
+            (Key(6), Enum::Bool(false)),
+            (Key(7), Enum::Bool(true)),
+            (Key(9), Enum::Chars('x', "".to_string())),
+        ]
+        .into_iter()
+        .collect(),
+    };
+    let b = FileOrMem::File("foo".to_owned());
+
+    let value = Both { a, b };
+
+    let pretty = ron::ser::PrettyConfig::new().separate_tuple_members(true);
+    let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
+
+    println!("Serialized: {}", serial);
+
+    let deserial = ron::de::from_str(&serial);
+
+    assert_eq!(Ok(value), deserial);
+}

vendor/ron/tests/struct_integers.rs

@@ -0,0 +1,39 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
+struct S {
+    a: i8,
+    b: i16,
+    c: i32,
+    d: i64,
+    #[cfg(feature = "integer128")]
+    e: i128,
+    f: u8,
+    g: u16,
+    h: u32,
+    i: u64,
+    #[cfg(feature = "integer128")]
+    j: u128,
+}
+
+#[test]
+fn roundtrip() {
+    let s = S {
+        a: std::i8::MIN,
+        b: std::i16::MIN,
+        c: std::i32::MIN,
+        d: std::i64::MIN,
+        #[cfg(feature = "integer128")]
+        e: std::i128::MIN,
+        f: std::u8::MAX,
+        g: std::u16::MAX,
+        h: std::u32::MAX,
+        i: std::u64::MAX,
+        #[cfg(feature = "integer128")]
+        j: std::u128::MAX,
+    };
+    let serialized = ron::ser::to_string(&s).unwrap();
+    dbg!(&serialized);
+    let deserialized = ron::de::from_str(&serialized).unwrap();
+    assert_eq!(s, deserialized,);
+}

vendor/ron/tests/to_string_pretty.rs

@@ -0,0 +1,23 @@
+use ron::{
+    ser::{to_string_pretty, PrettyConfig},
+    to_string,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct Point {
+    x: f64,
+    y: f64,
+}
+
+#[test]
+fn test_struct_names() {
+    let value = Point { x: 1.0, y: 2.0 };
+    let struct_name = to_string_pretty(&value, PrettyConfig::default().struct_names(true));
+    assert_eq!(
+        struct_name,
+        Ok("Point(\n    x: 1.0,\n    y: 2.0,\n)".to_string())
+    );
+    let no_struct_name = to_string(&value);
+    assert_eq!(no_struct_name, Ok("(x:1.0,y:2.0)".to_string()));
+}

vendor/ron/tests/unicode.rs

@@ -0,0 +1,13 @@
+use ron::de::from_str;
+
+#[test]
+fn test_char() {
+    let de: char = from_str("'Փ'").unwrap();
+    assert_eq!(de, 'Փ');
+}
+
+#[test]
+fn test_string() {
+    let de: String = from_str("\"My string: ऄ\"").unwrap();
+    assert_eq!(de, "My string: ऄ");
+}

vendor/ron/tests/value.rs

@@ -0,0 +1,163 @@
+use std::f64;
+
+use ron::{
+    error::Error,
+    value::{Map, Number, Value},
+};
+use serde::Serialize;
+
+#[test]
+fn bool() {
+    assert_eq!("true".parse(), Ok(Value::Bool(true)));
+    assert_eq!("false".parse(), Ok(Value::Bool(false)));
+}
+
+#[test]
+fn char() {
+    assert_eq!("'a'".parse(), Ok(Value::Char('a')));
+}
+
+#[test]
+fn map() {
+    let mut map = Map::new();
+    map.insert(Value::Char('a'), Value::Number(Number::new(1)));
+    map.insert(Value::Char('b'), Value::Number(Number::new(2f64)));
+    assert_eq!("{ 'a': 1, 'b': 2.0 }".parse(), Ok(Value::Map(map)));
+}
+
+#[test]
+fn number() {
+    assert_eq!("42".parse(), Ok(Value::Number(Number::new(42))));
+    assert_eq!(
+        "3.141592653589793".parse(),
+        Ok(Value::Number(Number::new(f64::consts::PI)))
+    );
+}
+
+#[test]
+fn option() {
+    let opt = Some(Box::new(Value::Char('c')));
+    assert_eq!("Some('c')".parse(), Ok(Value::Option(opt)));
+}
+
+#[test]
+fn string() {
+    let normal = "\"String\"";
+    assert_eq!(normal.parse(), Ok(Value::String("String".into())));
+
+    let raw = "r\"Raw String\"";
+    assert_eq!(raw.parse(), Ok(Value::String("Raw String".into())));
+
+    let raw_hashes = "r#\"Raw String\"#";
+    assert_eq!(raw_hashes.parse(), Ok(Value::String("Raw String".into())));
+
+    let raw_escaped = "r##\"Contains \"#\"##";
+    assert_eq!(
+        raw_escaped.parse(),
+        Ok(Value::String("Contains \"#".into()))
+    );
+
+    let raw_multi_line = "r\"Multi\nLine\"";
+    assert_eq!(
+        raw_multi_line.parse(),
+        Ok(Value::String("Multi\nLine".into()))
+    );
+}
+
+#[test]
+fn seq() {
+    let seq = vec![
+        Value::Number(Number::new(1)),
+        Value::Number(Number::new(2f64)),
+    ];
+    assert_eq!("[1, 2.0]".parse(), Ok(Value::Seq(seq)));
+
+    let err = Value::Seq(vec![Value::Number(Number::new(1))])
+        .into_rust::<[i32; 2]>()
+        .unwrap_err();
+
+    assert_eq!(
+        err,
+        Error::ExpectedDifferentLength {
+            expected: String::from("an array of length 2"),
+            found: 1,
+        }
+    );
+
+    let err = Value::Seq(vec![
+        Value::Number(Number::new(1)),
+        Value::Number(Number::new(2)),
+        Value::Number(Number::new(3)),
+    ])
+    .into_rust::<[i32; 2]>()
+    .unwrap_err();
+
+    assert_eq!(
+        err,
+        Error::ExpectedDifferentLength {
+            expected: String::from("a sequence of length 2"),
+            found: 3,
+        }
+    );
+}
+
+#[test]
+fn unit() {
+    use ron::error::{Error, Position, SpannedError};
+
+    assert_eq!("()".parse(), Ok(Value::Unit));
+    assert_eq!("Foo".parse(), Ok(Value::Unit));
+
+    assert_eq!(
+        "".parse::<Value>(),
+        Err(SpannedError {
+            code: Error::Eof,
+            position: Position { col: 1, line: 1 }
+        })
+    );
+}
+
+#[derive(Serialize)]
+struct Scene(Option<(u32, u32)>);
+
+#[derive(Serialize)]
+struct Scene2 {
+    foo: Option<(u32, u32)>,
+}
+
+#[test]
+fn roundtrip() {
+    use ron::{de::from_str, ser::to_string};
+
+    {
+        let s = to_string(&Scene2 {
+            foo: Some((122, 13)),
+        })
+        .unwrap();
+        println!("{}", s);
+        let scene: Value = from_str(&s).unwrap();
+        println!("{:?}", scene);
+    }
+    {
+        let s = to_string(&Scene(Some((13, 122)))).unwrap();
+        println!("{}", s);
+        let scene: Value = from_str(&s).unwrap();
+        println!("{:?}", scene);
+    }
+}
+
+#[test]
+fn map_roundtrip_338() {
+    // https://github.com/ron-rs/ron/issues/338
+
+    let v: Value = ron::from_str("{}").unwrap();
+    println!("{:?}", v);
+
+    let ser = ron::to_string(&v).unwrap();
+    println!("{:?}", ser);
+
+    let roundtrip = ron::from_str(&ser).unwrap();
+    println!("{:?}", roundtrip);
+
+    assert_eq!(v, roundtrip);
+}