Errors

testing/tests/test_annotations.rs

@@ -343,7 +343,7 @@ fn test_ignore_unknown() {
             Token::StructSep,
             Token::Str("whoops"),
         ],
-        Error::UnknownField("whoops".to_owned())
+        Error::Message("unknown field `whoops`, expected `a1`".to_owned())
     );
 }
 
@@ -905,7 +905,7 @@ fn test_missing_renamed_field_struct() {
 
             Token::StructEnd,
         ],
-        Error::MissingField("a3"),
+        Error::Message("missing field `a3`".to_owned()),
     );
 
     assert_de_tokens_error::<RenameStructSerializeDeserialize>(
@@ -918,7 +918,7 @@ fn test_missing_renamed_field_struct() {
 
             Token::StructEnd,
         ],
-        Error::MissingField("a5"),
+        Error::Message("missing field `a5`".to_owned()),
     );
 }
 
@@ -930,7 +930,7 @@ fn test_missing_renamed_field_enum() {
 
             Token::EnumMapEnd,
         ],
-        Error::MissingField("b"),
+        Error::Message("missing field `b`".to_owned()),
     );
 
     assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
@@ -943,7 +943,7 @@ fn test_missing_renamed_field_enum() {
 
             Token::EnumMapEnd,
         ],
-        Error::MissingField("d"),
+        Error::Message("missing field `d`".to_owned()),
     );
 }
 
@@ -962,7 +962,7 @@ fn test_invalid_length_enum() {
                 Token::I32(1),
             Token::EnumSeqEnd,
         ],
-        Error::InvalidLength(1),
+        Error::Message("invalid length 1, expected tuple of 3 elements".to_owned()),
     );
     assert_de_tokens_error::<InvalidLengthEnum>(
         &[
@@ -971,6 +971,6 @@ fn test_invalid_length_enum() {
                 Token::I32(1),
             Token::EnumSeqEnd,
         ],
-        Error::InvalidLength(1),
+        Error::Message("invalid length 1, expected tuple of 2 elements".to_owned()),
     );
 }

testing/tests/test_de.rs

@@ -3,7 +3,7 @@ use std::net;
 use std::path::PathBuf;
 use std::time::Duration;
 
-use serde::de::{Deserialize, Type};
+use serde::Deserialize;
 
 extern crate fnv;
 use self::fnv::FnvHasher;
@@ -849,7 +849,7 @@ declare_error_tests! {
                 Token::StructSep,
                 Token::Str("d"),
         ],
-        Error::UnknownField("d".to_owned()),
+        Error::Message("unknown field `d`, expected `a` or `b`".to_owned()),
     }
     test_skipped_field_is_unknown<StructDenyUnknown> {
         &[
@@ -857,7 +857,7 @@ declare_error_tests! {
                 Token::StructSep,
                 Token::Str("b"),
         ],
-        Error::UnknownField("b".to_owned()),
+        Error::Message("unknown field `b`, expected `a` or `b`".to_owned()),
     }
     test_skip_all_deny_unknown<StructSkipAllDenyUnknown> {
         &[
@@ -865,25 +865,25 @@ declare_error_tests! {
                 Token::StructSep,
                 Token::Str("a"),
         ],
-        Error::UnknownField("a".to_owned()),
+        Error::Message("unknown field `a`, expected `a`".to_owned()),
     }
     test_unknown_variant<Enum> {
         &[
             Token::EnumUnit("Enum", "Foo"),
         ],
-        Error::UnknownVariant("Foo".to_owned()),
+        Error::Message("unknown variant `Foo`, expected one of `Skipped`, `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
     }
     test_enum_skipped_variant<Enum> {
         &[
             Token::EnumUnit("Enum", "Skipped"),
         ],
-        Error::UnknownVariant("Skipped".to_owned()),
+        Error::Message("unknown variant `Skipped`, expected one of `Skipped`, `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
     }
     test_enum_skip_all<EnumSkipAll> {
         &[
             Token::EnumUnit("EnumSkipAll", "Skipped"),
         ],
-        Error::UnknownVariant("Skipped".to_owned()),
+        Error::Message("unknown variant `Skipped`, expected `Skipped`".to_owned()),
     }
     test_struct_seq_too_long<Struct> {
         &[
@@ -904,7 +904,7 @@ declare_error_tests! {
                 Token::MapSep,
                 Token::Str("a"),
         ],
-        Error::DuplicateField("a"),
+        Error::Message("duplicate field `a`".to_owned()),
     }
     test_duplicate_field_enum<Enum> {
         &[
@@ -916,7 +916,7 @@ declare_error_tests! {
                 Token::EnumMapSep,
                 Token::Str("a"),
         ],
-        Error::DuplicateField("a"),
+        Error::Message("duplicate field `a`".to_owned()),
     }
     test_enum_unit_usize<Enum> {
         &[
@@ -924,7 +924,7 @@ declare_error_tests! {
             Token::Usize(0),
             Token::Unit,
         ],
-        Error::InvalidType(Type::U64),
+        Error::Message("invalid type: integer `0`, expected field name".into()),
     }
     test_enum_unit_bytes<Enum> {
         &[
@@ -932,6 +932,6 @@ declare_error_tests! {
             Token::Bytes(b"Unit"),
             Token::Unit,
         ],
-        Error::InvalidType(Type::Bytes),
+        Error::Message("invalid type: byte array, expected field name".into()),
     }
 }

testing/tests/test_ser.rs

@@ -432,7 +432,7 @@ fn test_cannot_serialize_paths() {
     assert_ser_tokens_error(
         &Path::new(path),
         &[],
-        Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
+        Error::Message("Path contains invalid UTF-8 characters".to_owned()));
 
     let mut path_buf = PathBuf::new();
     path_buf.push(path);
@@ -440,7 +440,7 @@ fn test_cannot_serialize_paths() {
     assert_ser_tokens_error(
         &path_buf,
         &[],
-        Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
+        Error::Message("Path contains invalid UTF-8 characters".to_owned()));
 }
 
 #[test]
@@ -448,17 +448,17 @@ fn test_enum_skipped() {
     assert_ser_tokens_error(
         &Enum::SkippedUnit,
         &[],
-        Error::InvalidValue("The enum variant Enum::SkippedUnit cannot be serialized".to_owned()));
+        Error::Message("the enum variant Enum::SkippedUnit cannot be serialized".to_owned()));
     assert_ser_tokens_error(
         &Enum::SkippedOne(42),
         &[],
-        Error::InvalidValue("The enum variant Enum::SkippedOne cannot be serialized".to_owned()));
+        Error::Message("the enum variant Enum::SkippedOne cannot be serialized".to_owned()));
     assert_ser_tokens_error(
         &Enum::SkippedSeq(1, 2),
         &[],
-        Error::InvalidValue("The enum variant Enum::SkippedSeq cannot be serialized".to_owned()));
+        Error::Message("the enum variant Enum::SkippedSeq cannot be serialized".to_owned()));
     assert_ser_tokens_error(
         &Enum::SkippedMap { _a: 1, _b: 2 },
         &[],
-        Error::InvalidValue("The enum variant Enum::SkippedMap cannot be serialized".to_owned()));
+        Error::Message("the enum variant Enum::SkippedMap cannot be serialized".to_owned()));
 }