]>
git.proxmox.com Git - rustc.git/blob - vendor/toml-0.7.5/tests/testsuite/enum_external_deserialize.rs
1 use serde
::Deserialize
;
3 #[derive(Debug, Deserialize, PartialEq)]
8 #[derive(Debug, Deserialize, PartialEq)]
13 Struct { value: i64 }
,
16 #[derive(Debug, Deserialize, PartialEq)]
21 #[derive(Debug, Deserialize, PartialEq)]
26 fn value_from_str
<T
>(s
: &'_
str) -> Result
<T
, toml
::de
::Error
>
28 T
: serde
::de
::DeserializeOwned
,
30 T
::deserialize(toml
::de
::ValueDeserializer
::new(s
))
34 fn invalid_variant_returns_error_with_good_message_string() {
35 let error
= value_from_str
::<TheEnum
>("\"NonExistent\"").unwrap_err();
37 r
#"unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct`
42 let error
= toml
::from_str
::<Val
>("val = \"NonExistent\"").unwrap_err();
44 r
#"TOML parse error at line 1, column 7
46 1 | val = "NonExistent"
48 unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct`
55 fn invalid_variant_returns_error_with_good_message_inline_table() {
56 let error
= value_from_str
::<TheEnum
>("{ NonExistent = {} }").unwrap_err();
58 r
#"unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct`
63 let error
= toml
::from_str
::<Val
>("val = { NonExistent = {} }").unwrap_err();
65 r
#"TOML parse error at line 1, column 9
67 1 | val = { NonExistent = {} }
69 unknown variant `NonExistent`, expected one of `Plain`, `Tuple`, `NewType`, `Struct`
76 fn extra_field_returns_expected_empty_table_error() {
77 let error
= value_from_str
::<TheEnum
>("{ Plain = { extra_field = 404 } }").unwrap_err();
79 r
#"expected empty table
84 let error
= toml
::from_str
::<Val
>("val = { Plain = { extra_field = 404 } }").unwrap_err();
86 r
#"TOML parse error at line 1, column 17
88 1 | val = { Plain = { extra_field = 404 } }
89 | ^^^^^^^^^^^^^^^^^^^^^
97 fn extra_field_returns_expected_empty_table_error_struct_variant() {
98 let error
= value_from_str
::<TheEnum
>("{ Struct = { value = 123, extra_0 = 0, extra_1 = 1 } }")
102 r
#"unexpected keys in table: extra_0, extra_1, available keys: value
108 toml
::from_str
::<Val
>("val = { Struct = { value = 123, extra_0 = 0, extra_1 = 1 } }")
112 r
#"TOML parse error at line 1, column 33
114 1 | val = { Struct = { value = 123, extra_0 = 0, extra_1 = 1 } }
116 unexpected keys in table: extra_0, extra_1, available keys: value
127 assert_eq
!(TheEnum
::Plain
, value_from_str("\"Plain\"").unwrap());
133 toml
::from_str("val = \"Plain\"").unwrap()
138 fn from_inline_table() {
139 assert_eq
!(TheEnum
::Plain
, value_from_str("{ Plain = {} }").unwrap());
144 toml
::from_str("val = { Plain = {} }").unwrap()
149 fn from_std_table() {
150 assert_eq
!(TheEnum
::Plain
, toml
::from_str("[Plain]\n").unwrap());
158 fn from_inline_table() {
160 TheEnum
::Tuple(-123, true),
161 value_from_str("{ Tuple = { 0 = -123, 1 = true } }").unwrap()
165 val
: TheEnum
::Tuple(-123, true)
167 toml
::from_str("val = { Tuple = { 0 = -123, 1 = true } }").unwrap()
172 fn from_std_table() {
174 TheEnum
::Tuple(-123, true),
190 fn from_inline_table() {
192 TheEnum
::NewType("value".to_string()),
193 value_from_str(r
#"{ NewType = "value" }"#).unwrap()
197 val
: TheEnum
::NewType("value".to_string()),
199 toml
::from_str(r
#"val = { NewType = "value" }"#).unwrap()
204 fn from_std_table() {
206 TheEnum
::NewType("value".to_string()),
207 toml
::from_str(r
#"NewType = "value""#).unwrap()
211 val
: TheEnum
::NewType("value".to_string()),
227 fn from_inline_table() {
229 TheEnum
::Struct { value: -123 }
,
230 value_from_str("{ Struct = { value = -123 } }").unwrap()
234 val
: TheEnum
::Struct { value: -123 }
236 toml
::from_str("val = { Struct = { value = -123 } }").unwrap()
241 fn from_std_table() {
243 TheEnum
::Struct { value: -123 }
,
254 fn from_nested_std_table() {
257 inner
: TheEnum
::Struct { value: -123 }
273 fn from_inline_tables() {
277 { Tuple = { 0 = -123, 1 = true } },
278 { NewType = "value" },
279 { Struct = { value = -123 } }
285 TheEnum
::Tuple(-123, true),
286 TheEnum
::NewType("value".to_string()),
287 TheEnum
::Struct { value: -123 }
,
290 toml
::from_str(toml_str
).unwrap()
295 fn from_std_table() {
296 let toml_str
= r
#"[[enums]]
300 Tuple = { 0 = -123, 1 = true }
306 Struct = { value = -123 }
312 TheEnum
::Tuple(-123, true),
313 TheEnum
::NewType("value".to_string()),
314 TheEnum
::Struct { value: -123 }
,
317 toml
::from_str(toml_str
).unwrap()