Release 0.8.23

Support deserializing ByteBuf from string

.travis.yml

@@ -1,8 +1,8 @@
 sudo: false
 language: rust
 rust:
-- 1.11.0
 - 1.12.0
+- 1.13.0
 - stable
 - beta
 - nightly

README.md

@@ -11,12 +11,11 @@ You may be looking for:
 - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
 - [Examples](https://serde.rs/examples.html)
 - [API documentation](https://docs.serde.rs/serde/)
+- [Release notes](https://github.com/serde-rs/serde/releases)
 
 ## Serde in action
 
 ```rust
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

examples/serde-syntex-example/Cargo.toml

@@ -3,6 +3,7 @@ name = "serde-syntex-example"
 version = "0.1.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 build = "build.rs"
+publish = false
 
 [features]
 default = ["serde_codegen"]

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "0.8.20"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -9,6 +9,7 @@ repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde/"
 readme = "../README.md"
 keywords = ["serde", "serialization"]
+categories = ["encoding"]
 include = ["Cargo.toml", "src/**/*.rs"]
 
 [features]

serde/src/bytes.rs

@@ -84,7 +84,7 @@ mod bytebuf {
     use de;
 
     #[cfg(feature = "collections")]
-    use collections::Vec;
+    use collections::{String, Vec};
 
     /// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
     #[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
@@ -208,7 +208,7 @@ mod bytebuf {
         fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
             where E: de::Error,
         {
-            self.visit_byte_buf(v.to_vec())
+            Ok(ByteBuf::from(v))
         }
 
         #[inline]
@@ -217,6 +217,18 @@ mod bytebuf {
         {
             Ok(ByteBuf::from(v))
         }
+
+        fn visit_str<E>(&mut self, v: &str) -> Result<ByteBuf, E>
+            where E: de::Error,
+        {
+            Ok(ByteBuf::from(v))
+        }
+
+        fn visit_string<E>(&mut self, v: String) -> Result<ByteBuf, E>
+            where E: de::Error,
+        {
+            Ok(ByteBuf::from(v))
+        }
     }
 
     impl de::Deserialize for ByteBuf {

serde_codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen"
-version = "0.8.20"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -23,7 +23,7 @@ with-syn = []
 [dependencies]
 clippy = { version = "^0.*", optional = true }
 quote = "0.3.8"
-serde_codegen_internals = { version = "=0.11.2", default-features = false, path = "../serde_codegen_internals" }
+serde_codegen_internals = { version = "=0.11.3", default-features = false, path = "../serde_codegen_internals" }
 syn = { version = "0.10", features = ["aster", "visit"] }
-syntex = { version = "^0.50.0", optional = true }
+syntex = { version = "^0.54.0", optional = true }
-syntex_syntax = { version = "^0.50.0", optional = true }
+syntex_syntax = { version = "^0.54.0", optional = true }

serde_codegen/src/lib.rs

@@ -38,11 +38,11 @@ fn syntex_registry() -> syntex::Registry {
 
         impl fold::Folder for StripAttributeFolder {
             fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
-                match attr.node.value.node {
+                if attr.value.name == "serde" {
-                    ast::MetaItemKind::List(ref n, _) if n == &"serde" => { return None; }
+                    if let ast::MetaItemKind::List(..) = attr.value.node {
-                    _ => {}
+                        return None;
+                    }
                 }
-
                 Some(attr)
             }
 
@@ -116,13 +116,12 @@ macro_rules! shim {
 
             use syntax::{attr, ast, visit};
             struct MarkSerdeAttributesUsed;
-            impl visit::Visitor for MarkSerdeAttributesUsed {
+            impl<'a> visit::Visitor<'a> for MarkSerdeAttributesUsed {
                 fn visit_attribute(&mut self, attr: &ast::Attribute) {
-                    match attr.node.value.node {
+                    if attr.value.name == "serde" {
-                        ast::MetaItemKind::List(ref name, _) if name == "serde" => {
+                        if let ast::MetaItemKind::List(..) = attr.value.node {
                             attr::mark_used(attr);
                         }
-                        _ => {}
                     }
                 }
             }

serde_codegen/src/ser.rs

@@ -256,76 +256,80 @@ fn serialize_variant(
     let variant_ident = variant.ident.clone();
     let variant_name = variant.attrs.name().serialize_name();
 
-    match variant.style {
+    if variant.attrs.skip_serializing() {
-        Style::Unit => {
+        let skipped_msg = format!("The enum variant {}::{} cannot be serialized",
-            quote! {
+                                type_ident, variant_ident);
-                #type_ident::#variant_ident =>
+        let skipped_err = quote! {
-                    _serde::ser::Serializer::serialize_unit_variant(
+            Err(_serde::ser::Error::invalid_value(#skipped_msg))
-                        _serializer,
+        };
-                        #type_name,
+        let fields_pat = match variant.style {
-                        #variant_index,
+            Style::Unit => quote!(),
-                        #variant_name,
+            Style::Newtype | Style::Tuple => quote!( (..) ),
-                    ),
+            Style::Struct => quote!( {..} ),
-            }
+        };
-        },
+        quote! {
-        Style::Newtype => {
+            #type_ident::#variant_ident #fields_pat => #skipped_err,
-            let block = serialize_newtype_variant(
-                type_name,
-                variant_index,
-                variant_name,
-                ty,
-                generics,
-                &variant.fields[0],
-            );
-
-            quote! {
-                #type_ident::#variant_ident(ref __simple_value) => #block,
-            }
-        },
-        Style::Tuple => {
-            let field_names: Vec<Tokens> = (0 .. variant.fields.len())
-                .map(|i| {
-                    let id = aster::id(format!("__field{}", i));
-                    quote!(ref #id)
-                })
-                .collect();
-
-            let pat = quote!(#type_ident::#variant_ident(#(#field_names),*));
-
-            let block = serialize_tuple_variant(
-                type_name,
-                variant_index,
-                variant_name,
-                generics,
-                ty,
-                &variant.fields,
-            );
-
-            quote! {
-                #pat => { #block }
-            }
         }
-        Style::Struct => {
+    } else { // variant wasn't skipped
-            let fields = variant.fields.iter().map(|field| {
+        match variant.style {
-                let id = match field.ident {
+            Style::Unit => {
-                    Some(ref name) => name.clone(),
+                quote! {
-                    None => panic!("struct variant has unnamed fields"),
+                    #type_ident::#variant_ident =>
-                };
+                        _serde::ser::Serializer::serialize_unit_variant(
-                quote!(ref #id)
+                            _serializer,
-            });
+                            #type_name,
-            let pat = quote!(#type_ident::#variant_ident { #(#fields),* });
+                            #variant_index,
+                            #variant_name,
+                        ),
+                }
+            },
+            Style::Newtype => {
+                let block = serialize_newtype_variant(
+                    type_name,
+                    variant_index,
+                    variant_name,
+                    ty,
+                    generics,
+                    &variant.fields[0],
+                );
 
-            let block = serialize_struct_variant(
+                quote! {
-                variant_index,
+                    #type_ident::#variant_ident(ref __simple_value) => #block,
-                variant_name,
+                }
-                generics,
+            },
-                ty,
+            Style::Tuple => {
-                &variant.fields,
+                let field_names = (0 .. variant.fields.len())
-                item_attrs,
+                    .map(|i| aster::id(format!("__field{}", i)));
-            );
 
-            quote! {
+                let block = serialize_tuple_variant(
-                #pat => { #block }
+                    type_name,
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                );
+
+                quote! {
+                    #type_ident::#variant_ident(#(ref #field_names),*) => { #block }
+                }
+            }
+            Style::Struct => {
+                let fields = variant.fields.iter()
+                    .map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
+
+                let block = serialize_struct_variant(
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                    item_attrs,
+                );
+
+                quote! {
+                    #type_ident::#variant_ident { #(ref #fields),* } => { #block }
+                }
             }
         }
     }

serde_codegen_internals/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen_internals"
-version = "0.11.2"
+version = "0.11.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "AST representation used by Serde codegen. Unstable."

serde_codegen_internals/src/attr.rs

@@ -188,6 +188,7 @@ impl Item {
 pub struct Variant {
     name: Name,
     skip_deserializing: bool,
+    skip_serializing: bool,
 }
 
 impl Variant {
@@ -195,6 +196,7 @@ impl Variant {
         let mut ser_name = Attr::none(cx, "rename");
         let mut de_name = Attr::none(cx, "rename");
         let mut skip_deserializing = BoolAttr::none(cx, "skip_deserializing");
+        let mut skip_serializing = BoolAttr::none(cx, "skip_serializing");
 
         for meta_items in variant.attrs.iter().filter_map(get_serde_meta_items) {
             for meta_item in meta_items {
@@ -218,6 +220,10 @@ impl Variant {
                     MetaItem(Word(ref name)) if name == "skip_deserializing" => {
                         skip_deserializing.set_true();
                     }
+                    // Parse `#[serde(skip_serializing)]`
+                    MetaItem(Word(ref name)) if name == "skip_serializing" => {
+                        skip_serializing.set_true();
+                    }
 
                     MetaItem(ref meta_item) => {
                         cx.error(format!("unknown serde variant attribute `{}`",
@@ -237,6 +243,7 @@ impl Variant {
                 deserialize: de_name.get().unwrap_or_else(|| variant.ident.to_string()),
             },
             skip_deserializing: skip_deserializing.get(),
+            skip_serializing: skip_serializing.get(),
         }
     }
 
@@ -247,6 +254,10 @@ impl Variant {
     pub fn skip_deserializing(&self) -> bool {
         self.skip_deserializing
     }
+
+    pub fn skip_serializing(&self) -> bool {
+        self.skip_serializing
+    }
 }
 
 /// Represents field attribute information

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "0.8.20"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -15,7 +15,7 @@ name = "serde_derive"
 proc-macro = true
 
 [dependencies.serde_codegen]
-version = "=0.8.20"
+version = "=0.8.23"
 path = "../serde_codegen"
 default-features = false
 features = ["with-syn"]
@@ -23,5 +23,5 @@ features = ["with-syn"]
 [dev-dependencies]
 compiletest_rs = "^0.2.0"
 fnv = "1.0"
-serde = { version = "0.8.20", path = "../serde" }
+serde = { version = "0.8.23", path = "../serde" }
-serde_test = { version = "0.8.20", path = "../serde_test" }
+serde_test = { version = "0.8.23", path = "../serde_test" }

serde_derive/src/lib.rs

@@ -1,6 +1,3 @@
-#![feature(proc_macro, proc_macro_lib)]
-#![cfg(not(test))]
-
 extern crate proc_macro;
 extern crate serde_codegen;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-and-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-rename-de.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-ser-rename-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-ser-rename.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/rename-ser-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/duplicate-attribute/two-rename-ser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/str_ref_deser.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/unknown-attribute/container.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/unknown-attribute/field.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/compile-fail/unknown-attribute/variant.rs

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;
 

serde_derive/tests/run-pass/identity-op.rs

@@ -1,4 +1,3 @@
-#![feature(proc_macro)]
 #![deny(identity_op)]
 
 #[macro_use]

serde_derive/tests/test.rs

@@ -1,4 +1,4 @@
-#![feature(test, proc_macro)]
+#![feature(test)]
 
 #[macro_use]
 extern crate serde_derive;

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "0.8.20"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
@@ -12,4 +12,4 @@ keywords = ["serde", "serialization"]
 include = ["Cargo.toml", "src/**/*.rs"]
 
 [dependencies]
-serde = { version = "0.8.20", path = "../serde" }
+serde = { version = "0.8.23", path = "../serde" }

testing/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_testing"
-version = "0.8.20"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -10,6 +10,7 @@ documentation = "https://docs.serde.rs/serde/"
 readme = "README.md"
 keywords = ["serialization"]
 build = "build.rs"
+publish = false
 
 [features]
 unstable-testing = ["clippy", "serde/unstable-testing", "serde_codegen/unstable-testing"]

testing/tests/test.rs.in

@@ -1,4 +1,5 @@
 extern crate serde;
+extern crate serde_test;
 
 #[macro_use]
 mod macros;

testing/tests/test_bytes.rs

@@ -1,11 +1,13 @@
 use std::fmt;
 use std::error;
 
-use serde::{Serialize, Serializer, Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
 use serde::bytes::{ByteBuf, Bytes};
 use serde::ser;
 use serde::de;
 
+use serde_test::{assert_de_tokens, Token};
+
 ///////////////////////////////////////////////////////////////////////////////
 
 #[derive(Debug, PartialEq)]
@@ -286,153 +288,6 @@ impl Serializer for BytesSerializer {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-struct BytesDeserializer {
-    bytes: Option<Vec<u8>>,
-}
-
-impl BytesDeserializer {
-    fn new(bytes: Vec<u8>) -> Self {
-        BytesDeserializer {
-            bytes: Some(bytes),
-        }
-    }
-}
-
-impl Deserializer for BytesDeserializer {
-    type Error = Error;
-
-    fn deserialize<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        Err(Error)
-    }
-
-    fn deserialize_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        visitor.visit_byte_buf(self.bytes.take().unwrap())
-    }
-
-    fn deserialize_seq<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_struct_field<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_map<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_unit<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_ignored_any<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_string<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_str<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_char<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_i8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_u8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_f32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_f64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_bool<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_usize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_isize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-        where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_option<__V>(&mut self, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_seq_fixed_size<__V>(&mut self, _: usize, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_unit_struct<__V>(&mut self, _: &str, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_newtype_struct<__V>(&mut self, _: &str, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_tuple<__V>(&mut self, _: usize, visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::Visitor {
-        self.deserialize(visitor)
-    }
-    fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _visitor: __V)
-     -> Result<__V::Value, Self::Error> where __V: de::EnumVisitor {
-        Err(Error)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 #[test]
 fn test_bytes_ser_bytes() {
     let buf = vec![];
@@ -449,12 +304,42 @@ fn test_bytes_ser_bytes() {
 ///////////////////////////////////////////////////////////////////////////////
 
 #[test]
-fn test_byte_buf_de_bytes() {
+fn test_byte_buf_de() {
-    let mut de = BytesDeserializer::new(vec![]);
+    let empty = ByteBuf::new();
-    let bytes = Deserialize::deserialize(&mut de);
+    assert_de_tokens(&empty, &[Token::Bytes(b""),]);
-    assert_eq!(bytes, Ok(ByteBuf::new()));
+    assert_de_tokens(&empty, &[Token::Str("")]);
+    assert_de_tokens(&empty, &[Token::String(String::new())]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(None),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(Some(0)),
+        Token::SeqEnd,
+    ]);
 
-    let mut de = BytesDeserializer::new(vec![1, 2, 3]);
+    let buf = ByteBuf::from(vec![65, 66, 67]);
-    let bytes = Deserialize::deserialize(&mut de);
+    assert_de_tokens(&buf, &[Token::Bytes(b"ABC")]);
-    assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3])));
+    assert_de_tokens(&buf, &[Token::Str("ABC")]);
+    assert_de_tokens(&buf, &[Token::String("ABC".to_owned())]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(None),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(Some(3)),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
 }

testing/tests/test_de.rs

@@ -38,6 +38,7 @@ enum Enum {
     Simple(i32),
     Seq(i32, i32, i32),
     Map { a: i32, b: i32, c: i32 },
+    #[allow(dead_code)]
     #[serde(skip_deserializing)]
     Skipped,
 }

testing/tests/test_ser.rs

@@ -30,12 +30,20 @@ struct Struct {
     c: i32,
 }
 
-#[derive(Serialize)]
+#[derive(Serialize, PartialEq, Debug)]
 enum Enum {
     Unit,
     One(i32),
     Seq(i32, i32),
     Map { a: i32, b: i32 },
+    #[serde(skip_serializing)]
+    SkippedUnit,
+    #[serde(skip_serializing)]
+    SkippedOne(i32),
+    #[serde(skip_serializing)]
+    SkippedSeq(i32, i32),
+    #[serde(skip_serializing)]
+    SkippedMap { _a: i32, _b: i32 },
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -388,3 +396,23 @@ fn test_cannot_serialize_paths() {
         &[],
         Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
 }
+
+#[test]
+fn test_enum_skipped() {
+    assert_ser_tokens_error(
+        &Enum::SkippedUnit,
+        &[],
+        Error::InvalidValue("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()));
+    assert_ser_tokens_error(
+        &Enum::SkippedSeq(1, 2),
+        &[],
+        Error::InvalidValue("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()));
+}