Remove error from serde_test public API

test_suite/tests/test_annotations.rs

@@ -13,7 +13,7 @@ extern crate serde;
 use self::serde::{Serialize, Serializer, Deserialize, Deserializer};
 
 extern crate serde_test;
-use self::serde_test::{Error, Token, assert_tokens, assert_ser_tokens, assert_de_tokens,
+use self::serde_test::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens,
                        assert_de_tokens_error};
 
 trait MyDefault: Sized {
@@ -363,7 +363,7 @@ fn test_ignore_unknown() {
 
             Token::Str("whoops"),
         ],
-        Error::Message("unknown field `whoops`, expected `a1`".to_owned()),
+        "unknown field `whoops`, expected `a1`",
     );
 }
 
@@ -875,7 +875,7 @@ fn test_missing_renamed_field_struct() {
 
             Token::StructEnd,
         ],
-        Error::Message("missing field `a3`".to_owned()),
+        "missing field `a3`",
     );
 
     assert_de_tokens_error::<RenameStructSerializeDeserialize>(
@@ -887,7 +887,7 @@ fn test_missing_renamed_field_struct() {
 
             Token::StructEnd,
         ],
-        Error::Message("missing field `a5`".to_owned()),
+        "missing field `a5`",
     );
 }
 
@@ -899,7 +899,7 @@ fn test_missing_renamed_field_enum() {
 
             Token::StructVariantEnd,
         ],
-        Error::Message("missing field `b`".to_owned()),
+        "missing field `b`",
     );
 
     assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
@@ -911,7 +911,7 @@ fn test_missing_renamed_field_enum() {
 
             Token::StructVariantEnd,
         ],
-        Error::Message("missing field `d`".to_owned()),
+        "missing field `d`",
     );
 }
 
@@ -934,7 +934,7 @@ fn test_invalid_length_enum() {
             Token::I32(1),
             Token::TupleVariantEnd,
         ],
-        Error::Message("invalid length 1, expected tuple of 3 elements".to_owned()),
+        "invalid length 1, expected tuple of 3 elements",
     );
     assert_de_tokens_error::<InvalidLengthEnum>(
         &[
@@ -942,7 +942,7 @@ fn test_invalid_length_enum() {
             Token::I32(1),
             Token::TupleVariantEnd,
         ],
-        Error::Message("invalid length 1, expected tuple of 2 elements".to_owned()),
+        "invalid length 1, expected tuple of 2 elements",
     );
 }
 

test_suite/tests/test_borrow.rs

@@ -13,7 +13,7 @@ extern crate serde;
 use serde::{Deserialize, Deserializer};
 
 extern crate serde_test;
-use serde_test::{Error, Token, assert_de_tokens, assert_de_tokens_error};
+use serde_test::{Token, assert_de_tokens, assert_de_tokens_error};
 
 use std::borrow::Cow;
 
@@ -26,7 +26,7 @@ fn test_borrowed_str() {
 fn test_borrowed_str_from_string() {
     assert_de_tokens_error::<&str>(
         &[Token::String("borrowed")],
-        Error::Message("invalid type: string \"borrowed\", expected a borrowed string".to_owned(),),
+        "invalid type: string \"borrowed\", expected a borrowed string",
     );
 }
 
@@ -34,7 +34,7 @@ fn test_borrowed_str_from_string() {
 fn test_borrowed_str_from_str() {
     assert_de_tokens_error::<&str>(
         &[Token::Str("borrowed")],
-        Error::Message("invalid type: string \"borrowed\", expected a borrowed string".to_owned(),),
+        "invalid type: string \"borrowed\", expected a borrowed string",
     );
 }
 
@@ -52,7 +52,7 @@ fn test_borrowed_bytes() {
 fn test_borrowed_bytes_from_bytebuf() {
     assert_de_tokens_error::<&[u8]>(
         &[Token::ByteBuf(b"borrowed")],
-        Error::Message("invalid type: byte array, expected a borrowed byte array".to_owned(),),
+        "invalid type: byte array, expected a borrowed byte array",
     );
 }
 
@@ -60,7 +60,7 @@ fn test_borrowed_bytes_from_bytebuf() {
 fn test_borrowed_bytes_from_bytes() {
     assert_de_tokens_error::<&[u8]>(
         &[Token::Bytes(b"borrowed")],
-        Error::Message("invalid type: byte array, expected a borrowed byte array".to_owned(),),
+        "invalid type: byte array, expected a borrowed byte array",
     );
 }
 
@@ -128,7 +128,6 @@ fn test_cow() {
 
     let mut de = serde_test::Deserializer::new(tokens);
     let cows = Cows::deserialize(&mut de).unwrap();
-    assert_eq!(de.next_token(), None);
 
     match cows.copied {
         Cow::Owned(ref s) if s == "copied" => {}

test_suite/tests/test_de.rs

@@ -28,7 +28,7 @@ extern crate fnv;
 use self::fnv::FnvHasher;
 
 extern crate serde_test;
-use self::serde_test::{Error, Token, assert_de_tokens, assert_de_tokens_error};
+use self::serde_test::{Token, assert_de_tokens, assert_de_tokens_error};
 
 #[macro_use]
 mod macros;
@@ -149,8 +149,6 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token]) {
         a: i32,
     }
 
-    let expected = IgnoreBase { a: 1 };
-
     // Embed the tokens to be ignored in the normal token
     // stream for an IgnoreBase type
     let concated_tokens: Vec<Token> = vec![
@@ -166,10 +164,8 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token]) {
             .collect();
 
     let mut de = serde_test::Deserializer::new(&concated_tokens);
-    let v: Result<IgnoreBase, Error> = Deserialize::deserialize(&mut de);
-
-    assert_eq!(v.as_ref(), Ok(&expected));
-    assert_eq!(de.next_token(), None);
+    let base = IgnoreBase::deserialize(&mut de).unwrap();
+    assert_eq!(base, IgnoreBase { a: 1 });
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -789,7 +785,7 @@ fn test_net_ipaddr() {
 fn test_cstr_internal_null() {
     assert_de_tokens_error::<Box<CStr>>(
         &[Token::Bytes(b"a\0c")],
-        Error::Message("nul byte found in provided data at position: 1".into()),
+        "nul byte found in provided data at position: 1",
     );
 }
 
@@ -798,7 +794,7 @@ fn test_cstr_internal_null() {
 fn test_cstr_internal_null_end() {
     assert_de_tokens_error::<Box<CStr>>(
         &[Token::Bytes(b"ac\0")],
-        Error::Message("nul byte found in provided data at position: 2".into()),
+        "nul byte found in provided data at position: 2",
     );
 }
 
@@ -811,48 +807,39 @@ declare_error_tests! {
 
                 Token::Str("d"),
         ],
-        Error::Message("unknown field `d`, expected `a`".to_owned()),
+        "unknown field `d`, expected `a`",
     }
     test_skipped_field_is_unknown<StructDenyUnknown> {
         &[
             Token::Struct("StructDenyUnknown", 2),
                 Token::Str("b"),
         ],
-        Error::Message("unknown field `b`, expected `a`".to_owned()),
+        "unknown field `b`, expected `a`",
     }
     test_skip_all_deny_unknown<StructSkipAllDenyUnknown> {
         &[
             Token::Struct("StructSkipAllDenyUnknown", 1),
                 Token::Str("a"),
         ],
-        Error::Message("unknown field `a`, there are no fields".to_owned()),
+        "unknown field `a`, there are no fields",
     }
     test_unknown_variant<Enum> {
         &[
             Token::UnitVariant("Enum", "Foo"),
         ],
-        Error::Message("unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
+        "unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`",
     }
     test_enum_skipped_variant<Enum> {
         &[
             Token::UnitVariant("Enum", "Skipped"),
         ],
-        Error::Message("unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
+        "unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`",
     }
     test_enum_skip_all<EnumSkipAll> {
         &[
             Token::UnitVariant("EnumSkipAll", "Skipped"),
         ],
-        Error::Message("unknown variant `Skipped`, there are no variants".to_owned()),
-    }
-    test_struct_seq_too_long<Struct> {
-        &[
-            Token::Seq(Some(4)),
-                Token::I32(1),
-                Token::I32(2),
-                Token::I32(3),
-        ],
-        Error::UnexpectedToken(Token::I32(3)),
+        "unknown variant `Skipped`, there are no variants",
     }
     test_duplicate_field_struct<Struct> {
         &[
@@ -862,7 +849,7 @@ declare_error_tests! {
 
                 Token::Str("a"),
         ],
-        Error::Message("duplicate field `a`".to_owned()),
+        "duplicate field `a`",
     }
     test_duplicate_field_enum<Enum> {
         &[
@@ -872,7 +859,7 @@ declare_error_tests! {
 
                 Token::Str("a"),
         ],
-        Error::Message("duplicate field `a`".to_owned()),
+        "duplicate field `a`",
     }
     test_enum_out_of_range<Enum> {
         &[
@@ -880,7 +867,7 @@ declare_error_tests! {
             Token::U32(4),
             Token::Unit,
         ],
-        Error::Message("invalid value: integer `4`, expected variant index 0 <= i < 4".into()),
+        "invalid value: integer `4`, expected variant index 0 <= i < 4",
     }
     test_short_tuple<(u8, u8, u8)> {
         &[
@@ -888,7 +875,7 @@ declare_error_tests! {
             Token::U8(1),
             Token::TupleEnd,
         ],
-        Error::Message("invalid length 1, expected a tuple of size 3".into()),
+        "invalid length 1, expected a tuple of size 3",
     }
     test_short_array<[u8; 3]> {
         &[
@@ -896,142 +883,142 @@ declare_error_tests! {
             Token::U8(1),
             Token::SeqEnd,
         ],
-        Error::Message("invalid length 1, expected an array of length 3".into()),
+        "invalid length 1, expected an array of length 3",
     }
     test_cstring_internal_null<CString> {
         &[
             Token::Bytes(b"a\0c"),
         ],
-        Error::Message("nul byte found in provided data at position: 1".into()),
+        "nul byte found in provided data at position: 1",
     }
     test_cstring_internal_null_end<CString> {
         &[
             Token::Bytes(b"ac\0"),
         ],
-        Error::Message("nul byte found in provided data at position: 2".into()),
+        "nul byte found in provided data at position: 2",
     }
     test_unit_from_empty_seq<()> {
         &[
             Token::Seq(Some(0)),
             Token::SeqEnd,
         ],
-        Error::Message("invalid type: sequence, expected unit".into()),
+        "invalid type: sequence, expected unit",
     }
     test_unit_from_empty_seq_without_len<()> {
         &[
             Token::Seq(None),
             Token::SeqEnd,
         ],
-        Error::Message("invalid type: sequence, expected unit".into()),
+        "invalid type: sequence, expected unit",
     }
     test_unit_from_tuple_struct<()> {
         &[
             Token::TupleStruct("Anything", 0),
             Token::TupleStructEnd,
         ],
-        Error::Message("invalid type: sequence, expected unit".into()),
+        "invalid type: sequence, expected unit",
     }
     test_string_from_unit<String> {
         &[
             Token::Unit,
         ],
-        Error::Message("invalid type: unit value, expected a string".into()),
+        "invalid type: unit value, expected a string",
     }
     test_btreeset_from_unit<BTreeSet<isize>> {
         &[
             Token::Unit,
         ],
-        Error::Message("invalid type: unit value, expected a sequence".into()),
+        "invalid type: unit value, expected a sequence",
     }
     test_btreeset_from_unit_struct<BTreeSet<isize>> {
         &[
             Token::UnitStruct("Anything"),
         ],
-        Error::Message("invalid type: unit value, expected a sequence".into()),
+        "invalid type: unit value, expected a sequence",
     }
     test_hashset_from_unit<HashSet<isize>> {
         &[
             Token::Unit,
         ],
-        Error::Message("invalid type: unit value, expected a sequence".into()),
+        "invalid type: unit value, expected a sequence",
     }
     test_hashset_from_unit_struct<HashSet<isize>> {
         &[
             Token::UnitStruct("Anything"),
         ],
-        Error::Message("invalid type: unit value, expected a sequence".into()),
+        "invalid type: unit value, expected a sequence",
     }
     test_vec_from_unit<Vec<isize>> {
         &[
             Token::Unit,
         ],
-        Error::Message("invalid type: unit value, expected a sequence".into()),
+        "invalid type: unit value, expected a sequence",
     }
     test_vec_from_unit_struct<Vec<isize>> {
         &[
             Token::UnitStruct("Anything"),
         ],
-        Error::Message("invalid type: unit value, expected a sequence".into()),
+        "invalid type: unit value, expected a sequence",
     }
     test_zero_array_from_unit<[isize; 0]> {
         &[
             Token::Unit,
         ],
-        Error::Message("invalid type: unit value, expected an empty array".into()),
+        "invalid type: unit value, expected an empty array",
     }
     test_zero_array_from_unit_struct<[isize; 0]> {
         &[
             Token::UnitStruct("Anything"),
         ],
-        Error::Message("invalid type: unit value, expected an empty array".into()),
+        "invalid type: unit value, expected an empty array",
     }
     test_btreemap_from_unit<BTreeMap<isize, isize>> {
         &[
             Token::Unit,
         ],
-        Error::Message("invalid type: unit value, expected a map".into()),
+        "invalid type: unit value, expected a map",
     }
     test_btreemap_from_unit_struct<BTreeMap<isize, isize>> {
         &[
             Token::UnitStruct("Anything"),
         ],
-        Error::Message("invalid type: unit value, expected a map".into()),
+        "invalid type: unit value, expected a map",
     }
     test_hashmap_from_unit<HashMap<isize, isize>> {
         &[
             Token::Unit,
         ],
-        Error::Message("invalid type: unit value, expected a map".into()),
+        "invalid type: unit value, expected a map",
     }
     test_hashmap_from_unit_struct<HashMap<isize, isize>> {
         &[
             Token::UnitStruct("Anything"),
         ],
-        Error::Message("invalid type: unit value, expected a map".into()),
+        "invalid type: unit value, expected a map",
     }
     test_bool_from_string<bool> {
         &[
             Token::Str("false"),
         ],
-        Error::Message("invalid type: string \"false\", expected a boolean".into()),
+        "invalid type: string \"false\", expected a boolean",
     }
     test_number_from_string<isize> {
         &[
             Token::Str("1"),
         ],
-        Error::Message("invalid type: string \"1\", expected isize".into()),
+        "invalid type: string \"1\", expected isize",
     }
     test_integer_from_float<isize> {
         &[
             Token::F32(0.0),
         ],
-        Error::Message("invalid type: floating point `0`, expected isize".into()),
+        "invalid type: floating point `0`, expected isize",
     }
     test_unit_struct_from_seq<UnitStruct> {
         &[
             Token::Seq(Some(0)),
             Token::SeqEnd,
         ],
-        Error::Message("invalid type: sequence, expected unit struct UnitStruct".into()),
+        "invalid type: sequence, expected unit struct UnitStruct",
     }
 }

test_suite/tests/test_macros.rs

@@ -10,7 +10,7 @@
 extern crate serde_derive;
 
 extern crate serde_test;
-use self::serde_test::{Error, Token, assert_tokens, assert_ser_tokens, assert_de_tokens,
+use self::serde_test::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens,
                        assert_de_tokens_error};
 
 use std::collections::BTreeMap;
@@ -555,12 +555,12 @@ fn test_untagged_enum() {
 
     assert_de_tokens_error::<Untagged>(
         &[Token::None],
-        Error::Message("data did not match any variant of untagged enum Untagged".to_owned(),),
+        "data did not match any variant of untagged enum Untagged",
     );
 
     assert_de_tokens_error::<Untagged>(
         &[Token::Tuple(1), Token::U8(1), Token::TupleEnd],
-        Error::Message("data did not match any variant of untagged enum Untagged".to_owned(),),
+        "data did not match any variant of untagged enum Untagged",
     );
 
     assert_de_tokens_error::<Untagged>(
@@ -571,7 +571,7 @@ fn test_untagged_enum() {
             Token::U8(3),
             Token::TupleEnd,
         ],
-        Error::Message("data did not match any variant of untagged enum Untagged".to_owned(),),
+        "data did not match any variant of untagged enum Untagged",
     );
 }
 
@@ -679,7 +679,7 @@ fn test_internally_tagged_enum() {
 
     assert_de_tokens_error::<InternallyTagged>(
         &[Token::Map(Some(0)), Token::MapEnd],
-        Error::Message("missing field `type`".to_owned()),
+        "missing field `type`",
     );
 
     assert_de_tokens_error::<InternallyTagged>(
@@ -691,7 +691,7 @@ fn test_internally_tagged_enum() {
 
             Token::MapEnd,
         ],
-        Error::Message("unknown variant `Z`, expected one of `A`, `B`, `C`, `D`, `E`, `F`".to_owned(),),
+        "unknown variant `Z`, expected one of `A`, `B`, `C`, `D`, `E`, `F`",
     );
 }
 

test_suite/tests/test_ser.rs

@@ -21,7 +21,7 @@ use std::str;
 extern crate serde;
 
 extern crate serde_test;
-use self::serde_test::{Error, Token, assert_ser_tokens, assert_ser_tokens_error};
+use self::serde_test::{Token, assert_ser_tokens, assert_ser_tokens_error};
 
 extern crate fnv;
 use self::fnv::FnvHasher;
@@ -379,7 +379,7 @@ fn test_cannot_serialize_paths() {
     assert_ser_tokens_error(
         &Path::new(path),
         &[],
-        Error::Message("path contains invalid UTF-8 characters".to_owned()),
+        "path contains invalid UTF-8 characters",
     );
 
     let mut path_buf = PathBuf::new();
@@ -388,7 +388,7 @@ fn test_cannot_serialize_paths() {
     assert_ser_tokens_error(
         &path_buf,
         &[],
-        Error::Message("path contains invalid UTF-8 characters".to_owned()),
+        "path contains invalid UTF-8 characters",
     );
 }
 
@@ -397,21 +397,21 @@ fn test_enum_skipped() {
     assert_ser_tokens_error(
         &Enum::SkippedUnit,
         &[],
-        Error::Message("the enum variant Enum::SkippedUnit cannot be serialized".to_owned(),),
+        "the enum variant Enum::SkippedUnit cannot be serialized",
     );
     assert_ser_tokens_error(
         &Enum::SkippedOne(42),
         &[],
-        Error::Message("the enum variant Enum::SkippedOne cannot be serialized".to_owned(),),
+        "the enum variant Enum::SkippedOne cannot be serialized",
     );
     assert_ser_tokens_error(
         &Enum::SkippedSeq(1, 2),
         &[],
-        Error::Message("the enum variant Enum::SkippedSeq cannot be serialized".to_owned(),),
+        "the enum variant Enum::SkippedSeq cannot be serialized",
     );
     assert_ser_tokens_error(
         &Enum::SkippedMap { _a: 1, _b: 2 },
         &[],
-        Error::Message("the enum variant Enum::SkippedMap cannot be serialized".to_owned(),),
+        "the enum variant Enum::SkippedMap cannot be serialized",
     );
 }