| use serde::Deserialize; |
| |
| #[derive(Debug, Deserialize, PartialEq)] |
| struct OuterStruct { |
| inner: TheEnum, |
| } |
| |
| #[derive(Debug, Deserialize, PartialEq)] |
| enum TheEnum { |
| Plain, |
| Tuple(i64, bool), |
| NewType(String), |
| Struct { value: i64 }, |
| } |
| |
| #[derive(Debug, Deserialize, PartialEq)] |
| struct Val { |
| val: TheEnum, |
| } |
| |
| #[derive(Debug, Deserialize, PartialEq)] |
| struct Multi { |
| enums: Vec<TheEnum>, |
| } |
| |
| fn value_from_str<T>(s: &'_ str) -> Result<T, toml::de::Error> |
| where |
| T: serde::de::DeserializeOwned, |
| { |
| T::deserialize(toml::de::ValueDeserializer::new(s)) |
| } |
| |
| #[test] |
| fn invalid_variant_returns_error_with_good_message_string() { |
| let error = value_from_str::<TheEnum>("\"NonExistent\"").unwrap_err(); |
| snapbox::assert_eq( |
| r#"unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct` |
| "#, |
| error.to_string(), |
| ); |
| |
| let error = toml::from_str::<Val>("val = \"NonExistent\"").unwrap_err(); |
| snapbox::assert_eq( |
| r#"TOML parse error at line 1, column 7 |
| | |
| 1 | val = "NonExistent" |
| | ^^^^^^^^^^^^^ |
| unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct` |
| "#, |
| error.to_string(), |
| ); |
| } |
| |
| #[test] |
| fn invalid_variant_returns_error_with_good_message_inline_table() { |
| let error = value_from_str::<TheEnum>("{ NonExistent = {} }").unwrap_err(); |
| snapbox::assert_eq( |
| r#"unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct` |
| "#, |
| error.to_string(), |
| ); |
| |
| let error = toml::from_str::<Val>("val = { NonExistent = {} }").unwrap_err(); |
| snapbox::assert_eq( |
| r#"TOML parse error at line 1, column 9 |
| | |
| 1 | val = { NonExistent = {} } |
| | ^^^^^^^^^^^ |
| unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct` |
| "#, |
| error.to_string(), |
| ); |
| } |
| |
| #[test] |
| fn extra_field_returns_expected_empty_table_error() { |
| let error = value_from_str::<TheEnum>("{ Plain = { extra_field = 404 } }").unwrap_err(); |
| snapbox::assert_eq( |
| r#"expected empty table |
| "#, |
| error.to_string(), |
| ); |
| |
| let error = toml::from_str::<Val>("val = { Plain = { extra_field = 404 } }").unwrap_err(); |
| snapbox::assert_eq( |
| r#"TOML parse error at line 1, column 17 |
| | |
| 1 | val = { Plain = { extra_field = 404 } } |
| | ^^^^^^^^^^^^^^^^^^^^^ |
| expected empty table |
| "#, |
| error.to_string(), |
| ); |
| } |
| |
| #[test] |
| fn extra_field_returns_expected_empty_table_error_struct_variant() { |
| let error = value_from_str::<TheEnum>("{ Struct = { value = 123, extra_0 = 0, extra_1 = 1 } }") |
| .unwrap_err(); |
| |
| snapbox::assert_eq( |
| r#"unexpected keys in table: extra_0, extra_1, available keys: value |
| "#, |
| error.to_string(), |
| ); |
| |
| let error = |
| toml::from_str::<Val>("val = { Struct = { value = 123, extra_0 = 0, extra_1 = 1 } }") |
| .unwrap_err(); |
| |
| snapbox::assert_eq( |
| r#"TOML parse error at line 1, column 33 |
| | |
| 1 | val = { Struct = { value = 123, extra_0 = 0, extra_1 = 1 } } |
| | ^^^^^^^ |
| unexpected keys in table: extra_0, extra_1, available keys: value |
| "#, |
| error.to_string(), |
| ); |
| } |
| |
| mod enum_unit { |
| use super::*; |
| |
| #[test] |
| fn from_str() { |
| assert_eq!(TheEnum::Plain, value_from_str("\"Plain\"").unwrap()); |
| |
| assert_eq!( |
| Val { |
| val: TheEnum::Plain |
| }, |
| toml::from_str("val = \"Plain\"").unwrap() |
| ); |
| } |
| |
| #[test] |
| fn from_inline_table() { |
| assert_eq!(TheEnum::Plain, value_from_str("{ Plain = {} }").unwrap()); |
| assert_eq!( |
| Val { |
| val: TheEnum::Plain |
| }, |
| toml::from_str("val = { Plain = {} }").unwrap() |
| ); |
| } |
| |
| #[test] |
| fn from_std_table() { |
| assert_eq!(TheEnum::Plain, toml::from_str("[Plain]\n").unwrap()); |
| } |
| } |
| |
| mod enum_tuple { |
| use super::*; |
| |
| #[test] |
| fn from_inline_table() { |
| assert_eq!( |
| TheEnum::Tuple(-123, true), |
| value_from_str("{ Tuple = { 0 = -123, 1 = true } }").unwrap() |
| ); |
| assert_eq!( |
| Val { |
| val: TheEnum::Tuple(-123, true) |
| }, |
| toml::from_str("val = { Tuple = { 0 = -123, 1 = true } }").unwrap() |
| ); |
| } |
| |
| #[test] |
| fn from_std_table() { |
| assert_eq!( |
| TheEnum::Tuple(-123, true), |
| toml::from_str( |
| r#"[Tuple] |
| 0 = -123 |
| 1 = true |
| "# |
| ) |
| .unwrap() |
| ); |
| } |
| } |
| |
| mod enum_newtype { |
| use super::*; |
| |
| #[test] |
| fn from_inline_table() { |
| assert_eq!( |
| TheEnum::NewType("value".to_string()), |
| value_from_str(r#"{ NewType = "value" }"#).unwrap() |
| ); |
| assert_eq!( |
| Val { |
| val: TheEnum::NewType("value".to_string()), |
| }, |
| toml::from_str(r#"val = { NewType = "value" }"#).unwrap() |
| ); |
| } |
| |
| #[test] |
| fn from_std_table() { |
| assert_eq!( |
| TheEnum::NewType("value".to_string()), |
| toml::from_str(r#"NewType = "value""#).unwrap() |
| ); |
| assert_eq!( |
| Val { |
| val: TheEnum::NewType("value".to_string()), |
| }, |
| toml::from_str( |
| r#"[val] |
| NewType = "value" |
| "# |
| ) |
| .unwrap() |
| ); |
| } |
| } |
| |
| mod enum_struct { |
| use super::*; |
| |
| #[test] |
| fn from_inline_table() { |
| assert_eq!( |
| TheEnum::Struct { value: -123 }, |
| value_from_str("{ Struct = { value = -123 } }").unwrap() |
| ); |
| assert_eq!( |
| Val { |
| val: TheEnum::Struct { value: -123 } |
| }, |
| toml::from_str("val = { Struct = { value = -123 } }").unwrap() |
| ); |
| } |
| |
| #[test] |
| fn from_std_table() { |
| assert_eq!( |
| TheEnum::Struct { value: -123 }, |
| toml::from_str( |
| r#"[Struct] |
| value = -123 |
| "# |
| ) |
| .unwrap() |
| ); |
| } |
| |
| #[test] |
| fn from_nested_std_table() { |
| assert_eq!( |
| OuterStruct { |
| inner: TheEnum::Struct { value: -123 } |
| }, |
| toml::from_str( |
| r#"[inner.Struct] |
| value = -123 |
| "# |
| ) |
| .unwrap() |
| ); |
| } |
| } |
| |
| mod enum_array { |
| use super::*; |
| |
| #[test] |
| fn from_inline_tables() { |
| let toml_str = r#" |
| enums = [ |
| { Plain = {} }, |
| { Tuple = { 0 = -123, 1 = true } }, |
| { NewType = "value" }, |
| { Struct = { value = -123 } } |
| ]"#; |
| assert_eq!( |
| Multi { |
| enums: vec![ |
| TheEnum::Plain, |
| TheEnum::Tuple(-123, true), |
| TheEnum::NewType("value".to_string()), |
| TheEnum::Struct { value: -123 }, |
| ] |
| }, |
| toml::from_str(toml_str).unwrap() |
| ); |
| } |
| |
| #[test] |
| fn from_std_table() { |
| let toml_str = r#"[[enums]] |
| Plain = {} |
| |
| [[enums]] |
| Tuple = { 0 = -123, 1 = true } |
| |
| [[enums]] |
| NewType = "value" |
| |
| [[enums]] |
| Struct = { value = -123 } |
| "#; |
| assert_eq!( |
| Multi { |
| enums: vec![ |
| TheEnum::Plain, |
| TheEnum::Tuple(-123, true), |
| TheEnum::NewType("value".to_string()), |
| TheEnum::Struct { value: -123 }, |
| ] |
| }, |
| toml::from_str(toml_str).unwrap() |
| ); |
| } |
| } |