Version bump

Closes #149

.travis.yml

@@ -1,37 +1,41 @@
-sudo: false
 language: rust
+sudo: false
+
 rust:
   - stable
   - beta
   - nightly
+
+addons:
+  apt:
+    packages:
+    - libcurl4-openssl-dev
+    - libelf-dev
+    - libdw-dev
+
+before_script:
+- |
+    pip install 'travis-cargo<0.2' --user &&
+    export PATH=$HOME/.local/bin:$PATH
+
+script:
+- |
+    (cd serde && travis-cargo build) &&
+    (cd serde && travis-cargo test) &&
+    (cd serde_tests && travis-cargo test) &&
+    (cd serde_macros && travis-cargo --only nightly test) &&
+    (cd serde_macros && travis-cargo --only nightly bench) &&
+    (cd serde && travis-cargo --only stable doc) &&
+    (cd serde_codegen && travis-cargo --only stable doc)
+
+after_success:
+- (cd serde && travis-cargo --only stable doc-upload)
+- (cd serde_tests && travis-cargo coveralls --no-sudo)
+
 env:
   global:
-    secure: HO41LMpMXkF2In9+1sxWVu7fgolL+y9+4Q5PI6wZX2L5pDwpPJCjxaQarQXCEnoIxED1PlP03JuF7ULNz0zw1ylYhAOfOSdkxFZRnE2wMZqq6qvXBHwyMiDrAociIzoPKSGv7JVrKPsjsnd+96K6xxueIodQZrmAdyq7N/M82Mc=
-  matrix:
-    - CRATE=serde_tests TARGET=test
-matrix:
-  include:
-    - rust: nightly
-      env: CRATE=serde_macros TARGET=test
-    - rust: nightly
-      env: CRATE=serde_macros TARGET=bench
-    - rust: nightly
-      env: CRATE=serde_tests TARGET=bench
-script:
-  - (cd $CRATE && cargo $TARGET)
-after_success: |
-  [ $TRAVIS_BRANCH = "master" ] &&
-  [ $TRAVIS_PULL_REQUEST  = false ] &&
-  mkdir -p target/doc &&
-  (cd serde && cargo doc --no-deps) &&
-  (cd serde_codegen && cargo doc --no-deps) &&
-  (cd serde_macros && cargo doc --no-deps) &&
-  (cd serde_json && cargo doc --no-deps) &&
-  cp -r serde/target/doc target/doc/serde &&
-  cp -r serde_codegen/target/doc target/doc/serde_codegen &&
-  cp -r serde_macros/target/doc target/doc/serde_macros &&
-  cp -r serde_json/target/doc target/doc/serde_json &&
-  echo "<meta http-equiv=refresh content=0;url=`echo $TRAVIS_REPO_SLUG | cut -d '/' -f 2`/index.html>" > target/doc/index.html &&
-  pip install ghp-import &&
-  ghp-import -n target/doc &&
-  git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
+    # override the default `--features unstable` used for the nightly branch (optional)
+    - TRAVIS_CARGO_NIGHTLY_FEATURE=""
+
+    # encrypted github token for doc upload (see `GH_TOKEN` link above)
+    - secure: HO41LMpMXkF2In9+1sxWVu7fgolL+y9+4Q5PI6wZX2L5pDwpPJCjxaQarQXCEnoIxED1PlP03JuF7ULNz0zw1ylYhAOfOSdkxFZRnE2wMZqq6qvXBHwyMiDrAociIzoPKSGv7JVrKPsjsnd+96K6xxueIodQZrmAdyq7N/M82Mc=

README.md

@@ -2,6 +2,7 @@ Serde Rust Serialization Framework
 ==================================
 
 [![Build Status](https://api.travis-ci.org/serde-rs/serde.png?branch=master)](https://travis-ci.org/serde-rs/serde)
+[![Coverage Status](https://coveralls.io/repos/serde-rs/serde/badge.svg?branch=master&service=github)](https://coveralls.io/github/serde-rs/serde?branch=master)
 [![Latest Version](https://img.shields.io/crates/v/serde.svg)](https://crates.io/crates/serde)
 
 Serde is a powerful framework that enables serialization libraries to
@@ -61,7 +62,7 @@ fn main() {
 
     println!("{}", serialized);
 
-    let deserialized: Point = serde_json::from_str(&serialized_point).unwrap();
+    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
 
     println!("{:?}", deserialized);
 }
@@ -119,7 +120,7 @@ fn main() {
 
     println!("{}", serialized);
 
-    let deserialized: Point = serde_json::from_str(&serialized_point).unwrap();
+    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
 
     println!("{:?}", deserialized);
 }
@@ -487,23 +488,23 @@ impl serde::Deserialize for PointField {
     fn deserialize<D>(deserializer: &mut D) -> Result<PointField, D::Error>
         where D: serde::de::Deserializer
     {
-        struct FieldVisitor;
+        struct PointFieldVisitor;
 
-        impl serde::de::Visitor for FieldVisitor {
-            type Value = Field;
+        impl serde::de::Visitor for PointFieldVisitor {
+            type Value = PointField;
 
             fn visit_str<E>(&mut self, value: &str) -> Result<PointField, E>
                 where E: serde::de::Error
             {
                 match value {
-                    "x" => Ok(Field::X),
-                    "y" => Ok(Field::Y),
+                    "x" => Ok(PointField::X),
+                    "y" => Ok(PointField::Y),
                     _ => Err(serde::de::Error::syntax("expected x or y")),
                 }
             }
         }
 
-        deserializer.visit(FieldVisitor)
+        deserializer.visit(PointFieldVisitor)
     }
 }
 ```
@@ -515,7 +516,8 @@ impl serde::Deserialize for Point {
     fn deserialize<D>(deserializer: &mut D) -> Result<Point, D::Error>
         where D: serde::de::Deserializer
     {
-        deserializer.visit_struct("Point", PointVisitor)
+        static FIELDS: &'static [&'static str] = &["x", "y"];
+        deserializer.visit_struct("Point", FIELDS, PointVisitor)
     }
 }
 
@@ -524,9 +526,7 @@ struct PointVisitor;
 impl serde::de::Visitor for PointVisitor {
     type Value = Point;
 
-    fn visit_struct<V>(&mut self,
-                       _fields: &[&str],
-                       mut visitor: V) -> Result<Point, V::Error>
+    fn visit_map<V>(&mut self, mut visitor: V) -> Result<Point, V::Error>
         where V: serde::de::MapVisitor
     {
         let mut x = None;
@@ -534,8 +534,8 @@ impl serde::de::Visitor for PointVisitor {
 
         loop {
             match try!(visitor.visit_key()) {
-                Some(Field::X) => { x = Some(try!(visitor.visit_value())); }
-                Some(Field::Y) => { y = Some(try!(visitor.visit_value())); }
+                Some(PointField::X) => { x = Some(try!(visitor.visit_value())); }
+                Some(PointField::Y) => { y = Some(try!(visitor.visit_value())); }
                 None => { break; }
             }
         }

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "0.5.2"
+version = "0.5.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"

serde/src/de/mod.rs

@@ -68,7 +68,7 @@ pub enum Type {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-pub trait Deserialize {
+pub trait Deserialize: Sized {
     /// Deserialize this value given this `Deserializer`.
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer;

serde/src/de/value.rs

@@ -16,6 +16,7 @@ use bytes;
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#[derive(Clone, Debug, PartialEq)]
 pub enum Error {
     SyntaxError,
     EndOfStreamError,

serde_codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen"
-version = "0.5.1"
+version = "0.5.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"

serde_codegen/src/ser.rs

@@ -580,10 +580,13 @@ fn serialize_struct_visitor<I>(
 ) -> (P<ast::Item>, P<ast::Item>)
     where I: Iterator<Item=P<ast::Expr>>,
 {
-    let len = struct_def.fields.len();
-
     let field_attrs = struct_field_attrs(cx, builder, struct_def);
 
+    let len = struct_def.fields.len() - field_attrs.iter()
+        .fold(0, |sum, field| {
+            sum + if field.skip_serializing_field() { 1 } else { 0 }
+        });
+
     let arms: Vec<ast::Arm> = field_attrs.into_iter()
         .zip(value_exprs)
         .filter(|&(ref field, _)| !field.skip_serializing_field())

serde_json/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "serde_json"
-version = "0.5.1"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
-license = "MIT/Apache-2.0"
-description = "A JSON serialization file format"
-repository = "https://github.com/serde-rs/serde"
-documentation = "https://serde-rs.github.io/serde/serde_json/serde_json/index.html"
-readme = "../README.md"
-keywords = ["json", "serde", "serialization"]
-
-[dependencies]
-num = "*"
-serde = { version = "*", path = "../serde" }

serde_json/src/builder.rs

@@ -1,85 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::collections::BTreeMap;
-
-use serde::ser::{self, Serialize};
-
-use value::{self, Value};
-
-pub struct ArrayBuilder {
-    array: Vec<Value>,
-}
-
-impl ArrayBuilder {
-    pub fn new() -> ArrayBuilder {
-        ArrayBuilder { array: Vec::new() }
-    }
-
-    pub fn unwrap(self) -> Value {
-        Value::Array(self.array)
-    }
-
-    pub fn push<T: ser::Serialize>(mut self, v: T) -> ArrayBuilder {
-        self.array.push(value::to_value(&v));
-        self
-    }
-
-    pub fn push_array<F>(mut self, f: F) -> ArrayBuilder where
-        F: FnOnce(ArrayBuilder) -> ArrayBuilder
-    {
-        let builder = ArrayBuilder::new();
-        self.array.push(f(builder).unwrap());
-        self
-    }
-
-    pub fn push_object<F>(mut self, f: F) -> ArrayBuilder where
-        F: FnOnce(ObjectBuilder) -> ObjectBuilder
-    {
-        let builder = ObjectBuilder::new();
-        self.array.push(f(builder).unwrap());
-        self
-    }
-}
-
-pub struct ObjectBuilder {
-    object: BTreeMap<String, Value>,
-}
-
-impl ObjectBuilder {
-    pub fn new() -> ObjectBuilder {
-        ObjectBuilder { object: BTreeMap::new() }
-    }
-
-    pub fn unwrap(self) -> Value {
-        Value::Object(self.object)
-    }
-
-    pub fn insert<V: ser::Serialize>(mut self, k: String, v: V) -> ObjectBuilder {
-        self.object.insert(k, value::to_value(&v));
-        self
-    }
-
-    pub fn insert_array<F>(mut self, key: String, f: F) -> ObjectBuilder where
-        F: FnOnce(ArrayBuilder) -> ArrayBuilder
-    {
-        let builder = ArrayBuilder::new();
-        self.object.insert(key, f(builder).unwrap());
-        self
-    }
-
-    pub fn insert_object<F>(mut self, key: String, f: F) -> ObjectBuilder where
-        F: FnOnce(ObjectBuilder) -> ObjectBuilder
-    {
-        let builder = ObjectBuilder::new();
-        self.object.insert(key, f(builder).unwrap());
-        self
-    }
-}

serde_json/src/de.rs

@@ -1,820 +0,0 @@
-use std::char;
-use std::i32;
-use std::io;
-use std::str;
-
-use serde::de;
-use serde::iter::LineColIterator;
-
-use super::error::{Error, ErrorCode, Result};
-
-pub struct Deserializer<Iter: Iterator<Item=io::Result<u8>>> {
-    rdr: LineColIterator<Iter>,
-    ch: Option<u8>,
-    str_buf: Vec<u8>,
-}
-
-macro_rules! try_or_invalid {
-    ($self_:expr, $e:expr) => {
-        match $e {
-            Some(v) => v,
-            None => { return Err($self_.error(ErrorCode::InvalidNumber)); }
-        }
-    }
-}
-
-impl<Iter> Deserializer<Iter>
-    where Iter: Iterator<Item=io::Result<u8>>,
-{
-    /// Creates the JSON parser from an `std::iter::Iterator`.
-    #[inline]
-    pub fn new(rdr: Iter) -> Deserializer<Iter> {
-        Deserializer {
-            rdr: LineColIterator::new(rdr),
-            ch: None,
-            str_buf: Vec::with_capacity(128),
-        }
-    }
-
-    #[inline]
-    pub fn end(&mut self) -> Result<()> {
-        try!(self.parse_whitespace());
-        if try!(self.eof()) {
-            Ok(())
-        } else {
-            Err(self.error(ErrorCode::TrailingCharacters))
-        }
-    }
-
-    fn eof(&mut self) -> Result<bool> {
-        Ok(try!(self.peek()).is_none())
-    }
-
-    fn peek(&mut self) -> Result<Option<u8>> {
-        match self.ch {
-            Some(ch) => Ok(Some(ch)),
-            None => {
-                match self.rdr.next() {
-                    Some(Err(err)) => Err(Error::IoError(err)),
-                    Some(Ok(ch)) => {
-                        self.ch = Some(ch);
-                        Ok(self.ch)
-                    }
-                    None => Ok(None),
-                }
-            }
-        }
-    }
-
-    fn peek_or_null(&mut self) -> Result<u8> {
-        Ok(try!(self.peek()).unwrap_or(b'\x00'))
-    }
-
-    fn eat_char(&mut self) {
-        self.ch = None;
-    }
-
-    fn next_char(&mut self) -> Result<Option<u8>> {
-        match self.ch.take() {
-            Some(ch) => Ok(Some(ch)),
-            None => {
-                match self.rdr.next() {
-                    Some(Err(err)) => Err(Error::IoError(err)),
-                    Some(Ok(ch)) => Ok(Some(ch)),
-                    None => Ok(None),
-                }
-            }
-        }
-    }
-
-    fn next_char_or_null(&mut self) -> Result<u8> {
-        Ok(try!(self.next_char()).unwrap_or(b'\x00'))
-    }
-
-    fn error(&mut self, reason: ErrorCode) -> Error {
-        Error::SyntaxError(reason, self.rdr.line(), self.rdr.col())
-    }
-
-    fn parse_whitespace(&mut self) -> Result<()> {
-        loop {
-            match try!(self.peek_or_null()) {
-                b' ' | b'\n' | b'\t' | b'\r' => {
-                    self.eat_char();
-                }
-                _ => { return Ok(()); }
-            }
-        }
-    }
-
-    fn parse_value<V>(&mut self, mut visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        try!(self.parse_whitespace());
-
-        if try!(self.eof()) {
-            return Err(self.error(ErrorCode::EOFWhileParsingValue));
-        }
-
-        let value = match try!(self.peek_or_null()) {
-            b'n' => {
-                self.eat_char();
-                try!(self.parse_ident(b"ull"));
-                visitor.visit_unit()
-            }
-            b't' => {
-                self.eat_char();
-                try!(self.parse_ident(b"rue"));
-                visitor.visit_bool(true)
-            }
-            b'f' => {
-                self.eat_char();
-                try!(self.parse_ident(b"alse"));
-                visitor.visit_bool(false)
-            }
-            b'-' => {
-                self.eat_char();
-                self.parse_integer(false, visitor)
-            }
-            b'0' ... b'9' => {
-                self.parse_integer(true, visitor)
-            }
-            b'"' => {
-                self.eat_char();
-                try!(self.parse_string());
-                let s = str::from_utf8(&self.str_buf).unwrap();
-                visitor.visit_str(s)
-            }
-            b'[' => {
-                self.eat_char();
-                visitor.visit_seq(SeqVisitor::new(self))
-            }
-            b'{' => {
-                self.eat_char();
-                visitor.visit_map(MapVisitor::new(self))
-            }
-            _ => {
-                Err(self.error(ErrorCode::ExpectedSomeValue))
-            }
-        };
-
-        match value {
-            Ok(value) => Ok(value),
-            Err(Error::SyntaxError(code, _, _)) => Err(self.error(code)),
-            Err(err) => Err(err),
-        }
-    }
-
-    fn parse_ident(&mut self, ident: &[u8]) -> Result<()> {
-        for c in ident {
-            if Some(*c) != try!(self.next_char()) {
-                return Err(self.error(ErrorCode::ExpectedSomeIdent));
-            }
-        }
-
-        Ok(())
-    }
-
-    fn parse_integer<V>(&mut self, pos: bool, visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        match try!(self.next_char_or_null()) {
-            b'0' => {
-                // There can be only one leading '0'.
-                match try!(self.peek_or_null()) {
-                    b'0' ... b'9' => {
-                        Err(self.error(ErrorCode::InvalidNumber))
-                    }
-                    _ => {
-                        self.parse_number(pos, 0, visitor)
-                    }
-                }
-            },
-            c @ b'1' ... b'9' => {
-                let mut res: u64 = (c as u64) - ('0' as u64);
-
-                loop {
-                    match try!(self.peek_or_null()) {
-                        c @ b'0' ... b'9' => {
-                            self.eat_char();
-
-                            let digit = (c as u64) - ('0' as u64);
-
-                            // We need to be careful with overflow. If we can, try to keep the
-                            // number as a `u64` until we grow too large. At that point, switch to
-                            // parsing the value as a `f64`.
-                            match res.checked_mul(10).and_then(|val| val.checked_add(digit)) {
-                                Some(res_) => { res = res_; }
-                                None => {
-                                    return self.parse_float(
-                                        pos,
-                                        (res as f64) * 10.0 + (digit as f64),
-                                        visitor);
-                                }
-                            }
-                        }
-                        _ => {
-                            return self.parse_number(pos, res, visitor);
-                        }
-                    }
-                }
-            }
-            _ => {
-                Err(self.error(ErrorCode::InvalidNumber))
-            }
-        }
-    }
-
-    fn parse_float<V>(&mut self,
-                      pos: bool,
-                      mut res: f64,
-                      mut visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        loop {
-            match try!(self.next_char_or_null()) {
-                c @ b'0' ... b'9' => {
-                    let digit = (c as u64) - ('0' as u64);
-
-                    res *= 10.0;
-                    res += digit as f64;
-                }
-                _ => {
-                    match try!(self.peek_or_null()) {
-                        b'.' => {
-                            return self.parse_decimal(pos, res, visitor);
-                        }
-                        b'e' | b'E' => {
-                            return self.parse_exponent(pos, res, visitor);
-                        }
-                        _ => {
-                            if !pos {
-                                res = -res;
-                            }
-
-                            return visitor.visit_f64(res);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    fn parse_number<V>(&mut self,
-                       pos: bool,
-                       res: u64,
-                       mut visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        match try!(self.peek_or_null()) {
-            b'.' => {
-                self.parse_decimal(pos, res as f64, visitor)
-            }
-            b'e' | b'E' => {
-                self.parse_exponent(pos, res as f64, visitor)
-            }
-            _ => {
-                if pos {
-                    visitor.visit_u64(res)
-                } else {
-                    // FIXME: `wrapping_neg` will be stable in Rust 1.2
-                    //let res_i64 = (res as i64).wrapping_neg();
-                    let res_i64 = (!res + 1) as i64;
-
-                    // Convert into a float if we underflow.
-                    if res_i64 > 0 {
-                        visitor.visit_f64(-(res as f64))
-                    } else {
-                        visitor.visit_i64(res_i64)
-                    }
-                }
-            }
-        }
-    }
-
-    fn parse_decimal<V>(&mut self,
-                        pos: bool,
-                        mut res: f64,
-                        mut visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        self.eat_char();
-
-        let mut dec = 0.1;
-
-        // Make sure a digit follows the decimal place.
-        match try!(self.next_char_or_null()) {
-            c @ b'0' ... b'9' => {
-                res += (((c as u64) - (b'0' as u64)) as f64) * dec;
-            }
-             _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
-        }
-
-        loop {
-            match try!(self.peek_or_null()) {
-                c @ b'0' ... b'9' => {
-                    self.eat_char();
-
-                    dec /= 10.0;
-                    res += (((c as u64) - (b'0' as u64)) as f64) * dec;
-                }
-                _ => { break; }
-            }
-        }
-
-        match try!(self.peek_or_null()) {
-            b'e' | b'E' => {
-                self.parse_exponent(pos, res, visitor)
-            }
-            _ => {
-                if pos {
-                    visitor.visit_f64(res)
-                } else {
-                    visitor.visit_f64(-res)
-                }
-            }
-        }
-
-    }
-
-    fn parse_exponent<V>(&mut self,
-                         pos: bool,
-                         mut res: f64,
-                         mut visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        self.eat_char();
-
-        let pos_exp = match try!(self.peek_or_null()) {
-            b'+' => { self.eat_char(); true }
-            b'-' => { self.eat_char(); false }
-            _ => { true }
-        };
-
-        // Make sure a digit follows the exponent place.
-        let mut exp = match try!(self.next_char_or_null()) {
-            c @ b'0' ... b'9' => { (c as u64) - (b'0' as u64) }
-            _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
-        };
-
-        loop {
-            match try!(self.peek_or_null()) {
-                c @ b'0' ... b'9' => {
-                    self.eat_char();
-
-                    exp = try_or_invalid!(self, exp.checked_mul(10));
-                    exp = try_or_invalid!(self, exp.checked_add((c as u64) - (b'0' as u64)));
-                }
-                _ => { break; }
-            }
-        }
-
-        let exp = if exp <= i32::MAX as u64 {
-            10_f64.powi(exp as i32)
-        } else {
-            return Err(self.error(ErrorCode::InvalidNumber));
-        };
-
-        if pos_exp {
-            res *= exp;
-        } else {
-            res /= exp;
-        }
-
-        if pos {
-            visitor.visit_f64(res)
-        } else {
-            visitor.visit_f64(-res)
-        }
-    }
-
-    fn decode_hex_escape(&mut self) -> Result<u16> {
-        let mut i = 0;
-        let mut n = 0u16;
-        while i < 4 && !try!(self.eof()) {
-            n = match try!(self.next_char_or_null()) {
-                c @ b'0' ... b'9' => n * 16_u16 + ((c as u16) - (b'0' as u16)),
-                b'a' | b'A' => n * 16_u16 + 10_u16,
-                b'b' | b'B' => n * 16_u16 + 11_u16,
-                b'c' | b'C' => n * 16_u16 + 12_u16,
-                b'd' | b'D' => n * 16_u16 + 13_u16,
-                b'e' | b'E' => n * 16_u16 + 14_u16,
-                b'f' | b'F' => n * 16_u16 + 15_u16,
-                _ => { return Err(self.error(ErrorCode::InvalidEscape)); }
-            };
-
-            i += 1;
-        }
-
-        // Error out if we didn't parse 4 digits.
-        if i != 4 {
-            return Err(self.error(ErrorCode::InvalidEscape));
-        }
-
-        Ok(n)
-    }
-
-    fn parse_string(&mut self) -> Result<()> {
-        self.str_buf.clear();
-
-        loop {
-            let ch = match try!(self.next_char()) {
-                Some(ch) => ch,
-                None => { return Err(self.error(ErrorCode::EOFWhileParsingString)); }
-            };
-
-            match ch {
-                b'"' => {
-                    return Ok(());
-                }
-                b'\\' => {
-                    let ch = match try!(self.next_char()) {
-                        Some(ch) => ch,
-                        None => { return Err(self.error(ErrorCode::EOFWhileParsingString)); }
-                    };
-
-                    match ch {
-                        b'"' => self.str_buf.push(b'"'),
-                        b'\\' => self.str_buf.push(b'\\'),
-                        b'/' => self.str_buf.push(b'/'),
-                        b'b' => self.str_buf.push(b'\x08'),
-                        b'f' => self.str_buf.push(b'\x0c'),
-                        b'n' => self.str_buf.push(b'\n'),
-                        b'r' => self.str_buf.push(b'\r'),
-                        b't' => self.str_buf.push(b'\t'),
-                        b'u' => {
-                            let c = match try!(self.decode_hex_escape()) {
-                                0xDC00 ... 0xDFFF => {
-                                    return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
-                                }
-
-                                // Non-BMP characters are encoded as a sequence of
-                                // two hex escapes, representing UTF-16 surrogates.
-                                n1 @ 0xD800 ... 0xDBFF => {
-                                    match (try!(self.next_char()), try!(self.next_char())) {
-                                        (Some(b'\\'), Some(b'u')) => (),
-                                        _ => {
-                                            return Err(self.error(ErrorCode::UnexpectedEndOfHexEscape));
-                                        }
-                                    }
-
-                                    let n2 = try!(self.decode_hex_escape());
-
-                                    if n2 < 0xDC00 || n2 > 0xDFFF {
-                                        return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
-                                    }
-
-                                    let n = (((n1 - 0xD800) as u32) << 10 |
-                                              (n2 - 0xDC00) as u32) + 0x1_0000;
-
-                                    match char::from_u32(n as u32) {
-                                        Some(c) => c,
-                                        None => {
-                                            return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
-                                        }
-                                    }
-                                }
-
-                                n => {
-                                    match char::from_u32(n as u32) {
-                                        Some(c) => c,
-                                        None => {
-                                            return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
-                                        }
-                                    }
-                                }
-                            };
-
-                            // FIXME: this allocation is required in order to be compatible with stable
-                            // rust, which doesn't support encoding a `char` into a stack buffer.
-                            let buf = c.to_string();
-                            self.str_buf.extend(buf.bytes());
-                        }
-                        _ => {
-                            return Err(self.error(ErrorCode::InvalidEscape));
-                        }
-                    }
-                }
-                ch => {
-                    self.str_buf.push(ch);
-                }
-            }
-        }
-    }
-
-    fn parse_object_colon(&mut self) -> Result<()> {
-        try!(self.parse_whitespace());
-
-        match try!(self.next_char()) {
-            Some(b':') => Ok(()),
-            Some(_) => Err(self.error(ErrorCode::ExpectedColon)),
-            None => Err(self.error(ErrorCode::EOFWhileParsingObject)),
-        }
-    }
-}
-
-impl<Iter> de::Deserializer for Deserializer<Iter>
-    where Iter: Iterator<Item=io::Result<u8>>,
-{
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        self.parse_value(visitor)
-    }
-
-    /// Parses a `null` as a None, and any other values as a `Some(...)`.
-    #[inline]
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        try!(self.parse_whitespace());
-
-        match try!(self.peek_or_null()) {
-            b'n' => {
-                self.eat_char();
-                try!(self.parse_ident(b"ull"));
-                visitor.visit_none()
-            }
-            _ => {
-                visitor.visit_some(self)
-            }
-        }
-    }
-
-    /// Parses a newtype struct as the underlying value.
-    #[inline]
-    fn visit_newtype_struct<V>(&mut self,
-                               _name: &str,
-                               mut visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    /// Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straight
-    /// value, a `[..]`, or a `{..}`.
-    #[inline]
-    fn visit_enum<V>(&mut self,
-                     _name: &str,
-                     _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value>
-        where V: de::EnumVisitor,
-    {
-        try!(self.parse_whitespace());
-
-        match try!(self.next_char_or_null()) {
-            b'{' => {
-                try!(self.parse_whitespace());
-
-                let value = {
-                    try!(visitor.visit(&mut *self))
-                };
-
-                try!(self.parse_whitespace());
-
-                match try!(self.next_char_or_null()) {
-                    b'}' => {
-                        Ok(value)
-                    }
-                    _ => {
-                        Err(self.error(ErrorCode::ExpectedSomeValue))
-                    }
-                }
-            }
-            _ => {
-                Err(self.error(ErrorCode::ExpectedSomeValue))
-            }
-        }
-    }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
-}
-
-struct SeqVisitor<'a, Iter: 'a + Iterator<Item=io::Result<u8>>> {
-    de: &'a mut Deserializer<Iter>,
-    first: bool,
-}
-
-impl<'a, Iter: Iterator<Item=io::Result<u8>>> SeqVisitor<'a, Iter> {
-    fn new(de: &'a mut Deserializer<Iter>) -> Self {
-        SeqVisitor {
-            de: de,
-            first: true,
-        }
-    }
-}
-
-impl<'a, Iter> de::SeqVisitor for SeqVisitor<'a, Iter>
-    where Iter: Iterator<Item=io::Result<u8>>,
-{
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>>
-        where T: de::Deserialize,
-    {
-        try!(self.de.parse_whitespace());
-
-        match try!(self.de.peek()) {
-            Some(b']') => {
-                return Ok(None);
-            }
-            Some(b',') if !self.first => {
-                self.de.eat_char();
-            }
-            Some(_) => {
-                if self.first {
-                    self.first = false;
-                } else {
-                    return Err(self.de.error(ErrorCode::ExpectedListCommaOrEnd));
-                }
-            }
-            None => {
-                return Err(self.de.error(ErrorCode::EOFWhileParsingList));
-            }
-        }
-
-        let value = try!(de::Deserialize::deserialize(self.de));
-        Ok(Some(value))
-    }
-
-    fn end(&mut self) -> Result<()> {
-        try!(self.de.parse_whitespace());
-
-        match try!(self.de.next_char()) {
-            Some(b']') => { Ok(()) }
-            Some(_) => {
-                Err(self.de.error(ErrorCode::TrailingCharacters))
-            }
-            None => {
-                Err(self.de.error(ErrorCode::EOFWhileParsingList))
-            }
-        }
-    }
-}
-
-struct MapVisitor<'a, Iter: 'a + Iterator<Item=io::Result<u8>>> {
-    de: &'a mut Deserializer<Iter>,
-    first: bool,
-}
-
-impl<'a, Iter: Iterator<Item=io::Result<u8>>> MapVisitor<'a, Iter> {
-    fn new(de: &'a mut Deserializer<Iter>) -> Self {
-        MapVisitor {
-            de: de,
-            first: true,
-        }
-    }
-}
-
-impl<'a, Iter> de::MapVisitor for MapVisitor<'a, Iter>
-    where Iter: Iterator<Item=io::Result<u8>>
-{
-    type Error = Error;
-
-    fn visit_key<K>(&mut self) -> Result<Option<K>>
-        where K: de::Deserialize,
-    {
-        try!(self.de.parse_whitespace());
-
-        match try!(self.de.peek()) {
-            Some(b'}') => {
-                return Ok(None);
-            }
-            Some(b',') if !self.first => {
-                self.de.eat_char();
-                try!(self.de.parse_whitespace());
-            }
-            Some(_) => {
-                if self.first {
-                    self.first = false;
-                } else {
-                    return Err(self.de.error(ErrorCode::ExpectedObjectCommaOrEnd));
-                }
-            }
-            None => {
-                return Err(self.de.error(ErrorCode::EOFWhileParsingObject));
-            }
-        }
-
-        match try!(self.de.peek()) {
-            Some(b'"') => {
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
-            }
-            Some(_) => {
-                Err(self.de.error(ErrorCode::KeyMustBeAString))
-            }
-            None => {
-                Err(self.de.error(ErrorCode::EOFWhileParsingValue))
-            }
-        }
-    }
-
-    fn visit_value<V>(&mut self) -> Result<V>
-        where V: de::Deserialize,
-    {
-        try!(self.de.parse_object_colon());
-
-        Ok(try!(de::Deserialize::deserialize(self.de)))
-    }
-
-    fn end(&mut self) -> Result<()> {
-        try!(self.de.parse_whitespace());
-
-        match try!(self.de.next_char()) {
-            Some(b'}') => { Ok(()) }
-            Some(_) => {
-                Err(self.de.error(ErrorCode::TrailingCharacters))
-            }
-            None => {
-                Err(self.de.error(ErrorCode::EOFWhileParsingObject))
-            }
-        }
-    }
-
-    fn missing_field<V>(&mut self, _field: &'static str) -> Result<V>
-        where V: de::Deserialize,
-    {
-        let mut de = de::value::ValueDeserializer::into_deserializer(());
-        Ok(try!(de::Deserialize::deserialize(&mut de)))
-    }
-}
-
-impl<Iter> de::VariantVisitor for Deserializer<Iter>
-    where Iter: Iterator<Item=io::Result<u8>>,
-{
-    type Error = Error;
-
-    fn visit_variant<V>(&mut self) -> Result<V>
-        where V: de::Deserialize
-    {
-        let val = try!(de::Deserialize::deserialize(self));
-        try!(self.parse_object_colon());
-        Ok(val)
-    }
-
-    fn visit_unit(&mut self) -> Result<()> {
-        de::Deserialize::deserialize(self)
-    }
-
-    fn visit_newtype<T>(&mut self) -> Result<T>
-        where T: de::Deserialize,
-    {
-        de::Deserialize::deserialize(self)
-    }
-
-    fn visit_tuple<V>(&mut self,
-                      _len: usize,
-                      visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        de::Deserializer::visit(self, visitor)
-    }
-
-    fn visit_struct<V>(&mut self,
-                       _fields: &'static [&'static str],
-                       visitor: V) -> Result<V::Value>
-        where V: de::Visitor,
-    {
-        de::Deserializer::visit(self, visitor)
-    }
-}
-
-/// Decodes a json value from a `std::io::Read`.
-pub fn from_iter<I, T>(iter: I) -> Result<T>
-    where I: Iterator<Item=io::Result<u8>>,
-          T: de::Deserialize,
-{
-    let mut de = Deserializer::new(iter);
-    let value = try!(de::Deserialize::deserialize(&mut de));
-
-    // Make sure the whole stream has been consumed.
-    try!(de.end());
-    Ok(value)
-}
-
-/// Decodes a json value from a `std::io::Read`.
-pub fn from_reader<R, T>(rdr: R) -> Result<T>
-    where R: io::Read,
-          T: de::Deserialize,
-{
-    from_iter(rdr.bytes())
-}
-
-/// Decodes a json value from a `&str`.
-pub fn from_slice<T>(v: &[u8]) -> Result<T>
-    where T: de::Deserialize
-{
-    from_iter(v.iter().map(|byte| Ok(*byte)))
-}
-
-/// Decodes a json value from a `&str`.
-pub fn from_str<T>(s: &str) -> Result<T>
-    where T: de::Deserialize
-{
-    from_slice(s.as_bytes())
-}

serde_json/src/error.rs

@@ -1,189 +0,0 @@
-use std::error;
-use std::fmt;
-use std::io;
-use std::result;
-
-use serde::de;
-
-/// The errors that can arise while parsing a JSON stream.
-#[derive(Clone, PartialEq)]
-pub enum ErrorCode {
-    EOFWhileParsingList,
-    EOFWhileParsingObject,
-    EOFWhileParsingString,
-    EOFWhileParsingValue,
-    ExpectedColon,
-    ExpectedConversion,
-    ExpectedEnumEnd,
-    ExpectedEnumEndToken,
-    ExpectedEnumMapStart,
-    ExpectedEnumToken,
-    ExpectedEnumVariantString,
-    ExpectedListCommaOrEnd,
-    ExpectedName,
-    ExpectedObjectCommaOrEnd,
-    ExpectedSomeIdent,
-    ExpectedSomeValue,
-    InvalidEscape,
-    InvalidNumber,
-    InvalidUnicodeCodePoint,
-    KeyMustBeAString,
-    LoneLeadingSurrogateInHexEscape,
-    UnknownField(String),
-    MissingField(&'static str),
-    NotFourDigit,
-    NotUtf8,
-    TrailingCharacters,
-    UnexpectedEndOfHexEscape,
-    UnknownVariant,
-    UnrecognizedHex,
-}
-
-impl fmt::Debug for ErrorCode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use std::fmt::Debug;
-
-        match *self {
-            //ErrorCode::ConversionError(ref token) => write!(f, "failed to convert {}", token),
-            ErrorCode::EOFWhileParsingList => "EOF While parsing list".fmt(f),
-            ErrorCode::EOFWhileParsingObject => "EOF While parsing object".fmt(f),
-            ErrorCode::EOFWhileParsingString => "EOF While parsing string".fmt(f),
-            ErrorCode::EOFWhileParsingValue => "EOF While parsing value".fmt(f),
-            ErrorCode::ExpectedColon => "expected `:`".fmt(f),
-            ErrorCode::ExpectedConversion => "expected conversion".fmt(f),
-            ErrorCode::ExpectedEnumEnd => "expected enum end".fmt(f),
-            ErrorCode::ExpectedEnumEndToken => "expected enum map end".fmt(f),
-            ErrorCode::ExpectedEnumMapStart => "expected enum map start".fmt(f),
-            ErrorCode::ExpectedEnumToken => "expected enum token".fmt(f),
-            ErrorCode::ExpectedEnumVariantString => "expected variant".fmt(f),
-            ErrorCode::ExpectedListCommaOrEnd => "expected `,` or `]`".fmt(f),
-            ErrorCode::ExpectedName => "expected name".fmt(f),
-            ErrorCode::ExpectedObjectCommaOrEnd => "expected `,` or `}`".fmt(f),
-            ErrorCode::ExpectedSomeIdent => "expected ident".fmt(f),
-            ErrorCode::ExpectedSomeValue => "expected value".fmt(f),
-            //ErrorCode::ExpectedTokens(ref token, tokens) => write!(f, "expected {}, found {}", tokens, token),
-            ErrorCode::InvalidEscape => "invalid escape".fmt(f),
-            ErrorCode::InvalidNumber => "invalid number".fmt(f),
-            ErrorCode::InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f),
-            ErrorCode::KeyMustBeAString => "key must be a string".fmt(f),
-            ErrorCode::LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f),
-            ErrorCode::UnknownField(ref field) => write!(f, "unknown field \"{}\"", field),
-            ErrorCode::MissingField(ref field) => write!(f, "missing field \"{}\"", field),
-            ErrorCode::NotFourDigit => "invalid \\u escape (not four digits)".fmt(f),
-            ErrorCode::NotUtf8 => "contents not utf-8".fmt(f),
-            ErrorCode::TrailingCharacters => "trailing characters".fmt(f),
-            ErrorCode::UnexpectedEndOfHexEscape => "unexpected end of hex escape".fmt(f),
-            //ErrorCode::UnexpectedName(ref name) => write!(f, "unexpected name {}", name),
-            ErrorCode::UnknownVariant => "unknown variant".fmt(f),
-            ErrorCode::UnrecognizedHex => "invalid \\u escape (unrecognized hex)".fmt(f),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum Error {
-    /// msg, line, col
-    SyntaxError(ErrorCode, usize, usize),
-    IoError(io::Error),
-    /*
-    ExpectedError(String, String),
-    */
-    MissingFieldError(&'static str),
-    /*
-    UnknownVariantError(String),
-    */
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::SyntaxError(..) => "syntax error",
-            Error::IoError(ref error) => error::Error::description(error),
-            /*
-            Error::ExpectedError(ref expected, _) => &expected,
-            */
-            Error::MissingFieldError(_) => "missing field",
-            /*
-            Error::UnknownVariantError(_) => "unknown variant",
-            */
-        }
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::IoError(ref error) => Some(error),
-            _ => None,
-        }
-    }
-
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::SyntaxError(ref code, line, col) => {
-                write!(fmt, "{:?} at line {} column {}", code, line, col)
-            }
-            Error::IoError(ref error) => fmt::Display::fmt(error, fmt),
-            /*
-            Error::ExpectedError(ref expected, ref found) => {
-                Some(format!("expected {}, found {}", expected, found))
-            }
-            */
-            Error::MissingFieldError(ref field) => {
-                write!(fmt, "missing field {}", field)
-            }
-            /*
-            Error::UnknownVariantError(ref variant) => {
-                Some(format!("unknown variant {}", variant))
-            }
-            */
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(error: io::Error) -> Error {
-        Error::IoError(error)
-    }
-}
-
-impl From<de::value::Error> for Error {
-    fn from(error: de::value::Error) -> Error {
-        match error {
-            de::value::Error::SyntaxError => {
-                Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)
-            }
-            de::value::Error::EndOfStreamError => {
-                de::Error::end_of_stream()
-            }
-            de::value::Error::UnknownFieldError(field) => {
-                Error::SyntaxError(ErrorCode::UnknownField(field), 0, 0)
-            }
-            de::value::Error::MissingFieldError(field) => {
-                de::Error::missing_field(field)
-            }
-        }
-    }
-}
-
-impl de::Error for Error {
-    fn syntax(_: &str) -> Error {
-        Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)
-    }
-
-    fn end_of_stream() -> Error {
-        Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 0, 0)
-    }
-
-    fn unknown_field(field: &str) -> Error {
-        Error::SyntaxError(ErrorCode::UnknownField(field.to_string()), 0, 0)
-    }
-
-    fn missing_field(field: &'static str) -> Error {
-        Error::MissingFieldError(field)
-    }
-}
-
-/// Helper alias for `Result` objects that return a JSON `Error`.
-pub type Result<T> = result::Result<T, Error>;

serde_json/src/lib.rs

@@ -1,122 +0,0 @@
-//! JSON and serialization
-//!
-//! # What is JSON?
-//!
-//! JSON (JavaScript Object Notation) is a way to write data in JavaScript.  Like XML, it allows to
-//! encode structured data in a text format that can be easily read by humans.  Its simple syntax
-//! and native compatibility with JavaScript have made it a widely used format.
-//!
-//! Data types that can be encoded are JavaScript types (see the `serde_json:Value` enum for more
-//! details):
-//!
-//! * `Boolean`: equivalent to rust's `bool`
-//! * `I64`: equivalent to rust's `i64`
-//! * `U64`: equivalent to rust's `u64`
-//! * `F64`: equivalent to rust's `i64`
-//! * `String`: equivalent to rust's `String`
-//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the
-//!    same array
-//! * `Object`: equivalent to rust's `BTreeMap<String, serde_json::Value>`
-//! * `Null`
-//!
-//! An object is a series of string keys mapping to values, in `"key": value` format.  Arrays are
-//! enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).  A simple JSON
-//! document encoding a person, his/her age, address and phone numbers could look like
-//!
-//! ```ignore
-//! {
-//!     "FirstName": "John",
-//!     "LastName": "Doe",
-//!     "Age": 43,
-//!     "Address": {
-//!         "Street": "Downing Street 10",
-//!         "City": "London",
-//!         "Country": "Great Britain"
-//!     },
-//!     "PhoneNumbers": [
-//!         "+44 1234567",
-//!         "+44 2345678"
-//!     ]
-//! }
-//! ```
-//!
-//! # Type-based Serialization and Deserialization
-//!
-//! Serde provides a mechanism for low boilerplate serialization & deserialization of values to and
-//! from JSON via the serialization API.  To be able to serialize a piece of data, it must implement
-//! the `serde::Serialize` trait.  To be able to deserialize a piece of data, it must implement the
-//! `serde::Deserialize` trait.  Serde provides provides an annotation to automatically generate
-//! the code for these traits: `#[derive(Serialize, Deserialize)]`.
-//!
-//! The JSON API also provides an enum `serde_json::Value` and a method `to_value` to serialize
-//! objects.  A `serde_json::Value` value can be serialized as a string or buffer using the
-//! functions described above.  You can also use the `json::Serializer` object, which implements the
-//! `Serializer` trait.
-//!
-//! # Examples of use
-//!
-//! ## Parsing a `str` to `Value` and reading the result
-//!
-//! ```rust
-//! //#![feature(custom_derive, plugin)]
-//! //#![plugin(serde_macros)]
-//!
-//! extern crate serde_json;
-//!
-//! use serde_json::Value;
-//!
-//! fn main() {
-//!     let data: Value = serde_json::from_str("{\"foo\": 13, \"bar\": \"baz\"}").unwrap();
-//!     println!("data: {:?}", data);
-//!     // data: {"bar":"baz","foo":13}
-//!     println!("object? {}", data.is_object());
-//!     // object? true
-//!
-//!     let obj = data.as_object().unwrap();
-//!     let foo = obj.get("foo").unwrap();
-//!
-//!     println!("array? {:?}", foo.as_array());
-//!     // array? None
-//!     println!("u64? {:?}", foo.as_u64());
-//!     // u64? Some(13u64)
-//!
-//!     for (key, value) in obj.iter() {
-//!         println!("{}: {}", key, match *value {
-//!             Value::U64(v) => format!("{} (u64)", v),
-//!             Value::String(ref v) => format!("{} (string)", v),
-//!             _ => format!("other")
-//!         });
-//!     }
-//!     // bar: baz (string)
-//!     // foo: 13 (u64)
-//! }
-//! ```
-
-extern crate num;
-extern crate serde;
-
-pub use self::de::{
-    Deserializer,
-    from_iter,
-    from_reader,
-    from_slice,
-    from_str,
-};
-pub use self::error::{Error, ErrorCode, Result};
-pub use self::ser::{
-    Serializer,
-    to_writer,
-    to_writer_pretty,
-    to_vec,
-    to_vec_pretty,
-    to_string,
-    to_string_pretty,
-    escape_str,
-};
-pub use self::value::{Value, to_value, from_value};
-
-pub mod builder;
-pub mod de;
-pub mod error;
-pub mod ser;
-pub mod value;

serde_json/src/ser.rs

@@ -1,556 +0,0 @@
-use std::io;
-use std::num::FpCategory;
-use std::string::FromUtf8Error;
-
-use serde::ser;
-
-/// A structure for implementing serialization to JSON.
-pub struct Serializer<W, F=CompactFormatter> {
-    writer: W,
-    formatter: F,
-
-    /// `first` is used to signify if we should print a comma when we are walking through a
-    /// sequence.
-    first: bool,
-}
-
-impl<W> Serializer<W>
-    where W: io::Write,
-{
-    /// Creates a new JSON serializer.
-    #[inline]
-    pub fn new(writer: W) -> Self {
-        Serializer::with_formatter(writer, CompactFormatter)
-    }
-}
-
-impl<'a, W> Serializer<W, PrettyFormatter<'a>>
-    where W: io::Write,
-{
-    /// Creates a new JSON pretty print serializer.
-    #[inline]
-    pub fn pretty(writer: W) -> Self {
-        Serializer::with_formatter(writer, PrettyFormatter::new())
-    }
-}
-
-impl<W, F> Serializer<W, F>
-    where W: io::Write,
-          F: Formatter,
-{
-    /// Creates a new JSON visitor whose output will be written to the writer
-    /// specified.
-    #[inline]
-    pub fn with_formatter(writer: W, formatter: F) -> Self {
-        Serializer {
-            writer: writer,
-            formatter: formatter,
-            first: false,
-        }
-    }
-
-    /// Unwrap the `Writer` from the `Serializer`.
-    #[inline]
-    pub fn into_inner(self) -> W {
-        self.writer
-    }
-}
-
-impl<W, F> ser::Serializer for Serializer<W, F>
-    where W: io::Write,
-          F: Formatter,
-{
-    type Error = io::Error;
-
-    #[inline]
-    fn visit_bool(&mut self, value: bool) -> io::Result<()> {
-        if value {
-            self.writer.write_all(b"true")
-        } else {
-            self.writer.write_all(b"false")
-        }
-    }
-
-    #[inline]
-    fn visit_isize(&mut self, value: isize) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i8(&mut self, value: i8) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i16(&mut self, value: i16) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i32(&mut self, value: i32) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i64(&mut self, value: i64) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_usize(&mut self, value: usize) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u8(&mut self, value: u8) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u16(&mut self, value: u16) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u32(&mut self, value: u32) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u64(&mut self, value: u64) -> io::Result<()> {
-        write!(&mut self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_f32(&mut self, value: f32) -> io::Result<()> {
-        fmt_f32_or_null(&mut self.writer, value)
-    }
-
-    #[inline]
-    fn visit_f64(&mut self, value: f64) -> io::Result<()> {
-        fmt_f64_or_null(&mut self.writer, value)
-    }
-
-    #[inline]
-    fn visit_char(&mut self, value: char) -> io::Result<()> {
-        escape_char(&mut self.writer, value)
-    }
-
-    #[inline]
-    fn visit_str(&mut self, value: &str) -> io::Result<()> {
-        escape_str(&mut self.writer, value)
-    }
-
-    #[inline]
-    fn visit_none(&mut self) -> io::Result<()> {
-        self.visit_unit()
-    }
-
-    #[inline]
-    fn visit_some<V>(&mut self, value: V) -> io::Result<()>
-        where V: ser::Serialize
-    {
-        value.serialize(self)
-    }
-
-    #[inline]
-    fn visit_unit(&mut self) -> io::Result<()> {
-        self.writer.write_all(b"null")
-    }
-
-    /// Override `visit_newtype_struct` to serialize newtypes without an object wrapper.
-    #[inline]
-    fn visit_newtype_struct<T>(&mut self,
-                               _name: &'static str,
-                               value: T) -> Result<(), Self::Error>
-        where T: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    #[inline]
-    fn visit_unit_variant(&mut self,
-                          _name: &str,
-                          _variant_index: usize,
-                          variant: &str) -> io::Result<()> {
-        try!(self.formatter.open(&mut self.writer, b'{'));
-        try!(self.formatter.comma(&mut self.writer, true));
-        try!(self.visit_str(variant));
-        try!(self.formatter.colon(&mut self.writer));
-        try!(self.writer.write_all(b"[]"));
-        self.formatter.close(&mut self.writer, b'}')
-    }
-
-    #[inline]
-    fn visit_newtype_variant<T>(&mut self,
-                                _name: &str,
-                                _variant_index: usize,
-                                variant: &str,
-                                value: T) -> io::Result<()>
-        where T: ser::Serialize,
-    {
-        try!(self.formatter.open(&mut self.writer, b'{'));
-        try!(self.formatter.comma(&mut self.writer, true));
-        try!(self.visit_str(variant));
-        try!(self.formatter.colon(&mut self.writer));
-        try!(value.serialize(self));
-        self.formatter.close(&mut self.writer, b'}')
-    }
-
-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> io::Result<()>
-        where V: ser::SeqVisitor,
-    {
-        match visitor.len() {
-            Some(len) if len == 0 => {
-                self.writer.write_all(b"[]")
-            }
-            _ => {
-                try!(self.formatter.open(&mut self.writer, b'['));
-
-                self.first = true;
-
-                while let Some(()) = try!(visitor.visit(self)) { }
-
-                self.formatter.close(&mut self.writer, b']')
-            }
-        }
-
-    }
-
-    #[inline]
-    fn visit_tuple_variant<V>(&mut self,
-                              _name: &str,
-                              _variant_index: usize,
-                              variant: &str,
-                              visitor: V) -> io::Result<()>
-        where V: ser::SeqVisitor,
-    {
-        try!(self.formatter.open(&mut self.writer, b'{'));
-        try!(self.formatter.comma(&mut self.writer, true));
-        try!(self.visit_str(variant));
-        try!(self.formatter.colon(&mut self.writer));
-        try!(self.visit_seq(visitor));
-        self.formatter.close(&mut self.writer, b'}')
-    }
-
-    #[inline]
-    fn visit_seq_elt<T>(&mut self, value: T) -> io::Result<()>
-        where T: ser::Serialize,
-    {
-        try!(self.formatter.comma(&mut self.writer, self.first));
-        try!(value.serialize(self));
-
-        self.first = false;
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_map<V>(&mut self, mut visitor: V) -> io::Result<()>
-        where V: ser::MapVisitor,
-    {
-        match visitor.len() {
-            Some(len) if len == 0 => {
-                self.writer.write_all(b"{}")
-            }
-            _ => {
-                try!(self.formatter.open(&mut self.writer, b'{'));
-
-                self.first = true;
-
-                while let Some(()) = try!(visitor.visit(self)) { }
-
-                self.formatter.close(&mut self.writer, b'}')
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_struct_variant<V>(&mut self,
-                               _name: &str,
-                               _variant_index: usize,
-                               variant: &str,
-                               visitor: V) -> io::Result<()>
-        where V: ser::MapVisitor,
-    {
-        try!(self.formatter.open(&mut self.writer, b'{'));
-        try!(self.formatter.comma(&mut self.writer, true));
-        try!(self.visit_str(variant));
-        try!(self.formatter.colon(&mut self.writer));
-        try!(self.visit_map(visitor));
-
-        self.formatter.close(&mut self.writer, b'}')
-    }
-
-    #[inline]
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> io::Result<()>
-        where K: ser::Serialize,
-              V: ser::Serialize,
-    {
-        try!(self.formatter.comma(&mut self.writer, self.first));
-
-        try!(key.serialize(self));
-        try!(self.formatter.colon(&mut self.writer));
-        try!(value.serialize(self));
-
-        self.first = false;
-
-        Ok(())
-    }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
-}
-
-pub trait Formatter {
-    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write;
-
-    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-        where W: io::Write;
-
-    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
-        where W: io::Write;
-
-    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write;
-}
-
-pub struct CompactFormatter;
-
-impl Formatter for CompactFormatter {
-    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write,
-    {
-        writer.write_all(&[ch])
-    }
-
-    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-        where W: io::Write,
-    {
-        if first {
-            Ok(())
-        } else {
-            writer.write_all(b",")
-        }
-    }
-
-    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
-        where W: io::Write,
-    {
-        writer.write_all(b":")
-    }
-
-    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write,
-    {
-        writer.write_all(&[ch])
-    }
-}
-
-pub struct PrettyFormatter<'a> {
-    current_indent: usize,
-    indent: &'a [u8],
-}
-
-impl<'a> PrettyFormatter<'a> {
-    fn new() -> Self {
-        PrettyFormatter::with_indent(b"  ")
-    }
-
-    fn with_indent(indent: &'a [u8]) -> Self {
-        PrettyFormatter {
-            current_indent: 0,
-            indent: indent,
-        }
-    }
-}
-
-impl<'a> Formatter for PrettyFormatter<'a> {
-    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write,
-    {
-        self.current_indent += 1;
-        writer.write_all(&[ch])
-    }
-
-    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
-        where W: io::Write,
-    {
-        if first {
-            try!(writer.write_all(b"\n"));
-        } else {
-            try!(writer.write_all(b",\n"));
-        }
-
-        indent(writer, self.current_indent, self.indent)
-    }
-
-    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
-        where W: io::Write,
-    {
-        writer.write_all(b": ")
-    }
-
-    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
-        where W: io::Write,
-    {
-        self.current_indent -= 1;
-        try!(writer.write(b"\n"));
-        try!(indent(writer, self.current_indent, self.indent));
-
-        writer.write_all(&[ch])
-    }
-}
-
-#[inline]
-pub fn escape_bytes<W>(wr: &mut W, bytes: &[u8]) -> io::Result<()>
-    where W: io::Write
-{
-    try!(wr.write_all(b"\""));
-
-    let mut start = 0;
-
-    for (i, byte) in bytes.iter().enumerate() {
-        let escaped = match *byte {
-            b'"' => b"\\\"",
-            b'\\' => b"\\\\",
-            b'\x08' => b"\\b",
-            b'\x0c' => b"\\f",
-            b'\n' => b"\\n",
-            b'\r' => b"\\r",
-            b'\t' => b"\\t",
-            _ => { continue; }
-        };
-
-        if start < i {
-            try!(wr.write_all(&bytes[start..i]));
-        }
-
-        try!(wr.write_all(escaped));
-
-        start = i + 1;
-    }
-
-    if start != bytes.len() {
-        try!(wr.write_all(&bytes[start..]));
-    }
-
-    try!(wr.write_all(b"\""));
-    Ok(())
-}
-
-#[inline]
-pub fn escape_str<W>(wr: &mut W, value: &str) -> io::Result<()>
-    where W: io::Write
-{
-    escape_bytes(wr, value.as_bytes())
-}
-
-#[inline]
-fn escape_char<W>(wr: &mut W, value: char) -> io::Result<()>
-    where W: io::Write
-{
-    // FIXME: this allocation is required in order to be compatible with stable
-    // rust, which doesn't support encoding a `char` into a stack buffer.
-    escape_bytes(wr, value.to_string().as_bytes())
-}
-
-fn fmt_f32_or_null<W>(wr: &mut W, value: f32) -> io::Result<()>
-    where W: io::Write
-{
-    match value.classify() {
-        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
-        _ => {
-            write!(wr, "{:?}", value)
-        }
-    }
-}
-
-fn fmt_f64_or_null<W>(wr: &mut W, value: f64) -> io::Result<()>
-    where W: io::Write
-{
-    match value.classify() {
-        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
-        _ => {
-            write!(wr, "{:?}", value)
-        }
-    }
-}
-
-/// Encode the specified struct into a json `[u8]` writer.
-#[inline]
-pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
-    where W: io::Write,
-          T: ser::Serialize,
-{
-    let mut ser = Serializer::new(writer);
-    try!(value.serialize(&mut ser));
-    Ok(())
-}
-
-/// Encode the specified struct into a json `[u8]` writer.
-#[inline]
-pub fn to_writer_pretty<W, T>(writer: &mut W, value: &T) -> io::Result<()>
-    where W: io::Write,
-          T: ser::Serialize,
-{
-    let mut ser = Serializer::pretty(writer);
-    try!(value.serialize(&mut ser));
-    Ok(())
-}
-
-/// Encode the specified struct into a json `[u8]` buffer.
-#[inline]
-pub fn to_vec<T>(value: &T) -> Vec<u8>
-    where T: ser::Serialize,
-{
-    // We are writing to a Vec, which doesn't fail. So we can ignore
-    // the error.
-    let mut writer = Vec::with_capacity(128);
-    to_writer(&mut writer, value).unwrap();
-    writer
-}
-
-/// Encode the specified struct into a json `[u8]` buffer.
-#[inline]
-pub fn to_vec_pretty<T>(value: &T) -> Vec<u8>
-    where T: ser::Serialize,
-{
-    // We are writing to a Vec, which doesn't fail. So we can ignore
-    // the error.
-    let mut writer = Vec::with_capacity(128);
-    to_writer_pretty(&mut writer, value).unwrap();
-    writer
-}
-
-/// Encode the specified struct into a json `String` buffer.
-#[inline]
-pub fn to_string<T>(value: &T) -> Result<String, FromUtf8Error>
-    where T: ser::Serialize
-{
-    let vec = to_vec(value);
-    String::from_utf8(vec)
-}
-
-/// Encode the specified struct into a json `String` buffer.
-#[inline]
-pub fn to_string_pretty<T>(value: &T) -> Result<String, FromUtf8Error>
-    where T: ser::Serialize
-{
-    let vec = to_vec_pretty(value);
-    String::from_utf8(vec)
-}
-
-fn indent<W>(wr: &mut W, n: usize, s: &[u8]) -> io::Result<()>
-    where W: io::Write,
-{
-    for _ in 0 .. n {
-        try!(wr.write_all(s));
-    }
-
-    Ok(())
-}

serde_json/src/value.rs

@@ -1,951 +0,0 @@
-use std::collections::{BTreeMap, btree_map};
-use std::fmt;
-use std::io;
-use std::str;
-use std::vec;
-
-use num::NumCast;
-
-use serde::de;
-use serde::ser;
-
-use error::Error;
-
-#[derive(Clone, PartialEq)]
-pub enum Value {
-    Null,
-    Bool(bool),
-    I64(i64),
-    U64(u64),
-    F64(f64),
-    String(String),
-    Array(Vec<Value>),
-    Object(BTreeMap<String, Value>),
-}
-
-impl Value {
-    /// If the `Value` is an Object, returns the value associated with the provided key.
-    /// Otherwise, returns None.
-    pub fn find<'a>(&'a self, key: &str) -> Option<&'a Value>{
-        match self {
-            &Value::Object(ref map) => map.get(key),
-            _ => None
-        }
-    }
-
-    /// Attempts to get a nested Value Object for each key in `keys`.
-    /// If any key is found not to exist, find_path will return None.
-    /// Otherwise, it will return the `Value` associated with the final key.
-    pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Value>{
-        let mut target = self;
-        for key in keys {
-            match target.find(key) {
-                Some(t) => { target = t; },
-                None => return None
-            }
-        }
-        Some(target)
-    }
-
-    /// Looks up a value by path.
-    ///
-    /// This is a convenience method that splits the path by `'.'`
-    /// and then feeds the sequence of keys into the `find_path`
-    /// method.
-    ///
-    /// ``` ignore
-    /// let obj: Value = json::from_str(r#"{"x": {"a": 1}}"#).unwrap();
-    ///
-    /// assert!(obj.lookup("x.a").unwrap() == &Value::U64(1));
-    /// ```
-    pub fn lookup<'a>(&'a self, path: &str) -> Option<&'a Value> {
-        let mut target = self;
-        for key in path.split('.') {
-            match target.find(key) {
-                Some(t) => { target = t; },
-                None => return None
-            }
-        }
-        Some(target)
-    }
-
-    /// If the `Value` is an Object, performs a depth-first search until
-    /// a value associated with the provided key is found. If no value is found
-    /// or the `Value` is not an Object, returns None.
-    pub fn search<'a>(&'a self, key: &str) -> Option<&'a Value> {
-        match self {
-            &Value::Object(ref map) => {
-                match map.get(key) {
-                    Some(json_value) => Some(json_value),
-                    None => {
-                        for (_, v) in map.iter() {
-                            match v.search(key) {
-                                x if x.is_some() => return x,
-                                _ => ()
-                            }
-                        }
-                        None
-                    }
-                }
-            },
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is an Object. Returns false otherwise.
-    pub fn is_object<'a>(&'a self) -> bool {
-        self.as_object().is_some()
-    }
-
-    /// If the `Value` is an Object, returns the associated BTreeMap.
-    /// Returns None otherwise.
-    pub fn as_object<'a>(&'a self) -> Option<&'a BTreeMap<String, Value>> {
-        match self {
-            &Value::Object(ref map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// If the `Value` is an Object, returns the associated mutable BTreeMap.
-    /// Returns None otherwise.
-    pub fn as_object_mut<'a>(&'a mut self) -> Option<&'a mut BTreeMap<String, Value>> {
-        match self {
-            &mut Value::Object(ref mut map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is an Array. Returns false otherwise.
-    pub fn is_array<'a>(&'a self) -> bool {
-        self.as_array().is_some()
-    }
-
-    /// If the `Value` is an Array, returns the associated vector.
-    /// Returns None otherwise.
-    pub fn as_array<'a>(&'a self) -> Option<&'a Vec<Value>> {
-        match self {
-            &Value::Array(ref array) => Some(&*array),
-            _ => None
-        }
-    }
-
-    /// If the `Value` is an Array, returns the associated mutable vector.
-    /// Returns None otherwise.
-    pub fn as_array_mut<'a>(&'a mut self) -> Option<&'a mut Vec<Value>> {
-        match self {
-            &mut Value::Array(ref mut list) => Some(list),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is a String. Returns false otherwise.
-    pub fn is_string<'a>(&'a self) -> bool {
-        self.as_string().is_some()
-    }
-
-    /// If the `Value` is a String, returns the associated str.
-    /// Returns None otherwise.
-    pub fn as_string<'a>(&'a self) -> Option<&'a str> {
-        match *self {
-            Value::String(ref s) => Some(&s),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is a Number. Returns false otherwise.
-    pub fn is_number(&self) -> bool {
-        match *self {
-            Value::I64(_) | Value::U64(_) | Value::F64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is a i64. Returns false otherwise.
-    pub fn is_i64(&self) -> bool {
-        match *self {
-            Value::I64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is a u64. Returns false otherwise.
-    pub fn is_u64(&self) -> bool {
-        match *self {
-            Value::U64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is a f64. Returns false otherwise.
-    pub fn is_f64(&self) -> bool {
-        match *self {
-            Value::F64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// If the `Value` is a number, return or cast it to a i64.
-    /// Returns None otherwise.
-    pub fn as_i64(&self) -> Option<i64> {
-        match *self {
-            Value::I64(n) => Some(n),
-            Value::U64(n) => NumCast::from(n),
-            _ => None
-        }
-    }
-
-    /// If the `Value` is a number, return or cast it to a u64.
-    /// Returns None otherwise.
-    pub fn as_u64(&self) -> Option<u64> {
-        match *self {
-            Value::I64(n) => NumCast::from(n),
-            Value::U64(n) => Some(n),
-            _ => None
-        }
-    }
-
-    /// If the `Value` is a number, return or cast it to a f64.
-    /// Returns None otherwise.
-    pub fn as_f64(&self) -> Option<f64> {
-        match *self {
-            Value::I64(n) => NumCast::from(n),
-            Value::U64(n) => NumCast::from(n),
-            Value::F64(n) => Some(n),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is a Boolean. Returns false otherwise.
-    pub fn is_boolean(&self) -> bool {
-        self.as_boolean().is_some()
-    }
-
-    /// If the `Value` is a Boolean, returns the associated bool.
-    /// Returns None otherwise.
-    pub fn as_boolean(&self) -> Option<bool> {
-        match self {
-            &Value::Bool(b) => Some(b),
-            _ => None
-        }
-    }
-
-    /// Returns true if the `Value` is a Null. Returns false otherwise.
-    pub fn is_null(&self) -> bool {
-        self.as_null().is_some()
-    }
-
-    /// If the `Value` is a Null, returns ().
-    /// Returns None otherwise.
-    pub fn as_null(&self) -> Option<()> {
-        match self {
-            &Value::Null => Some(()),
-            _ => None
-        }
-    }
-}
-
-impl ser::Serialize for Value {
-    #[inline]
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-        where S: ser::Serializer,
-    {
-        match *self {
-            Value::Null => serializer.visit_unit(),
-            Value::Bool(v) => serializer.visit_bool(v),
-            Value::I64(v) => serializer.visit_i64(v),
-            Value::U64(v) => serializer.visit_u64(v),
-            Value::F64(v) => serializer.visit_f64(v),
-            Value::String(ref v) => serializer.visit_str(&v),
-            Value::Array(ref v) => v.serialize(serializer),
-            Value::Object(ref v) => v.serialize(serializer),
-        }
-    }
-}
-
-impl de::Deserialize for Value {
-    #[inline]
-    fn deserialize<D>(deserializer: &mut D) -> Result<Value, D::Error>
-        where D: de::Deserializer,
-    {
-        struct ValueVisitor;
-
-        impl de::Visitor for ValueVisitor {
-            type Value = Value;
-
-            #[inline]
-            fn visit_bool<E>(&mut self, value: bool) -> Result<Value, E> {
-                Ok(Value::Bool(value))
-            }
-
-            #[inline]
-            fn visit_i64<E>(&mut self, value: i64) -> Result<Value, E> {
-                if value < 0 {
-                    Ok(Value::I64(value))
-                } else {
-                    Ok(Value::U64(value as u64))
-                }
-            }
-
-            #[inline]
-            fn visit_u64<E>(&mut self, value: u64) -> Result<Value, E> {
-                Ok(Value::U64(value))
-            }
-
-            #[inline]
-            fn visit_f64<E>(&mut self, value: f64) -> Result<Value, E> {
-                Ok(Value::F64(value))
-            }
-
-            #[inline]
-            fn visit_str<E>(&mut self, value: &str) -> Result<Value, E>
-                where E: de::Error,
-            {
-                self.visit_string(value.to_string())
-            }
-
-            #[inline]
-            fn visit_string<E>(&mut self, value: String) -> Result<Value, E> {
-                Ok(Value::String(value))
-            }
-
-            #[inline]
-            fn visit_none<E>(&mut self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Value, D::Error>
-                where D: de::Deserializer,
-            {
-                de::Deserialize::deserialize(deserializer)
-            }
-
-            #[inline]
-            fn visit_unit<E>(&mut self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_seq<V>(&mut self, visitor: V) -> Result<Value, V::Error>
-                where V: de::SeqVisitor,
-            {
-                let values = try!(de::impls::VecVisitor::new().visit_seq(visitor));
-                Ok(Value::Array(values))
-            }
-
-            #[inline]
-            fn visit_map<V>(&mut self, visitor: V) -> Result<Value, V::Error>
-                where V: de::MapVisitor,
-            {
-                let values = try!(de::impls::BTreeMapVisitor::new().visit_map(visitor));
-                Ok(Value::Object(values))
-            }
-        }
-
-        deserializer.visit(ValueVisitor)
-    }
-}
-
-struct WriterFormatter<'a, 'b: 'a> {
-    inner: &'a mut fmt::Formatter<'b>,
-}
-
-impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        match self.inner.write_str(str::from_utf8(buf).unwrap()) {
-            Ok(_) => Ok(buf.len()),
-            Err(_) => Err(io::Error::last_os_error()),
-        }
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl fmt::Debug for Value {
-    /// Serializes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut wr = WriterFormatter { inner: f };
-        super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
-    }
-}
-
-#[derive(Debug)]
-enum State {
-    Value(Value),
-    Array(Vec<Value>),
-    Object(BTreeMap<String, Value>),
-}
-
-pub struct Serializer {
-    state: Vec<State>,
-}
-
-impl Serializer {
-    pub fn new() -> Serializer {
-        Serializer {
-            state: Vec::with_capacity(4),
-        }
-    }
-
-    pub fn unwrap(mut self) -> Value {
-        match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        }
-    }
-}
-
-impl ser::Serializer for Serializer {
-    type Error = ();
-
-    #[inline]
-    fn visit_bool(&mut self, value: bool) -> Result<(), ()> {
-        self.state.push(State::Value(Value::Bool(value)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_i64(&mut self, value: i64) -> Result<(), ()> {
-        if value < 0 {
-            self.state.push(State::Value(Value::I64(value)));
-        } else {
-            self.state.push(State::Value(Value::U64(value as u64)));
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_u64(&mut self, value: u64) -> Result<(), ()> {
-        self.state.push(State::Value(Value::U64(value)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_f64(&mut self, value: f64) -> Result<(), ()> {
-        self.state.push(State::Value(Value::F64(value as f64)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_char(&mut self, value: char) -> Result<(), ()> {
-        self.state.push(State::Value(Value::String(value.to_string())));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_str(&mut self, value: &str) -> Result<(), ()> {
-        self.state.push(State::Value(Value::String(value.to_string())));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_none(&mut self) -> Result<(), ()> {
-        self.visit_unit()
-    }
-
-    #[inline]
-    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
-        where V: ser::Serialize,
-    {
-        value.serialize(self)
-    }
-
-    #[inline]
-    fn visit_unit(&mut self) -> Result<(), ()> {
-        self.state.push(State::Value(Value::Null));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_unit_variant(&mut self,
-                          _name: &str,
-                          _variant_index: usize,
-                          variant: &str) -> Result<(), ()> {
-        let mut values = BTreeMap::new();
-        values.insert(variant.to_string(), Value::Array(vec![]));
-
-        self.state.push(State::Value(Value::Object(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_newtype_variant<T>(&mut self,
-                                _name: &str,
-                                _variant_index: usize,
-                                variant: &str,
-                                value: T) -> Result<(), ()>
-        where T: ser::Serialize,
-    {
-        let mut values = BTreeMap::new();
-        values.insert(variant.to_string(), to_value(&value));
-
-        self.state.push(State::Value(Value::Object(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: ser::SeqVisitor,
-    {
-        let len = visitor.len().unwrap_or(0);
-        let values = Vec::with_capacity(len);
-
-        self.state.push(State::Array(values));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        let values = match self.state.pop().unwrap() {
-            State::Array(values) => values,
-            state => panic!("Expected array, found {:?}", state),
-        };
-
-        self.state.push(State::Value(Value::Array(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_tuple_variant<V>(&mut self,
-                              _name: &str,
-                              _variant_index: usize,
-                              variant: &str,
-                              visitor: V) -> Result<(), ()>
-        where V: ser::SeqVisitor,
-    {
-        try!(self.visit_seq(visitor));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        let mut object = BTreeMap::new();
-
-        object.insert(variant.to_string(), value);
-
-        self.state.push(State::Value(Value::Object(object)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
-        where T: ser::Serialize,
-    {
-        try!(value.serialize(self));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        match *self.state.last_mut().unwrap() {
-            State::Array(ref mut values) => { values.push(value); }
-            ref state => panic!("expected array, found {:?}", state),
-        }
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: ser::MapVisitor,
-    {
-        let values = BTreeMap::new();
-
-        self.state.push(State::Object(values));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        let values = match self.state.pop().unwrap() {
-            State::Object(values) => values,
-            state => panic!("expected object, found {:?}", state),
-        };
-
-        self.state.push(State::Value(Value::Object(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_struct_variant<V>(&mut self,
-                               _name: &str,
-                               _variant_index: usize,
-                               variant: &str,
-                               visitor: V) -> Result<(), ()>
-        where V: ser::MapVisitor,
-    {
-        try!(self.visit_map(visitor));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        let mut object = BTreeMap::new();
-
-        object.insert(variant.to_string(), value);
-
-        self.state.push(State::Value(Value::Object(object)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
-        where K: ser::Serialize,
-              V: ser::Serialize,
-    {
-        try!(key.serialize(self));
-
-        let key = match self.state.pop().unwrap() {
-            State::Value(Value::String(value)) => value,
-            state => panic!("expected key, found {:?}", state),
-        };
-
-        try!(value.serialize(self));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        match *self.state.last_mut().unwrap() {
-            State::Object(ref mut values) => { values.insert(key, value); }
-            ref state => panic!("expected object, found {:?}", state),
-        }
-
-        Ok(())
-    }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
-}
-
-pub struct Deserializer {
-    value: Option<Value>,
-}
-
-impl Deserializer {
-    /// Creates a new deserializer instance for deserializing the specified JSON value.
-    pub fn new(value: Value) -> Deserializer {
-        Deserializer {
-            value: Some(value),
-        }
-    }
-}
-
-impl de::Deserializer for Deserializer {
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        let value = match self.value.take() {
-            Some(value) => value,
-            None => { return Err(de::Error::end_of_stream()); }
-        };
-
-        match value {
-            Value::Null => visitor.visit_unit(),
-            Value::Bool(v) => visitor.visit_bool(v),
-            Value::I64(v) => visitor.visit_i64(v),
-            Value::U64(v) => visitor.visit_u64(v),
-            Value::F64(v) => visitor.visit_f64(v),
-            Value::String(v) => visitor.visit_string(v),
-            Value::Array(v) => {
-                let len = v.len();
-                visitor.visit_seq(SeqDeserializer {
-                    de: self,
-                    iter: v.into_iter(),
-                    len: len,
-                })
-            }
-            Value::Object(v) => {
-                let len = v.len();
-                visitor.visit_map(MapDeserializer {
-                    de: self,
-                    iter: v.into_iter(),
-                    value: None,
-                    len: len,
-                })
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.value {
-            Some(Value::Null) => visitor.visit_none(),
-            Some(_) => visitor.visit_some(self),
-            None => Err(de::Error::end_of_stream()),
-        }
-    }
-
-    #[inline]
-    fn visit_enum<V>(&mut self,
-                     _name: &str,
-                     _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumVisitor,
-    {
-        let value = match self.value.take() {
-            Some(Value::Object(value)) => value,
-            Some(_) => { return Err(de::Error::syntax("expected an enum")); }
-            None => { return Err(de::Error::end_of_stream()); }
-        };
-
-        let mut iter = value.into_iter();
-
-        let (variant, value) = match iter.next() {
-            Some(v) => v,
-            None => return Err(de::Error::syntax("expected a variant name")),
-        };
-
-        // enums are encoded in json as maps with a single key:value pair
-        match iter.next() {
-            Some(_) => Err(de::Error::syntax("expected map")),
-            None => visitor.visit(VariantDeserializer {
-                de: self,
-                val: Some(value),
-                variant: Some(Value::String(variant)),
-            }),
-        }
-    }
-
-    #[inline]
-    fn visit_newtype_struct<V>(&mut self,
-                               _name: &'static str,
-                               mut visitor: V) -> Result<V::Value, Self::Error>
-        where V: de::Visitor,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    #[inline]
-    fn format() -> &'static str {
-        "json"
-    }
-}
-
-struct VariantDeserializer<'a> {
-    de: &'a mut Deserializer,
-    val: Option<Value>,
-    variant: Option<Value>,
-}
-
-impl<'a> de::VariantVisitor for VariantDeserializer<'a> {
-    type Error = Error;
-
-    fn visit_variant<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        de::Deserialize::deserialize(&mut Deserializer::new(self.variant.take().unwrap()))
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Error> {
-        de::Deserialize::deserialize(&mut Deserializer::new(self.val.take().unwrap()))
-    }
-
-    fn visit_newtype<T>(&mut self) -> Result<T, Error>
-        where T: de::Deserialize,
-    {
-        de::Deserialize::deserialize(&mut Deserializer::new(self.val.take().unwrap()))
-    }
-
-    fn visit_tuple<V>(&mut self,
-                      _len: usize,
-                      visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        if let Value::Array(fields) = self.val.take().unwrap() {
-            de::Deserializer::visit(
-                &mut SeqDeserializer {
-                    de: self.de,
-                    len: fields.len(),
-                    iter: fields.into_iter(),
-                },
-                visitor,
-            )
-        } else {
-            Err(de::Error::syntax("expected a tuple"))
-        }
-    }
-
-    fn visit_struct<V>(&mut self,
-                       _fields: &'static[&'static str],
-                       visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        if let Value::Object(fields) = self.val.take().unwrap() {
-            de::Deserializer::visit(
-                &mut MapDeserializer {
-                    de: self.de,
-                    len: fields.len(),
-                    iter: fields.into_iter(),
-                    value: None,
-                },
-                visitor,
-            )
-        } else {
-            Err(de::Error::syntax("expected a struct"))
-        }
-    }
-}
-
-struct SeqDeserializer<'a> {
-    de: &'a mut Deserializer,
-    iter: vec::IntoIter<Value>,
-    len: usize,
-}
-
-impl<'a> de::Deserializer for SeqDeserializer<'a> {
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        if self.len == 0 {
-            visitor.visit_unit()
-        } else {
-            visitor.visit_seq(self)
-        }
-    }
-}
-
-impl<'a> de::SeqVisitor for SeqDeserializer<'a> {
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize
-    {
-        match self.iter.next() {
-            Some(value) => {
-                self.len -= 1;
-                self.de.value = Some(value);
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        if self.len == 0 {
-            Ok(())
-        } else {
-            Err(de::Error::length_mismatch(self.len))
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-struct MapDeserializer<'a> {
-    de: &'a mut Deserializer,
-    iter: btree_map::IntoIter<String, Value>,
-    value: Option<Value>,
-    len: usize,
-}
-
-impl<'a> de::MapVisitor for MapDeserializer<'a> {
-    type Error = Error;
-
-    fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize
-    {
-        match self.iter.next() {
-            Some((key, value)) => {
-                self.len -= 1;
-                self.value = Some(value);
-                self.de.value = Some(Value::String(key));
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn visit_value<T>(&mut self) -> Result<T, Error>
-        where T: de::Deserialize
-    {
-        let value = self.value.take().unwrap();
-        self.de.value = Some(value);
-        Ok(try!(de::Deserialize::deserialize(self.de)))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        if self.len == 0 {
-            Ok(())
-        } else {
-            Err(de::Error::length_mismatch(self.len))
-        }
-    }
-
-    fn missing_field<V>(&mut self, _field: &'static str) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        // See if the type can deserialize from a unit.
-        struct UnitDeserializer;
-
-        impl de::Deserializer for UnitDeserializer {
-            type Error = Error;
-
-            fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-                where V: de::Visitor,
-            {
-                visitor.visit_unit()
-            }
-
-            fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-                where V: de::Visitor,
-            {
-                visitor.visit_none()
-            }
-        }
-
-        Ok(try!(de::Deserialize::deserialize(&mut UnitDeserializer)))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-impl<'a> de::Deserializer for MapDeserializer<'a> {
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        visitor.visit_map(self)
-    }
-}
-
-/// Shortcut function to encode a `T` into a JSON `Value`
-pub fn to_value<T>(value: &T) -> Value
-    where T: ser::Serialize
-{
-    let mut ser = Serializer::new();
-    value.serialize(&mut ser).ok().unwrap();
-    ser.unwrap()
-}
-
-/// Shortcut function to decode a JSON `Value` into a `T`
-pub fn from_value<T>(value: Value) -> Result<T, Error>
-    where T: de::Deserialize
-{
-    let mut de = Deserializer::new(value);
-    de::Deserialize::deserialize(&mut de)
-}

serde_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_macros"
-version = "0.5.1"
+version = "0.5.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -19,4 +19,3 @@ serde_codegen = { version = "*", path = "../serde_codegen", default-features = f
 num = "*"
 rustc-serialize = "*"
 serde = { version = "*", path = "../serde", features = ["nightly"] }
-serde_json = { version = "*", path = "../serde_json" }

serde_macros/benches/bench.rs

@@ -4,7 +4,6 @@
 extern crate num;
 extern crate rustc_serialize;
 extern crate serde;
-extern crate serde_json;
 extern crate test;
 
 include!("../../serde_tests/benches/bench.rs.in");

serde_macros/examples/json.rs

@@ -1,66 +0,0 @@
-#![feature(custom_derive, plugin)]
-#![plugin(serde_macros)]
-
-extern crate serde;
-extern crate serde_json;
-
-use std::collections::BTreeMap;
-
-// Creating serializable types with serde is quite simple with `serde_macros`. It implements a
-// syntax extension that automatically generates the necessary serde trait implementations.
-#[derive(Debug, Serialize, Deserialize)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-fn main() {
-    let point = Point { x: 5, y: 6 };
-
-    // Serializing to JSON is pretty simple by using the `to_string` method:
-    let serialized_point = serde_json::to_string(&point).unwrap();
-
-    println!("{}", serialized_point);
-    // prints:
-    //
-    // {"x":5,"y":6}
-
-    // There is also support for pretty printing using `to_string_pretty`:
-    let serialized_point = serde_json::to_string_pretty(&point).unwrap();
-
-    println!("{}", serialized_point);
-    // prints:
-    //
-    // {
-    //   "x":5,
-    //   "y":6
-    // }
-
-    // Values can also be deserialized with the same style using `from_str`:
-    let deserialized_point: Point = serde_json::from_str(&serialized_point).unwrap();
-
-    println!("{:?}", deserialized_point);
-    // prints:
-    //
-    // Point { x: 5, y: 6 }
-
-    // `Point`s aren't the only type that can be serialized to. Because `Point` members have the
-    // same type, they can be also serialized into a map. Also, 
-    let deserialized_map: BTreeMap<String, i64> =
-        serde_json::from_str(&serialized_point).unwrap();
-
-    println!("{:?}", deserialized_map);
-    // prints:
-    //
-    // {"x": 5, "y": 6}
-
-    // If you need to accept arbitrary data, you can also deserialize into `serde_json::Value`,
-    // which can represent all JSON values.
-    let deserialized_value: serde_json::Value =
-        serde_json::from_str(&serialized_point).unwrap();
-
-    println!("{:?}", deserialized_value);
-    // prints:
-    //
-    // {"x":5,"y":6}
-}

serde_macros/tests/test.rs

@@ -2,7 +2,6 @@
 #![plugin(serde_macros)]
 
 extern crate serde;
-extern crate serde_json;
 extern crate test;
 
 include!("../../serde_tests/tests/test.rs.in");

serde_tests/Cargo.toml

@@ -19,7 +19,6 @@ serde_codegen = { version = "*", path = "../serde_codegen", features = ["with-sy
 num = "*"
 rustc-serialize = "*"
 serde = { version = "*", path = "../serde" }
-serde_json = { version = "*", path = "../serde_json" }
 syntex = "*"
 
 [[test]]

serde_tests/benches/bench.rs

@@ -3,7 +3,6 @@
 extern crate num;
 extern crate rustc_serialize;
 extern crate serde;
-extern crate serde_json;
 extern crate test;
 
 include!(concat!(env!("OUT_DIR"), "/bench.rs"));

serde_tests/benches/bench.rs.in

@@ -1,5 +1,4 @@
 mod bench_enum;
-mod bench_log;
 mod bench_map;
 mod bench_struct;
 mod bench_vec;

serde_tests/benches/bench_map.rs

@@ -417,14 +417,14 @@ fn bench_decoder_100(b: &mut Bencher) {
     })
 }
 
-fn run_deserializer<
-    D: Deserializer<Error=E>,
-    E: Debug,
-    T: Clone + PartialEq + Debug + Deserialize
->(mut d: D, value: T) {
-    let v: T = Deserialize::deserialize(&mut d).unwrap();
+fn run_deserializer<D, T>(mut d: D, value: T)
+    where D: Deserializer,
+          D::Error: Debug + PartialEq,
+          T: Clone + PartialEq + Debug + Deserialize
+{
+    let v = T::deserialize(&mut d);
 
-    assert_eq!(value, v);
+    assert_eq!(Ok(value), v);
 }
 
 #[bench]

serde_tests/benches/bench_vec.rs

@@ -504,14 +504,14 @@ fn run_decoder<
     assert_eq!(Ok(value), v);
 }
 
-fn run_deserializer<
-    D: Deserializer<Error=E>,
-    E: Debug,
-    T: Clone + PartialEq + Debug + Deserialize
->(mut d: D, value: T) {
-    let v: T = Deserialize::deserialize(&mut d).unwrap();
+fn run_deserializer<D, T>(mut d: D, value: T)
+    where D: Deserializer,
+          D::Error: Debug + PartialEq,
+          T: Clone + PartialEq + Debug + Deserialize
+{
+    let v = T::deserialize(&mut d);
 
-    assert_eq!(value, v);
+    assert_eq!(Ok(value), v);
 }
 
 #[bench]

serde_tests/tests/macros.rs

@@ -0,0 +1,79 @@
+#[macro_export]
+macro_rules! declare_ser_tests {
+    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
+        $(
+            #[test]
+            fn $name() {
+                $(
+                    ::token::assert_ser_tokens(&$value, $tokens);
+                )+
+            }
+        )+
+    }
+}
+
+#[macro_export]
+macro_rules! btreemap {
+    () => {
+        BTreeMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = BTreeMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}
+
+macro_rules! btreeset {
+    () => {
+        BTreeSet::new()
+    };
+    ($($value:expr),+) => {
+        {
+            let mut set = BTreeSet::new();
+            $(set.insert($value);)+
+            set
+        }
+    }
+}
+
+macro_rules! btreemap {
+    () => {
+        BTreeMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = BTreeMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}
+
+macro_rules! hashset {
+    () => {
+        HashSet::new()
+    };
+    ($($value:expr),+) => {
+        {
+            let mut set = HashSet::new();
+            $(set.insert($value);)+
+            set
+        }
+    }
+}
+
+macro_rules! hashmap {
+    () => {
+        HashMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = HashMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}

serde_tests/tests/test.rs

@@ -1,4 +1,3 @@
 extern crate serde;
-extern crate serde_json;
 
 include!(concat!(env!("OUT_DIR"), "/test.rs"));

serde_tests/tests/test.rs.in

@@ -1,7 +1,10 @@
+#[macro_use]
+mod macros;
+
+mod token;
+
 mod test_annotations;
 mod test_bytes;
 mod test_de;
-mod test_json;
-mod test_json_builder;
 mod test_macros;
 mod test_ser;

serde_tests/tests/test_annotations.rs

@@ -1,5 +1,6 @@
 use std::default;
-use serde_json;
+
+use token::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens};
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 struct Default {
@@ -18,7 +19,7 @@ struct Rename {
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 struct FormatRename {
     a1: i32,
-    #[serde(rename(xml= "a4", json="a5"))]
+    #[serde(rename(xml= "a4", token="a5"))]
     a2: i32,
 }
 
@@ -26,7 +27,7 @@ struct FormatRename {
 enum SerEnum<A> {
     Map {
         a: i8,
-        #[serde(rename(xml= "c", json="d"))]
+        #[serde(rename(xml= "c", token="d"))]
         b: A,
     },
 }
@@ -40,51 +41,131 @@ struct SkipSerializingFields<A: default::Default> {
 
 #[test]
 fn test_default() {
-    let deserialized_value: Default = serde_json::from_str(&"{\"a1\":1,\"a2\":2}").unwrap();
-    assert_eq!(deserialized_value, Default { a1: 1, a2: 2 });
+    assert_de_tokens(
+        &Default { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("Default", Some(2)),
 
-    let deserialized_value: Default = serde_json::from_str(&"{\"a1\":1}").unwrap();
-    assert_eq!(deserialized_value, Default { a1: 1, a2: 0 });
+            Token::MapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::MapSep,
+            Token::Str("a2"),
+            Token::I32(2),
+
+            Token::MapEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &Default { a1: 1, a2: 0 },
+        vec![
+            Token::StructStart("Default", Some(1)),
+
+            Token::MapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::MapEnd,
+        ]
+    );
 }
 
 #[test]
 fn test_rename() {
-    let value = Rename { a1: 1, a2: 2 };
-    let serialized_value = serde_json::to_string(&value).unwrap();
-    assert_eq!(serialized_value, "{\"a1\":1,\"a3\":2}");
+    assert_tokens(
+        &Rename { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("Rename", Some(2)),
 
-    let deserialized_value: Rename = serde_json::from_str(&serialized_value).unwrap();
-    assert_eq!(value, deserialized_value);
+            Token::MapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::MapSep,
+            Token::Str("a3"),
+            Token::I32(2),
+
+            Token::MapEnd,
+        ]
+    );
 }
 
 #[test]
 fn test_format_rename() {
-    let value = FormatRename { a1: 1, a2: 2 };
-    let serialized_value = serde_json::to_string(&value).unwrap();
-    assert_eq!(serialized_value, "{\"a1\":1,\"a5\":2}");
+    assert_tokens(
+        &FormatRename { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("FormatRename", Some(2)),
 
-    let deserialized_value = serde_json::from_str("{\"a1\":1,\"a5\":2}").unwrap();
-    assert_eq!(value, deserialized_value);
+            Token::MapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::MapSep,
+            Token::Str("a5"),
+            Token::I32(2),
+
+            Token::MapEnd,
+        ]
+    );
 }
 
 #[test]
 fn test_enum_format_rename() {
-    let s1 = String::new();
-    let value = SerEnum::Map { a: 0i8, b: s1 };
-    let serialized_value = serde_json::to_string(&value).unwrap();
-    let ans = "{\"Map\":{\"a\":0,\"d\":\"\"}}";
-    assert_eq!(serialized_value, ans);
+    assert_tokens(
+        &SerEnum::Map {
+            a: 0,
+            b: String::new(),
+        },
+        vec![
+            Token::EnumMapStart("SerEnum", "Map", Some(2)),
 
-    let deserialized_value = serde_json::from_str(ans).unwrap();
-    assert_eq!(value, deserialized_value);
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(0),
+
+            Token::MapSep,
+            Token::Str("d"),
+            Token::Str(""),
+
+            Token::MapEnd,
+        ]
+    );
 }
 
 #[test]
 fn test_skip_serializing_fields() {
-    let value = SkipSerializingFields { a: 1, b: 2 };
-    let serialized_value = serde_json::to_string(&value).unwrap();
-    assert_eq!(serialized_value, "{\"a\":1}");
+    assert_ser_tokens(
+        &SkipSerializingFields {
+            a: 1,
+            b: 2,
+        },
+        &[
+            Token::StructStart("SkipSerializingFields", Some(1)),
 
-    let deserialized_value: SkipSerializingFields<_> = serde_json::from_str(&serialized_value).unwrap();
-    assert_eq!(SkipSerializingFields { a: 1, b: 0 }, deserialized_value);
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::MapEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &SkipSerializingFields {
+            a: 1,
+            b: 0,
+        },
+        vec![
+            Token::StructStart("SkipSerializingFields", Some(1)),
+
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::MapEnd,
+        ]
+    );
 }

serde_tests/tests/test_bytes.rs

@@ -1,7 +1,6 @@
 use serde;
 use serde::Serialize;
 use serde::bytes::{ByteBuf, Bytes};
-use serde_json;
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -140,17 +139,6 @@ impl serde::Deserializer for BytesDeserializer {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[test]
-fn test_bytes_ser_json() {
-    let buf = vec![];
-    let bytes = Bytes::from(&buf);
-    assert_eq!(serde_json::to_string(&bytes).unwrap(), "[]".to_string());
-
-    let buf = vec![1, 2, 3];
-    let bytes = Bytes::from(&buf);
-    assert_eq!(serde_json::to_string(&bytes).unwrap(), "[1,2,3]".to_string());
-}
-
 #[test]
 fn test_bytes_ser_bytes() {
     let buf = vec![];
@@ -164,39 +152,8 @@ fn test_bytes_ser_bytes() {
     bytes.serialize(&mut ser).unwrap();
 }
 
-#[test]
-fn test_byte_buf_ser_json() {
-    let bytes = ByteBuf::new();
-    assert_eq!(serde_json::to_string(&bytes).unwrap(), "[]".to_string());
-
-    let bytes = ByteBuf::from(vec![1, 2, 3]);
-    assert_eq!(serde_json::to_string(&bytes).unwrap(), "[1,2,3]".to_string());
-}
-
-#[test]
-fn test_byte_buf_ser_bytes() {
-    let bytes = ByteBuf::new();
-    let mut ser = BytesSerializer::new(vec![]);
-    bytes.serialize(&mut ser).unwrap();
-
-    let bytes = ByteBuf::from(vec![1, 2, 3]);
-    let mut ser = BytesSerializer::new(vec![1, 2, 3]);
-    bytes.serialize(&mut ser).unwrap();
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
-#[test]
-fn test_byte_buf_de_json() {
-    let bytes = ByteBuf::new();
-    let v: ByteBuf = serde_json::from_str("[]").unwrap();
-    assert_eq!(v, bytes);
-
-    let bytes = ByteBuf::from(vec![1, 2, 3]);
-    let v: ByteBuf = serde_json::from_str("[1, 2, 3]").unwrap();
-    assert_eq!(v, bytes);
-}
-
 #[test]
 fn test_byte_buf_de_bytes() {
     let mut de = BytesDeserializer::new(vec![]);

serde_tests/tests/test_de.rs

@@ -1,384 +1,8 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
-use std::iter;
-use std::vec;
 
-use serde::de::{self, Deserialize, Deserializer, Visitor};
+use serde::de::{Deserializer, Visitor};
 
-#[derive(Debug)]
-enum Token {
-    Bool(bool),
-    Isize(isize),
-    I8(i8),
-    I16(i16),
-    I32(i32),
-    I64(i64),
-    Usize(usize),
-    U8(u8),
-    U16(u16),
-    U32(u32),
-    U64(u64),
-    F32(f32),
-    F64(f64),
-    Char(char),
-    Str(&'static str),
-    String(String),
-    Bytes(&'static [u8]),
-
-    Option(bool),
-
-    Name(&'static str),
-
-    Unit,
-
-    SeqStart(usize),
-    SeqSep,
-    SeqEnd,
-
-    MapStart(usize),
-    MapSep,
-    MapEnd,
-
-    EnumStart(&'static str),
-    EnumUnit,
-    EnumNewtype,
-    EnumSeq,
-    EnumMap,
-    EnumEnd,
-}
-
-struct TokenDeserializer {
-    tokens: iter::Peekable<vec::IntoIter<Token>>,
-}
-
-impl<'a> TokenDeserializer {
-    fn new(tokens: Vec<Token>) -> TokenDeserializer {
-        TokenDeserializer {
-            tokens: tokens.into_iter().peekable(),
-        }
-    }
-}
-
-#[derive(Clone, PartialEq, Debug)]
-enum Error {
-    SyntaxError,
-    EndOfStreamError,
-    UnknownFieldError(String),
-    MissingFieldError(&'static str),
-    InvalidName(&'static str),
-}
-
-impl de::Error for Error {
-    fn syntax(_: &str) -> Error { Error::SyntaxError }
-
-    fn end_of_stream() -> Error { Error::EndOfStreamError }
-
-    fn unknown_field(field: &str) -> Error {
-        Error::UnknownFieldError(field.to_string())
-    }
-
-    fn missing_field(field: &'static str) -> Error {
-        Error::MissingFieldError(field)
-    }
-}
-
-impl Deserializer for TokenDeserializer {
-    type Error = Error;
-
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: Visitor,
-    {
-        match self.tokens.next() {
-            Some(Token::Bool(v)) => visitor.visit_bool(v),
-            Some(Token::Isize(v)) => visitor.visit_isize(v),
-            Some(Token::I8(v)) => visitor.visit_i8(v),
-            Some(Token::I16(v)) => visitor.visit_i16(v),
-            Some(Token::I32(v)) => visitor.visit_i32(v),
-            Some(Token::I64(v)) => visitor.visit_i64(v),
-            Some(Token::Usize(v)) => visitor.visit_usize(v),
-            Some(Token::U8(v)) => visitor.visit_u8(v),
-            Some(Token::U16(v)) => visitor.visit_u16(v),
-            Some(Token::U32(v)) => visitor.visit_u32(v),
-            Some(Token::U64(v)) => visitor.visit_u64(v),
-            Some(Token::F32(v)) => visitor.visit_f32(v),
-            Some(Token::F64(v)) => visitor.visit_f64(v),
-            Some(Token::Char(v)) => visitor.visit_char(v),
-            Some(Token::Str(v)) => visitor.visit_str(v),
-            Some(Token::String(v)) => visitor.visit_string(v),
-            Some(Token::Bytes(v)) => visitor.visit_bytes(v),
-            Some(Token::Option(false)) => visitor.visit_none(),
-            Some(Token::Option(true)) => visitor.visit_some(self),
-            Some(Token::Unit) => visitor.visit_unit(),
-            Some(Token::SeqStart(len)) => {
-                visitor.visit_seq(TokenDeserializerSeqVisitor {
-                    de: self,
-                    len: len,
-                })
-            }
-            Some(Token::MapStart(len)) => {
-                visitor.visit_map(TokenDeserializerMapVisitor {
-                    de: self,
-                    len: len,
-                })
-            }
-            Some(Token::Name(_)) => self.visit(visitor),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    /// Hook into `Option` deserializing so we can treat `Unit` as a
-    /// `None`, or a regular value as `Some(value)`.
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: Visitor,
-    {
-        match self.tokens.peek() {
-            Some(&Token::Option(false)) => {
-                self.tokens.next();
-                visitor.visit_none()
-            }
-            Some(&Token::Option(true)) => {
-                self.tokens.next();
-                visitor.visit_some(self)
-            }
-            Some(&Token::Unit) => {
-                self.tokens.next();
-                visitor.visit_none()
-            }
-            Some(_) => visitor.visit_some(self),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_enum<V>(&mut self,
-                     name: &str,
-                     _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumVisitor,
-    {
-        match self.tokens.next() {
-            Some(Token::EnumStart(n)) => {
-                if name == n {
-                    visitor.visit(TokenDeserializerVariantVisitor {
-                        de: self,
-                    })
-                } else {
-                    Err(Error::SyntaxError)
-                }
-            }
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_unit_struct<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.tokens.peek() {
-            Some(&Token::Name(n)) => {
-                if name == n {
-                    self.tokens.next();
-                    self.visit_seq(visitor)
-                } else {
-                    Err(Error::InvalidName(n))
-                }
-            }
-            Some(_) => self.visit(visitor),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_tuple_struct<V>(&mut self,
-                             name: &str,
-                             _len: usize,
-                             visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.tokens.peek() {
-            Some(&Token::Name(n)) => {
-                if name == n {
-                    self.tokens.next();
-                    self.visit_seq(visitor)
-                } else {
-                    Err(Error::InvalidName(n))
-                }
-            }
-            Some(_) => self.visit_seq(visitor),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_struct<V>(&mut self,
-                       name: &str,
-                       _fields: &'static [&'static str],
-                       visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.tokens.peek() {
-            Some(&Token::Name(n)) => {
-                if name == n {
-                    self.tokens.next();
-                    self.visit_map(visitor)
-                } else {
-                    Err(Error::InvalidName(n))
-                }
-            }
-            Some(_) => self.visit_map(visitor),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct TokenDeserializerSeqVisitor<'a> {
-    de: &'a mut TokenDeserializer,
-    len: usize,
-}
-
-impl<'a> de::SeqVisitor for TokenDeserializerSeqVisitor<'a> {
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: Deserialize,
-    {
-        match self.de.tokens.peek() {
-            Some(&Token::SeqSep) => {
-                self.len -= 1;
-                self.de.tokens.next();
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
-            }
-            Some(&Token::SeqEnd) => Ok(None),
-            Some(_) => {
-                Err(Error::SyntaxError)
-            }
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        assert_eq!(self.len, 0);
-        match self.de.tokens.next() {
-            Some(Token::SeqEnd) => Ok(()),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct TokenDeserializerMapVisitor<'a> {
-    de: &'a mut TokenDeserializer,
-    len: usize,
-}
-
-impl<'a> de::MapVisitor for TokenDeserializerMapVisitor<'a> {
-    type Error = Error;
-
-    fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
-        where K: Deserialize,
-    {
-        match self.de.tokens.peek() {
-            Some(&Token::MapSep) => {
-                self.de.tokens.next();
-                self.len -= 1;
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
-            }
-            Some(&Token::MapEnd) => Ok(None),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_value<V>(&mut self) -> Result<V, Error>
-        where V: Deserialize,
-    {
-        Ok(try!(Deserialize::deserialize(self.de)))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        assert_eq!(self.len, 0);
-        match self.de.tokens.next() {
-            Some(Token::MapEnd) => Ok(()),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct TokenDeserializerVariantVisitor<'a> {
-    de: &'a mut TokenDeserializer,
-}
-
-impl<'a> de::VariantVisitor for TokenDeserializerVariantVisitor<'a> {
-    type Error = Error;
-
-    fn visit_variant<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        de::Deserialize::deserialize(self.de)
-    }
-
-    fn visit_unit(&mut self) -> Result<(), Error> {
-        match self.de.tokens.next() {
-            Some(Token::EnumUnit) => {
-                de::Deserialize::deserialize(self.de)
-            }
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
-        where T: de::Deserialize,
-    {
-        match self.de.tokens.next() {
-            Some(Token::EnumNewtype) => {
-                de::Deserialize::deserialize(self.de)
-            }
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_tuple<V>(&mut self,
-                      _len: usize,
-                      visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.de.tokens.next() {
-            Some(Token::EnumSeq) => {
-                de::Deserializer::visit(self.de, visitor)
-            }
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_struct<V>(&mut self,
-                       _fields: &'static [&'static str],
-                       visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.de.tokens.next() {
-            Some(Token::EnumMap) => {
-                de::Deserializer::visit(self.de, visitor)
-            }
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-}
+use token::{Token, assert_de_tokens};
 
 //////////////////////////////////////////////////////////////////////////
 
@@ -405,66 +29,12 @@ enum Enum {
 
 //////////////////////////////////////////////////////////////////////////
 
-macro_rules! btreeset {
-    () => {
-        BTreeSet::new()
-    };
-    ($($value:expr),+) => {
-        {
-            let mut set = BTreeSet::new();
-            $(set.insert($value);)+
-            set
-        }
-    }
-}
-
-macro_rules! btreemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
-
-macro_rules! hashset {
-    () => {
-        HashSet::new()
-    };
-    ($($value:expr),+) => {
-        {
-            let mut set = HashSet::new();
-            $(set.insert($value);)+
-            set
-        }
-    }
-}
-
-macro_rules! hashmap {
-    () => {
-        HashMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = HashMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
-
 macro_rules! declare_test {
     ($name:ident { $($value:expr => $tokens:expr,)+ }) => {
         #[test]
         fn $name() {
             $(
-                let mut de = TokenDeserializer::new($tokens);
-                let value: Result<_, Error> = Deserialize::deserialize(&mut de);
-                assert_eq!(value, Ok($value));
+                assert_de_tokens(&$value, $tokens);
             )+
         }
     }
@@ -539,47 +109,47 @@ declare_tests! {
     test_result {
         Ok::<i32, i32>(0) => vec![
             Token::EnumStart("Result"),
-                Token::Str("Ok"),
-
-                Token::EnumNewtype,
-                Token::I32(0),
-            Token::SeqEnd,
+            Token::Str("Ok"),
+            Token::I32(0),
         ],
         Err::<i32, i32>(1) => vec![
             Token::EnumStart("Result"),
-                Token::Str("Err"),
-
-                Token::EnumNewtype,
-                Token::I32(1),
-            Token::SeqEnd,
+            Token::Str("Err"),
+            Token::I32(1),
         ],
     }
     test_unit {
         () => vec![Token::Unit],
         () => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
         () => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::SeqStart(None),
+            Token::SeqEnd,
+        ],
+        () => vec![
+            Token::TupleStructStart("Anything", Some(0)),
             Token::SeqEnd,
         ],
     }
     test_unit_struct {
         UnitStruct => vec![Token::Unit],
         UnitStruct => vec![
-            Token::Name("UnitStruct"),
-            Token::Unit,
+            Token::UnitStruct("UnitStruct"),
         ],
         UnitStruct => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        UnitStruct => vec![
+            Token::SeqStart(None),
             Token::SeqEnd,
         ],
     }
     test_tuple_struct {
         TupleStruct(1, 2, 3) => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                 Token::SeqSep,
                 Token::I32(1),
 
@@ -591,8 +161,31 @@ declare_tests! {
             Token::SeqEnd,
         ],
         TupleStruct(1, 2, 3) => vec![
-            Token::Name("TupleStruct"),
-            Token::SeqStart(3),
+            Token::SeqStart(None),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        TupleStruct(1, 2, 3) => vec![
+            Token::TupleStructStart("TupleStruct", Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        TupleStruct(1, 2, 3) => vec![
+            Token::TupleStructStart("TupleStruct", None),
                 Token::SeqSep,
                 Token::I32(1),
 
@@ -609,23 +202,23 @@ declare_tests! {
             Token::Unit,
         ],
         BTreeSet::<isize>::new() => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
         btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                 Token::SeqSep,
-                Token::SeqStart(0),
+                Token::SeqStart(Some(0)),
                 Token::SeqEnd,
 
                 Token::SeqSep,
-                Token::SeqStart(1),
+                Token::SeqStart(Some(1)),
                     Token::SeqSep,
                     Token::I32(1),
                 Token::SeqEnd,
 
                 Token::SeqSep,
-                Token::SeqStart(2),
+                Token::SeqStart(Some(2)),
                     Token::SeqSep,
                     Token::I32(2),
 
@@ -635,12 +228,10 @@ declare_tests! {
             Token::SeqEnd,
         ],
         BTreeSet::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
         ],
         BTreeSet::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::TupleStructStart("Anything", Some(0)),
             Token::SeqEnd,
         ],
     }
@@ -649,11 +240,11 @@ declare_tests! {
             Token::Unit,
         ],
         HashSet::<isize>::new() => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
         hashset![1, 2, 3] => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                 Token::SeqSep,
                 Token::I32(1),
 
@@ -665,12 +256,10 @@ declare_tests! {
             Token::SeqEnd,
         ],
         HashSet::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
         ],
         HashSet::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::TupleStructStart("Anything", Some(0)),
             Token::SeqEnd,
         ],
     }
@@ -679,23 +268,23 @@ declare_tests! {
             Token::Unit,
         ],
         Vec::<isize>::new() => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
         vec![vec![], vec![1], vec![2, 3]] => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                 Token::SeqSep,
-                Token::SeqStart(0),
+                Token::SeqStart(Some(0)),
                 Token::SeqEnd,
 
                 Token::SeqSep,
-                Token::SeqStart(1),
+                Token::SeqStart(Some(1)),
                     Token::SeqSep,
                     Token::I32(1),
                 Token::SeqEnd,
 
                 Token::SeqSep,
-                Token::SeqStart(2),
+                Token::SeqStart(Some(2)),
                     Token::SeqSep,
                     Token::I32(2),
 
@@ -705,12 +294,10 @@ declare_tests! {
             Token::SeqEnd,
         ],
         Vec::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
         ],
         Vec::<isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::TupleStructStart("Anything", Some(0)),
             Token::SeqEnd,
         ],
     }
@@ -719,23 +306,23 @@ declare_tests! {
             Token::Unit,
         ],
         [0; 0] => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
         ([0; 0], [1], [2, 3]) => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                 Token::SeqSep,
-                Token::SeqStart(0),
+                Token::SeqStart(Some(0)),
                 Token::SeqEnd,
 
                 Token::SeqSep,
-                Token::SeqStart(1),
+                Token::SeqStart(Some(1)),
                     Token::SeqSep,
                     Token::I32(1),
                 Token::SeqEnd,
 
                 Token::SeqSep,
-                Token::SeqStart(2),
+                Token::SeqStart(Some(2)),
                     Token::SeqSep,
                     Token::I32(2),
 
@@ -745,24 +332,22 @@ declare_tests! {
             Token::SeqEnd,
         ],
         [0; 0] => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
         ],
         [0; 0] => vec![
-            Token::Name("Anything"),
-            Token::SeqStart(0),
+            Token::TupleStructStart("Anything", Some(0)),
             Token::SeqEnd,
         ],
     }
     test_tuple {
         (1,) => vec![
-            Token::SeqStart(1),
+            Token::SeqStart(Some(1)),
                 Token::SeqSep,
                 Token::I32(1),
             Token::SeqEnd,
         ],
         (1, 2, 3) => vec![
-            Token::SeqStart(3),
+            Token::SeqStart(Some(3)),
                 Token::SeqSep,
                 Token::I32(1),
 
@@ -779,18 +364,18 @@ declare_tests! {
             Token::Unit,
         ],
         BTreeMap::<isize, isize>::new() => vec![
-            Token::MapStart(0),
+            Token::MapStart(Some(0)),
             Token::MapEnd,
         ],
         btreemap![1 => 2] => vec![
-            Token::MapStart(1),
+            Token::MapStart(Some(1)),
                 Token::MapSep,
                 Token::I32(1),
                 Token::I32(2),
             Token::MapEnd,
         ],
         btreemap![1 => 2, 3 => 4] => vec![
-            Token::MapStart(2),
+            Token::MapStart(Some(2)),
                 Token::MapSep,
                 Token::I32(1),
                 Token::I32(2),
@@ -801,15 +386,15 @@ declare_tests! {
             Token::MapEnd,
         ],
         btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
-            Token::MapStart(2),
+            Token::MapStart(Some(2)),
                 Token::MapSep,
                 Token::I32(1),
-                Token::MapStart(0),
+                Token::MapStart(Some(0)),
                 Token::MapEnd,
 
                 Token::MapSep,
                 Token::I32(2),
-                Token::MapStart(2),
+                Token::MapStart(Some(2)),
                     Token::MapSep,
                     Token::I32(3),
                     Token::I32(4),
@@ -821,12 +406,10 @@ declare_tests! {
             Token::MapEnd,
         ],
         BTreeMap::<isize, isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
         ],
         BTreeMap::<isize, isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::MapStart(0),
+            Token::StructStart("Anything", Some(0)),
             Token::MapEnd,
         ],
     }
@@ -835,18 +418,18 @@ declare_tests! {
             Token::Unit,
         ],
         HashMap::<isize, isize>::new() => vec![
-            Token::MapStart(0),
+            Token::MapStart(Some(0)),
             Token::MapEnd,
         ],
         hashmap![1 => 2] => vec![
-            Token::MapStart(1),
+            Token::MapStart(Some(1)),
                 Token::MapSep,
                 Token::I32(1),
                 Token::I32(2),
             Token::MapEnd,
         ],
         hashmap![1 => 2, 3 => 4] => vec![
-            Token::MapStart(2),
+            Token::MapStart(Some(2)),
                 Token::MapSep,
                 Token::I32(1),
                 Token::I32(2),
@@ -857,15 +440,15 @@ declare_tests! {
             Token::MapEnd,
         ],
         hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => vec![
-            Token::MapStart(2),
+            Token::MapStart(Some(2)),
                 Token::MapSep,
                 Token::I32(1),
-                Token::MapStart(0),
+                Token::MapStart(Some(0)),
                 Token::MapEnd,
 
                 Token::MapSep,
                 Token::I32(2),
-                Token::MapStart(2),
+                Token::MapStart(Some(2)),
                     Token::MapSep,
                     Token::I32(3),
                     Token::I32(4),
@@ -877,18 +460,16 @@ declare_tests! {
             Token::MapEnd,
         ],
         HashMap::<isize, isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::Unit,
+            Token::UnitStruct("Anything"),
         ],
         HashMap::<isize, isize>::new() => vec![
-            Token::Name("Anything"),
-            Token::MapStart(0),
+            Token::StructStart("Anything", Some(0)),
             Token::MapEnd,
         ],
     }
     test_struct {
         Struct { a: 1, b: 2, c: 3 } => vec![
-            Token::MapStart(3),
+            Token::MapStart(Some(3)),
                 Token::MapSep,
                 Token::Str("a"),
                 Token::I32(1),
@@ -903,8 +484,7 @@ declare_tests! {
             Token::MapEnd,
         ],
         Struct { a: 1, b: 2, c: 3 } => vec![
-            Token::Name("Struct"),
-            Token::MapStart(3),
+            Token::StructStart("Struct", Some(3)),
                 Token::MapSep,
                 Token::Str("a"),
                 Token::I32(1),
@@ -921,83 +501,58 @@ declare_tests! {
     }
     test_enum_unit {
         Enum::Unit => vec![
-            Token::EnumStart("Enum"),
-                Token::Str("Unit"),
-
-                Token::EnumUnit,
-                Token::Unit,
-            Token::EnumEnd,
+            Token::EnumUnit("Enum", "Unit"),
         ],
     }
     test_enum_simple {
         Enum::Simple(1) => vec![
-            Token::EnumStart("Enum"),
-                Token::Str("Simple"),
-
-                Token::EnumNewtype,
-                Token::I32(1),
-            Token::EnumEnd,
+            Token::EnumNewtype("Enum", "Simple"),
+            Token::I32(1),
         ],
     }
     test_enum_seq {
         Enum::Seq(1, 2, 3) => vec![
-            Token::EnumStart("Enum"),
-                Token::Str("Seq"),
+            Token::EnumSeqStart("Enum", "Seq", Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
 
-                Token::EnumSeq,
-                Token::SeqStart(3),
-                    Token::SeqSep,
-                    Token::I32(1),
+                Token::SeqSep,
+                Token::I32(2),
 
-                    Token::SeqSep,
-                    Token::I32(2),
-
-                    Token::SeqSep,
-                    Token::I32(3),
-                Token::SeqEnd,
-            Token::EnumEnd,
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
         ],
     }
     test_enum_map {
         Enum::Map { a: 1, b: 2, c: 3 } => vec![
-            Token::EnumStart("Enum"),
-                Token::Str("Map"),
+            Token::EnumMapStart("Enum", "Map", Some(3)),
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(1),
 
-                Token::EnumMap,
-                Token::MapStart(3),
-                    Token::MapSep,
-                    Token::Str("a"),
-                    Token::I32(1),
+                Token::MapSep,
+                Token::Str("b"),
+                Token::I32(2),
 
-                    Token::MapSep,
-                    Token::Str("b"),
-                    Token::I32(2),
-
-                    Token::MapSep,
-                    Token::Str("c"),
-                    Token::I32(3),
-                Token::MapEnd,
-            Token::EnumEnd,
+                Token::MapSep,
+                Token::Str("c"),
+                Token::I32(3),
+            Token::MapEnd,
         ],
     }
     test_enum_unit_usize {
         Enum::Unit => vec![
             Token::EnumStart("Enum"),
-                Token::Usize(0),
-
-                Token::EnumUnit,
-                Token::Unit,
-            Token::EnumEnd,
+            Token::Usize(0),
+            Token::Unit,
         ],
     }
     test_enum_unit_bytes {
         Enum::Unit => vec![
             Token::EnumStart("Enum"),
-                Token::Bytes(b"Unit"),
-
-                Token::EnumUnit,
-                Token::Unit,
-            Token::EnumEnd,
+            Token::Bytes(b"Unit"),
+            Token::Unit,
         ],
     }
 }

serde_tests/tests/test_json_builder.rs

@@ -1,50 +0,0 @@
-use std::collections::BTreeMap;
-
-use serde_json::value::Value;
-use serde_json::builder::{ArrayBuilder, ObjectBuilder};
-
-#[test]
-fn test_array_builder() {
-    let value = ArrayBuilder::new().unwrap();
-    assert_eq!(value, Value::Array(Vec::new()));
-
-    let value = ArrayBuilder::new()
-        .push(1)
-        .push(2)
-        .push(3)
-        .unwrap();
-    assert_eq!(value, Value::Array(vec!(Value::U64(1), Value::U64(2), Value::U64(3))));
-
-    let value = ArrayBuilder::new()
-        .push_array(|bld| bld.push(1).push(2).push(3))
-        .unwrap();
-    assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::U64(1), Value::U64(2), Value::U64(3))))));
-
-    let value = ArrayBuilder::new()
-        .push_object(|bld|
-            bld
-                .insert("a".to_string(), 1)
-                .insert("b".to_string(), 2))
-        .unwrap();
-
-    let mut map = BTreeMap::new();
-    map.insert("a".to_string(), Value::U64(1));
-    map.insert("b".to_string(), Value::U64(2));
-    assert_eq!(value, Value::Array(vec!(Value::Object(map))));
-}
-
-#[test]
-fn test_object_builder() {
-    let value = ObjectBuilder::new().unwrap();
-    assert_eq!(value, Value::Object(BTreeMap::new()));
-
-    let value = ObjectBuilder::new()
-        .insert("a".to_string(), 1)
-        .insert("b".to_string(), 2)
-        .unwrap();
-
-    let mut map = BTreeMap::new();
-    map.insert("a".to_string(), Value::U64(1));
-    map.insert("b".to_string(), Value::U64(2));
-    assert_eq!(value, Value::Object(map));
-}

serde_tests/tests/test_macros.rs

@@ -1,18 +1,4 @@
-use std::collections::BTreeMap;
-use serde_json::{self, Value};
-
-macro_rules! btreemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
+use token::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens};
 
 /*
 trait Trait {
@@ -83,7 +69,7 @@ enum SerEnum<'a, B: 'a, C: /* Trait + */ 'a, D> where D: /* Trait + */ 'a {
     },
 }
 
-#[derive(Debug, PartialEq, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
 enum DeEnum<B, C: /* Trait */, D> /* where D: Trait */ {
     Unit,
     Seq(
@@ -152,23 +138,10 @@ pub enum GenericEnum<T, U> {
 
 #[test]
 fn test_named_unit() {
-    let named_unit = NamedUnit;
-
-    assert_eq!(
-        serde_json::to_string(&named_unit).unwrap(),
-        "null".to_string()
+    assert_tokens(
+        &NamedUnit,
+        vec![Token::UnitStruct("NamedUnit")]
     );
-
-    assert_eq!(
-        serde_json::to_value(&named_unit),
-        Value::Null
-    );
-
-    let v: NamedUnit = serde_json::from_str("null").unwrap();
-    assert_eq!(v, named_unit);
-
-    let v: NamedUnit = serde_json::from_value(Value::Null).unwrap();
-    assert_eq!(v, named_unit);
 }
 
 #[test]
@@ -176,35 +149,41 @@ fn test_ser_named_tuple() {
     let a = 5;
     let mut b = 6;
     let c = 7;
-    let named_tuple = SerNamedTuple(&a, &mut b, c);
+    assert_ser_tokens(
+        &SerNamedTuple(&a, &mut b, c),
+        &[
+            Token::TupleStructStart("SerNamedTuple", Some(3)),
+            Token::SeqSep,
+            Token::I32(5),
 
-    assert_eq!(
-        serde_json::to_string(&named_tuple).unwrap(),
-        "[5,6,7]"
-    );
+            Token::SeqSep,
+            Token::I32(6),
 
-    assert_eq!(
-        serde_json::to_value(&named_tuple),
-        Value::Array(vec![Value::U64(5), Value::U64(6), Value::U64(7)])
+            Token::SeqSep,
+            Token::I32(7),
+
+            Token::SeqEnd,
+        ],
     );
 }
 
 #[test]
 fn test_de_named_tuple() {
-    let v: DeNamedTuple<i32, i32, i32> = serde_json::from_str("[1,2,3]").unwrap();
-    assert_eq!(
-        v,
-        DeNamedTuple(1, 2, 3)
-    );
+    assert_de_tokens(
+        &DeNamedTuple(5, 6, 7),
+        vec![
+            Token::TupleStructStart("DeNamedTuple", Some(3)),
+            Token::SeqSep,
+            Token::I32(5),
 
-    let v: Value = serde_json::from_str("[1,2,3]").unwrap();
-    assert_eq!(
-        v,
-        Value::Array(vec![
-            Value::U64(1),
-            Value::U64(2),
-            Value::U64(3),
-        ])
+            Token::SeqSep,
+            Token::I32(6),
+
+            Token::SeqSep,
+            Token::I32(7),
+
+            Token::SeqEnd,
+        ]
     );
 }
 
@@ -213,60 +192,68 @@ fn test_ser_named_map() {
     let a = 5;
     let mut b = 6;
     let c = 7;
-    let named_map = SerNamedMap {
-        a: &a,
-        b: &mut b,
-        c: c,
-    };
 
-    assert_eq!(
-        serde_json::to_string(&named_map).unwrap(),
-        "{\"a\":5,\"b\":6,\"c\":7}"
-    );
+    assert_ser_tokens(
+        &SerNamedMap {
+            a: &a,
+            b: &mut b,
+            c: c,
+        },
+        &[
+            Token::StructStart("SerNamedMap", Some(3)),
 
-    assert_eq!(
-        serde_json::to_value(&named_map),
-        Value::Object(btreemap![
-            "a".to_string() => Value::U64(5),
-            "b".to_string() => Value::U64(6),
-            "c".to_string() => Value::U64(7)
-        ])
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::MapSep,
+            Token::Str("b"),
+            Token::I32(6),
+
+            Token::MapSep,
+            Token::Str("c"),
+            Token::I32(7),
+
+            Token::MapEnd,
+        ]
     );
 }
 
 #[test]
 fn test_de_named_map() {
-    let v = DeNamedMap {
-        a: 5,
-        b: 6,
-        c: 7,
-    };
+    assert_de_tokens(
+        &DeNamedMap {
+            a: 5,
+            b: 6,
+            c: 7,
+        },
+        vec![
+            Token::StructStart("DeNamedMap", Some(3)),
 
-    let v2: DeNamedMap<i32, i32, i32> = serde_json::from_str(
-        "{\"a\":5,\"b\":6,\"c\":7}"
-    ).unwrap();
-    assert_eq!(v, v2);
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I32(5),
 
-    let v2 = serde_json::from_value(Value::Object(btreemap![
-        "a".to_string() => Value::U64(5),
-        "b".to_string() => Value::U64(6),
-        "c".to_string() => Value::U64(7)
-    ])).unwrap();
-    assert_eq!(v, v2);
+            Token::MapSep,
+            Token::Str("b"),
+            Token::I32(6),
+
+            Token::MapSep,
+            Token::Str("c"),
+            Token::I32(7),
+
+            Token::MapEnd,
+        ]
+    );
 }
 
 #[test]
 fn test_ser_enum_unit() {
-    assert_eq!(
-        serde_json::to_string(&SerEnum::Unit::<u32, u32, u32>).unwrap(),
-        "{\"Unit\":[]}"
-    );
-
-    assert_eq!(
-        serde_json::to_value(&SerEnum::Unit::<u32, u32, u32>),
-        Value::Object(btreemap!(
-            "Unit".to_string() => Value::Array(vec![]))
-        )
+    assert_ser_tokens(
+        &SerEnum::Unit::<u32, u32, u32>,
+        &[
+            Token::EnumUnit("SerEnum", "Unit"),
+        ]
     );
 }
 
@@ -279,37 +266,32 @@ fn test_ser_enum_seq() {
     let mut e = 5;
     //let f = 6;
 
-    assert_eq!(
-        serde_json::to_string(&SerEnum::Seq(
+    assert_ser_tokens(
+        &SerEnum::Seq(
             a,
             b,
             &c,
             //d,
             &mut e,
             //f,
-        )).unwrap(),
-        "{\"Seq\":[1,2,3,5]}".to_string()
-    );
+        ),
+        &[
+            Token::EnumSeqStart("SerEnum", "Seq", Some(4)),
 
-    assert_eq!(
-        serde_json::to_value(&SerEnum::Seq(
-            a,
-            b,
-            &c,
-            //d,
-            &mut e,
-            //e,
-        )),
-        Value::Object(btreemap!(
-            "Seq".to_string() => Value::Array(vec![
-                Value::U64(1),
-                Value::U64(2),
-                Value::U64(3),
-                //Value::U64(4),
-                Value::U64(5),
-                //Value::U64(6),
-            ])
-        ))
+            Token::SeqSep,
+            Token::I8(1),
+
+            Token::SeqSep,
+            Token::I32(2),
+
+            Token::SeqSep,
+            Token::I32(3),
+
+            Token::SeqSep,
+            Token::I32(5),
+
+            Token::SeqEnd,
+        ],
     );
 }
 
@@ -322,54 +304,46 @@ fn test_ser_enum_map() {
     let mut e = 5;
     //let f = 6;
 
-    assert_eq!(
-        serde_json::to_string(&SerEnum::Map {
+    assert_ser_tokens(
+        &SerEnum::Map {
             a: a,
             b: b,
             c: &c,
             //d: d,
             e: &mut e,
             //f: f,
-        }).unwrap(),
-        "{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}".to_string()
-    );
+        },
+        &[
+            Token::EnumMapStart("SerEnum", "Map", Some(4)),
 
-    assert_eq!(
-        serde_json::to_value(&SerEnum::Map {
-            a: a,
-            b: b,
-            c: &c,
-            //d: d,
-            e: &mut e,
-            //f: f,
-        }),
-        Value::Object(btreemap!(
-            "Map".to_string() => Value::Object(btreemap![
-                "a".to_string() => Value::U64(1),
-                "b".to_string() => Value::U64(2),
-                "c".to_string() => Value::U64(3),
-                //"d".to_string() => Value::U64(4)
-                "e".to_string() => Value::U64(5)
-                //"f".to_string() => Value::U64(6)
-            ])
-        ))
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::MapSep,
+            Token::Str("b"),
+            Token::I32(2),
+
+            Token::MapSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::MapSep,
+            Token::Str("e"),
+            Token::I32(5),
+
+            Token::MapEnd,
+        ],
     );
 }
 
 #[test]
 fn test_de_enum_unit() {
-    let v: DeEnum<_, _, _> = serde_json::from_str("{\"Unit\":[]}").unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Unit::<u32, u32, u32>
-    );
-
-    let v: DeEnum<_, _, _> = serde_json::from_value(Value::Object(btreemap!(
-        "Unit".to_string() => Value::Array(vec![]))
-    )).unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Unit::<u32, u32, u32>
+    assert_tokens(
+        &DeEnum::Unit::<u32, u32, u32>,
+        vec![
+            Token::EnumUnit("DeEnum", "Unit"),
+        ],
     );
 }
 
@@ -382,39 +356,32 @@ fn test_de_enum_seq() {
     let e = 5;
     //let f = 6;
 
-    let v: DeEnum<_, _, _> = serde_json::from_str("{\"Seq\":[1,2,3,5]}").unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Seq(
+    assert_tokens(
+        &DeEnum::Seq(
             a,
             b,
             c,
             //d,
             e,
             //f,
-        )
-    );
+        ),
+        vec![
+            Token::EnumSeqStart("DeEnum", "Seq", Some(4)),
 
-    let v: DeEnum<_, _, _> = serde_json::from_value(Value::Object(btreemap!(
-        "Seq".to_string() => Value::Array(vec![
-            Value::U64(1),
-            Value::U64(2),
-            Value::U64(3),
-            //Value::U64(4),
-            Value::U64(5),
-            //Value::U64(6),
-        ])
-    ))).unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Seq(
-            a,
-            b,
-            c,
-            //d,
-            e,
-            //e,
-        )
+            Token::SeqSep,
+            Token::I8(1),
+
+            Token::SeqSep,
+            Token::I32(2),
+
+            Token::SeqSep,
+            Token::I32(3),
+
+            Token::SeqSep,
+            Token::I32(5),
+
+            Token::SeqEnd,
+        ],
     );
 }
 
@@ -427,110 +394,186 @@ fn test_de_enum_map() {
     let e = 5;
     //let f = 6;
 
-    let v: DeEnum<_, _, _> = serde_json::from_str(
-        "{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}"
-    ).unwrap();
-    assert_eq!(
-        v,
-        DeEnum::Map {
+    assert_tokens(
+        &DeEnum::Map {
             a: a,
             b: b,
             c: c,
             //d: d,
             e: e,
             //f: f,
-        }
-    );
+        },
+        vec![
+            Token::EnumMapStart("DeEnum", "Map", Some(4)),
 
-    let v: DeEnum<_, _, _> = serde_json::from_value(Value::Object(btreemap!(
-        "Map".to_string() => Value::Object(btreemap![
-            "a".to_string() => Value::U64(1),
-            "b".to_string() => Value::U64(2),
-            "c".to_string() => Value::U64(3),
-            //"d".to_string() => Value::U64(4)
-            "e".to_string() => Value::U64(5)
-            //"f".to_string() => Value::U64(6)
-        ])
-    ))).unwrap();
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I8(1),
 
-    assert_eq!(
-        v,
-        DeEnum::Map {
-            a: a,
-            b: b,
-            c: c,
-            //d: d,
-            e: e,
-            //f: f,
-        }
+            Token::MapSep,
+            Token::Str("b"),
+            Token::I32(2),
+
+            Token::MapSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::MapSep,
+            Token::Str("e"),
+            Token::I32(5),
+
+            Token::MapEnd,
+        ],
     );
 }
 
 #[test]
 fn test_lifetimes() {
     let value = 5;
-    let lifetime = Lifetimes::LifetimeSeq(&value);
-    assert_eq!(
-        serde_json::to_string(&lifetime).unwrap(),
-        "{\"LifetimeSeq\":5}"
+
+    assert_ser_tokens(
+        &Lifetimes::LifetimeSeq(&value),
+        &[
+            Token::EnumNewtype("Lifetimes", "LifetimeSeq"),
+            Token::I32(5),
+        ]
     );
 
-    let lifetime = Lifetimes::NoLifetimeSeq(5);
-    assert_eq!(
-        serde_json::to_string(&lifetime).unwrap(),
-        "{\"NoLifetimeSeq\":5}"
+    assert_ser_tokens(
+        &Lifetimes::NoLifetimeSeq(5),
+        &[
+            Token::EnumNewtype("Lifetimes", "NoLifetimeSeq"),
+            Token::I32(5),
+        ]
     );
 
-    let value = 5;
-    let lifetime = Lifetimes::LifetimeMap { a: &value };
-    assert_eq!(
-        serde_json::to_string(&lifetime).unwrap(),
-        "{\"LifetimeMap\":{\"a\":5}}"
+    assert_ser_tokens(
+        &Lifetimes::LifetimeMap { a: &value },
+        &[
+            Token::EnumMapStart("Lifetimes", "LifetimeMap", Some(1)),
+
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::MapEnd,
+        ]
     );
 
-    let lifetime = Lifetimes::NoLifetimeMap { a: 5 };
-    assert_eq!(
-        serde_json::to_string(&lifetime).unwrap(),
-        "{\"NoLifetimeMap\":{\"a\":5}}"
+    assert_ser_tokens(
+        &Lifetimes::NoLifetimeMap { a: 5 },
+        &[
+            Token::EnumMapStart("Lifetimes", "NoLifetimeMap", Some(1)),
+
+            Token::MapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::MapEnd,
+        ]
     );
 }
 
-macro_rules! declare_tests {
-    ($($name:ident { $($ty:ty : $value:expr => $str:expr,)+ })+) => {
-        $(
-            #[test]
-            fn $name() {
-                $(
-                    let value: $ty = $value;
+#[test]
+fn test_generic_struct() {
+    assert_tokens(
+        &GenericStruct { x: 5u32 },
+        vec![
+            Token::StructStart("GenericStruct", Some(1)),
 
-                    let string = serde_json::to_string(&value).unwrap();
-                    assert_eq!(string, $str);
+            Token::MapSep,
+            Token::Str("x"),
+            Token::U32(5),
 
-                    let expected: $ty = serde_json::from_str(&string).unwrap();
-                    assert_eq!(value, expected);
-                )+
-            }
-        )+
-    }
+            Token::MapEnd,
+        ]
+    );
 }
 
-declare_tests! {
-    test_generic_struct {
-        GenericStruct<u32> : GenericStruct { x: 5 } => "{\"x\":5}",
-    }
-    test_generic_newtype_struct {
-        GenericNewtypeStruct<u32> : GenericNewtypeStruct(5) => "5",
-    }
-    test_generic_tuple_struct {
-        GenericTupleStruct<u32, u32> : GenericTupleStruct(5, 6) => "[5,6]",
-    }
-    test_generic_enum_newtype {
-        GenericEnum<u32, u32> : GenericEnum::Newtype(5) => "{\"Newtype\":5}",
-    }
-    test_generic_enum_seq {
-        GenericEnum<u32, u32> : GenericEnum::Seq(5, 6) => "{\"Seq\":[5,6]}",
-    }
-    test_generic_enum_map {
-        GenericEnum<u32, u32> : GenericEnum::Map { x: 5, y: 6 } => "{\"Map\":{\"x\":5,\"y\":6}}",
-    }
+#[test]
+fn test_generic_newtype_struct() {
+    assert_tokens(
+        &GenericNewtypeStruct(5u32),
+        vec![
+            Token::StructNewtype("GenericNewtypeStruct"),
+            Token::U32(5),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_tuple_struct() {
+    assert_tokens(
+        &GenericTupleStruct(5u32, 6u32),
+        vec![
+            Token::TupleStructStart("GenericTupleStruct", Some(2)),
+
+            Token::SeqSep,
+            Token::U32(5),
+
+            Token::SeqSep,
+            Token::U32(6),
+
+            Token::SeqEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_unit() {
+    assert_tokens(
+        &GenericEnum::Unit::<u32, u32>,
+        vec![
+            Token::EnumUnit("GenericEnum", "Unit"),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_newtype() {
+    assert_tokens(
+        &GenericEnum::Newtype::<u32, u32>(5),
+        vec![
+            Token::EnumNewtype("GenericEnum", "Newtype"),
+            Token::U32(5),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_seq() {
+    assert_tokens(
+        &GenericEnum::Seq::<u32, u32>(5, 6),
+        vec![
+            Token::EnumSeqStart("GenericEnum", "Seq", Some(2)),
+
+            Token::SeqSep,
+            Token::U32(5),
+
+            Token::SeqSep,
+            Token::U32(6),
+
+            Token::SeqEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_map() {
+    assert_tokens(
+        &GenericEnum::Map::<u32, u32> { x: 5, y: 6 },
+        vec![
+            Token::EnumMapStart("GenericEnum", "Map", Some(2)),
+
+            Token::MapSep,
+            Token::Str("x"),
+            Token::U32(5),
+
+            Token::MapSep,
+            Token::Str("y"),
+            Token::U32(6),
+
+            Token::MapEnd,
+        ]
+    );
 }

serde_tests/tests/test_ser.rs

@@ -1,300 +1,6 @@
-use std::vec;
 use std::collections::BTreeMap;
 
-use serde::ser::{Serialize, Serializer, SeqVisitor, MapVisitor};
-
-#[derive(Clone, PartialEq, Debug)]
-pub enum Token<'a> {
-    Bool(bool),
-    Isize(isize),
-    I8(i8),
-    I16(i16),
-    I32(i32),
-    I64(i64),
-    Usize(usize),
-    U8(u8),
-    U16(u16),
-    U32(u32),
-    U64(u64),
-    F32(f32),
-    F64(f64),
-    Char(char),
-    Str(&'a str),
-
-    Option(bool),
-
-    Unit,
-    UnitStruct(&'a str),
-    EnumUnit(&'a str, &'a str),
-
-    EnumNewtype(&'a str, &'a str),
-
-    SeqStart(Option<usize>),
-    TupleStructStart(&'a str, Option<usize>),
-    EnumSeqStart(&'a str, &'a str, Option<usize>),
-    SeqSep,
-    SeqEnd,
-
-    MapStart(Option<usize>),
-    StructStart(&'a str, Option<usize>),
-    EnumMapStart(&'a str, &'a str, Option<usize>),
-    MapSep,
-    MapEnd,
-}
-
-struct AssertSerializer<'a> {
-    iter: vec::IntoIter<Token<'a>>,
-}
-
-impl<'a> AssertSerializer<'a> {
-    fn new(values: Vec<Token<'a>>) -> AssertSerializer {
-        AssertSerializer {
-            iter: values.into_iter(),
-        }
-    }
-
-    fn visit_sequence<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: SeqVisitor
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.iter.next(), Some(Token::SeqEnd));
-
-        Ok(())
-    }
-
-    fn visit_mapping<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: MapVisitor
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.iter.next(), Some(Token::MapEnd));
-
-        Ok(())
-    }
-}
-
-impl<'a> Serializer for AssertSerializer<'a> {
-    type Error = ();
-
-    fn visit_unit(&mut self) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Unit));
-        Ok(())
-    }
-
-    fn visit_newtype_variant<T>(&mut self,
-                                name: &str,
-                                _variant_index: usize,
-                                variant: &str,
-                                value: T) -> Result<(), ()>
-        where T: Serialize,
-    {
-        assert_eq!(self.iter.next(), Some(Token::EnumNewtype(name, variant)));
-        value.serialize(self)
-    }
-
-    fn visit_unit_struct(&mut self, name: &str) -> Result<(), ()> {
-        assert_eq!(self.iter.next().unwrap(), Token::UnitStruct(name));
-        Ok(())
-    }
-
-    fn visit_unit_variant(&mut self,
-                          name: &str,
-                          _variant_index: usize,
-                          variant: &str) -> Result<(), ()> {
-        assert_eq!(
-            self.iter.next().unwrap(),
-            Token::EnumUnit(name, variant)
-        );
-
-        Ok(())
-    }
-
-    fn visit_bool(&mut self, v: bool) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Bool(v)));
-        Ok(())
-    }
-
-    fn visit_isize(&mut self, v: isize) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Isize(v)));
-        Ok(())
-    }
-
-    fn visit_i8(&mut self, v: i8) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::I8(v)));
-        Ok(())
-    }
-
-    fn visit_i16(&mut self, v: i16) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::I16(v)));
-        Ok(())
-    }
-
-    fn visit_i32(&mut self, v: i32) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::I32(v)));
-        Ok(())
-    }
-
-    fn visit_i64(&mut self, v: i64) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::I64(v)));
-        Ok(())
-    }
-
-    fn visit_usize(&mut self, v: usize) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Usize(v)));
-        Ok(())
-    }
-
-    fn visit_u8(&mut self, v: u8) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::U8(v)));
-        Ok(())
-    }
-
-    fn visit_u16(&mut self, v: u16) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::U16(v)));
-        Ok(())
-    }
-
-    fn visit_u32(&mut self, v: u32) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::U32(v)));
-        Ok(())
-    }
-
-    fn visit_u64(&mut self, v: u64) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::U64(v)));
-        Ok(())
-    }
-
-    fn visit_f32(&mut self, v: f32) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::F32(v)));
-        Ok(())
-    }
-
-    fn visit_f64(&mut self, v: f64) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::F64(v)));
-        Ok(())
-    }
-
-    fn visit_char(&mut self, v: char) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Char(v)));
-        Ok(())
-    }
-
-    fn visit_str(&mut self, v: &str) -> Result<(), ()> {
-        assert_eq!(self.iter.next().unwrap(), Token::Str(v));
-        Ok(())
-    }
-
-    fn visit_none(&mut self) -> Result<(), ()> {
-        assert_eq!(self.iter.next(), Some(Token::Option(false)));
-        Ok(())
-    }
-
-    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
-        where V: Serialize,
-    {
-        assert_eq!(self.iter.next(), Some(Token::Option(true)));
-        value.serialize(self)
-    }
-
-
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<(), ()>
-        where V: SeqVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.iter.next(), Some(Token::SeqStart(len)));
-
-        self.visit_sequence(visitor)
-    }
-
-    fn visit_tuple_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
-        where V: SeqVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(
-            self.iter.next().unwrap(),
-            Token::TupleStructStart(name, len)
-        );
-
-        self.visit_sequence(visitor)
-    }
-
-    fn visit_tuple_variant<V>(&mut self,
-                              name: &str,
-                              _variant_index: usize,
-                              variant: &str,
-                              visitor: V) -> Result<(), ()>
-        where V: SeqVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(
-            self.iter.next().unwrap(),
-            Token::EnumSeqStart(name, variant, len)
-        );
-
-        self.visit_sequence(visitor)
-    }
-
-    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
-        where T: Serialize
-    {
-        assert_eq!(self.iter.next(), Some(Token::SeqSep));
-        value.serialize(self)
-    }
-
-    fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()>
-        where V: MapVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.iter.next(), Some(Token::MapStart(len)));
-
-        self.visit_mapping(visitor)
-    }
-
-    fn visit_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
-        where V: MapVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(
-            self.iter.next().unwrap(),
-            Token::StructStart(name, len)
-        );
-
-        self.visit_mapping(visitor)
-    }
-
-    fn visit_struct_variant<V>(&mut self,
-                               name: &str,
-                               _variant_index: usize,
-                               variant: &str,
-                               visitor: V) -> Result<(), ()>
-        where V: MapVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(
-            self.iter.next().unwrap(),
-            Token::EnumMapStart(name, variant, len)
-        );
-
-        self.visit_mapping(visitor)
-    }
-
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
-        where K: Serialize,
-              V: Serialize,
-    {
-        assert_eq!(self.iter.next(), Some(Token::MapSep));
-
-        try!(key.serialize(self));
-        value.serialize(self)
-    }
-}
+use token::Token;
 
 //////////////////////////////////////////////////////////////////////////
 
@@ -321,95 +27,62 @@ enum Enum {
 
 //////////////////////////////////////////////////////////////////////////
 
-macro_rules! btreemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
-
-macro_rules! declare_test {
-    ($name:ident { $($value:expr => $tokens:expr,)+ }) => {
-        #[test]
-        fn $name() {
-            $(
-                let mut ser = AssertSerializer::new($tokens);
-                assert_eq!($value.serialize(&mut ser), Ok(()));
-            )+
-        }
-    }
-}
-
-macro_rules! declare_tests {
-    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
-        $(
-            declare_test!($name { $($value => $tokens,)+ });
-        )+
-    }
-}
-
-declare_tests! {
+declare_ser_tests! {
     test_unit {
-        () => vec![Token::Unit],
+        () => &[Token::Unit],
     }
     test_bool {
-        true => vec![Token::Bool(true)],
-        false => vec![Token::Bool(false)],
+        true => &[Token::Bool(true)],
+        false => &[Token::Bool(false)],
     }
     test_isizes {
-        0isize => vec![Token::Isize(0)],
-        0i8 => vec![Token::I8(0)],
-        0i16 => vec![Token::I16(0)],
-        0i32 => vec![Token::I32(0)],
-        0i64 => vec![Token::I64(0)],
+        0isize => &[Token::Isize(0)],
+        0i8 => &[Token::I8(0)],
+        0i16 => &[Token::I16(0)],
+        0i32 => &[Token::I32(0)],
+        0i64 => &[Token::I64(0)],
     }
     test_usizes {
-        0usize => vec![Token::Usize(0)],
-        0u8 => vec![Token::U8(0)],
-        0u16 => vec![Token::U16(0)],
-        0u32 => vec![Token::U32(0)],
-        0u64 => vec![Token::U64(0)],
+        0usize => &[Token::Usize(0)],
+        0u8 => &[Token::U8(0)],
+        0u16 => &[Token::U16(0)],
+        0u32 => &[Token::U32(0)],
+        0u64 => &[Token::U64(0)],
     }
     test_floats {
-        0f32 => vec![Token::F32(0.)],
-        0f64 => vec![Token::F64(0.)],
+        0f32 => &[Token::F32(0.)],
+        0f64 => &[Token::F64(0.)],
     }
     test_char {
-        'a' => vec![Token::Char('a')],
+        'a' => &[Token::Char('a')],
     }
     test_str {
-        "abc" => vec![Token::Str("abc")],
-        "abc".to_string() => vec![Token::Str("abc")],
+        "abc" => &[Token::Str("abc")],
+        "abc".to_string() => &[Token::Str("abc")],
     }
     test_option {
-        None::<i32> => vec![Token::Option(false)],
-        Some(1) => vec![
+        None::<i32> => &[Token::Option(false)],
+        Some(1) => &[
             Token::Option(true),
             Token::I32(1),
         ],
     }
     test_result {
-        Ok::<i32, i32>(0) => vec![
+        Ok::<i32, i32>(0) => &[
             Token::EnumNewtype("Result", "Ok"),
             Token::I32(0),
         ],
-        Err::<i32, i32>(1) => vec![
+        Err::<i32, i32>(1) => &[
             Token::EnumNewtype("Result", "Err"),
             Token::I32(1),
         ],
     }
     test_slice {
-        &[0][..0] => vec![
+        &[0][..0] => &[
             Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
-        &[1, 2, 3][..] => vec![
+        &[1, 2, 3][..] => &[
             Token::SeqStart(Some(3)),
                 Token::SeqSep,
                 Token::I32(1),
@@ -423,11 +96,11 @@ declare_tests! {
         ],
     }
     test_array {
-        [0; 0] => vec![
+        [0; 0] => &[
             Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
-        [1, 2, 3] => vec![
+        [1, 2, 3] => &[
             Token::SeqStart(Some(3)),
                 Token::SeqSep,
                 Token::I32(1),
@@ -441,11 +114,11 @@ declare_tests! {
         ],
     }
     test_vec {
-        Vec::<isize>::new() => vec![
+        Vec::<isize>::new() => &[
             Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
-        vec![vec![], vec![1], vec![2, 3]] => vec![
+        vec![vec![], vec![1], vec![2, 3]] => &[
             Token::SeqStart(Some(3)),
                 Token::SeqSep,
                 Token::SeqStart(Some(0)),
@@ -469,13 +142,13 @@ declare_tests! {
         ],
     }
     test_tuple {
-        (1,) => vec![
+        (1,) => &[
             Token::SeqStart(Some(1)),
                 Token::SeqSep,
                 Token::I32(1),
             Token::SeqEnd,
         ],
-        (1, 2, 3) => vec![
+        (1, 2, 3) => &[
             Token::SeqStart(Some(3)),
                 Token::SeqSep,
                 Token::I32(1),
@@ -489,14 +162,14 @@ declare_tests! {
         ],
     }
     test_btreemap {
-        btreemap![1 => 2] => vec![
+        btreemap![1 => 2] => &[
             Token::MapStart(Some(1)),
                 Token::MapSep,
                 Token::I32(1),
                 Token::I32(2),
             Token::MapEnd,
         ],
-        btreemap![1 => 2, 3 => 4] => vec![
+        btreemap![1 => 2, 3 => 4] => &[
             Token::MapStart(Some(2)),
                 Token::MapSep,
                 Token::I32(1),
@@ -507,7 +180,7 @@ declare_tests! {
                 Token::I32(4),
             Token::MapEnd,
         ],
-        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
+        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
             Token::MapStart(Some(2)),
                 Token::MapSep,
                 Token::I32(1),
@@ -529,10 +202,10 @@ declare_tests! {
         ],
     }
     test_unit_struct {
-        UnitStruct => vec![Token::UnitStruct("UnitStruct")],
+        UnitStruct => &[Token::UnitStruct("UnitStruct")],
     }
     test_tuple_struct {
-        TupleStruct(1, 2, 3) => vec![
+        TupleStruct(1, 2, 3) => &[
             Token::TupleStructStart("TupleStruct", Some(3)),
                 Token::SeqSep,
                 Token::I32(1),
@@ -546,7 +219,7 @@ declare_tests! {
         ],
     }
     test_struct {
-        Struct { a: 1, b: 2, c: 3 } => vec![
+        Struct { a: 1, b: 2, c: 3 } => &[
             Token::StructStart("Struct", Some(3)),
                 Token::MapSep,
                 Token::Str("a"),
@@ -563,9 +236,9 @@ declare_tests! {
         ],
     }
     test_enum {
-        Enum::Unit => vec![Token::EnumUnit("Enum", "Unit")],
-        Enum::One(42) => vec![Token::EnumNewtype("Enum", "One"), Token::I32(42)],
-        Enum::Seq(1, 2) => vec![
+        Enum::Unit => &[Token::EnumUnit("Enum", "Unit")],
+        Enum::One(42) => &[Token::EnumNewtype("Enum", "One"), Token::I32(42)],
+        Enum::Seq(1, 2) => &[
             Token::EnumSeqStart("Enum", "Seq", Some(2)),
                 Token::SeqSep,
                 Token::I32(1),
@@ -574,7 +247,7 @@ declare_tests! {
                 Token::I32(2),
             Token::SeqEnd,
         ],
-        Enum::Map { a: 1, b: 2 } => vec![
+        Enum::Map { a: 1, b: 2 } => &[
             Token::EnumMapStart("Enum", "Map", Some(2)),
                 Token::MapSep,
                 Token::Str("a"),

serde_tests/tests/token.rs

@@ -0,0 +1,789 @@
+use std::fmt;
+use std::iter;
+
+use serde::{ser, de};
+use serde::de::value::{self, ValueDeserializer};
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum Token<'a> {
+    Bool(bool),
+    Isize(isize),
+    I8(i8),
+    I16(i16),
+    I32(i32),
+    I64(i64),
+    Usize(usize),
+    U8(u8),
+    U16(u16),
+    U32(u32),
+    U64(u64),
+    F32(f32),
+    F64(f64),
+    Char(char),
+    Str(&'a str),
+    String(String),
+    Bytes(&'a [u8]),
+
+    Option(bool),
+
+    Unit,
+    UnitStruct(&'a str),
+
+    StructNewtype(&'a str),
+
+    EnumStart(&'a str),
+    EnumUnit(&'a str, &'a str),
+    EnumNewtype(&'a str, &'a str),
+    EnumSeqStart(&'a str, &'a str, Option<usize>),
+    EnumMapStart(&'a str, &'a str, Option<usize>),
+
+    SeqStart(Option<usize>),
+    TupleStructStart(&'a str, Option<usize>),
+    SeqSep,
+    SeqEnd,
+
+    MapStart(Option<usize>),
+    StructStart(&'a str, Option<usize>),
+    MapSep,
+    MapEnd,
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+pub struct Serializer<I> {
+    tokens: I,
+}
+
+impl<'a, I> Serializer<I>
+    where I: Iterator<Item=&'a Token<'a>>
+{
+    pub fn new(tokens: I) -> Serializer<I> {
+        Serializer {
+            tokens: tokens,
+        }
+    }
+
+    fn visit_sequence<V>(&mut self, mut visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor
+    {
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::SeqEnd));
+
+        Ok(())
+    }
+
+    fn visit_mapping<V>(&mut self, mut visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor
+    {
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::MapEnd));
+
+        Ok(())
+    }
+}
+
+impl<'a, I> ser::Serializer for Serializer<I>
+    where I: Iterator<Item=&'a Token<'a>>,
+{
+    type Error = ();
+
+    fn visit_unit(&mut self) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Unit));
+        Ok(())
+    }
+
+    fn visit_newtype_variant<T>(&mut self,
+                                name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                value: T) -> Result<(), ()>
+        where T: ser::Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumNewtype(name, variant)));
+        value.serialize(self)
+    }
+
+    fn visit_unit_struct(&mut self, name: &str) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::UnitStruct(name)));
+        Ok(())
+    }
+
+    fn visit_unit_variant(&mut self,
+                          name: &str,
+                          _variant_index: usize,
+                          variant: &str) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumUnit(name, variant)));
+
+        Ok(())
+    }
+
+    fn visit_bool(&mut self, v: bool) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Bool(v)));
+        Ok(())
+    }
+
+    fn visit_isize(&mut self, v: isize) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Isize(v)));
+        Ok(())
+    }
+
+    fn visit_i8(&mut self, v: i8) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::I8(v)));
+        Ok(())
+    }
+
+    fn visit_i16(&mut self, v: i16) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::I16(v)));
+        Ok(())
+    }
+
+    fn visit_i32(&mut self, v: i32) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::I32(v)));
+        Ok(())
+    }
+
+    fn visit_i64(&mut self, v: i64) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::I64(v)));
+        Ok(())
+    }
+
+    fn visit_usize(&mut self, v: usize) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Usize(v)));
+        Ok(())
+    }
+
+    fn visit_u8(&mut self, v: u8) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::U8(v)));
+        Ok(())
+    }
+
+    fn visit_u16(&mut self, v: u16) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::U16(v)));
+        Ok(())
+    }
+
+    fn visit_u32(&mut self, v: u32) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::U32(v)));
+        Ok(())
+    }
+
+    fn visit_u64(&mut self, v: u64) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::U64(v)));
+        Ok(())
+    }
+
+    fn visit_f32(&mut self, v: f32) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::F32(v)));
+        Ok(())
+    }
+
+    fn visit_f64(&mut self, v: f64) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::F64(v)));
+        Ok(())
+    }
+
+    fn visit_char(&mut self, v: char) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Char(v)));
+        Ok(())
+    }
+
+    fn visit_str(&mut self, v: &str) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Str(v)));
+        Ok(())
+    }
+
+    fn visit_none(&mut self) -> Result<(), ()> {
+        assert_eq!(self.tokens.next(), Some(&Token::Option(false)));
+        Ok(())
+    }
+
+    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
+        where V: ser::Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::Option(true)));
+        value.serialize(self)
+    }
+
+
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::SeqStart(len)));
+
+        self.visit_sequence(visitor)
+    }
+
+    fn visit_newtype_struct<T>(&mut self,
+                               name: &'static str,
+                               value: T) -> Result<(), ()>
+        where T: ser::Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::StructNewtype(name)));
+        value.serialize(self)
+    }
+
+    fn visit_tuple_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::TupleStructStart(name, len)));
+
+        self.visit_sequence(visitor)
+    }
+
+    fn visit_tuple_variant<V>(&mut self,
+                              name: &str,
+                              _variant_index: usize,
+                              variant: &str,
+                              visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqStart(name, variant, len)));
+
+        self.visit_sequence(visitor)
+    }
+
+    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
+        where T: ser::Serialize
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::SeqSep));
+        value.serialize(self)
+    }
+
+    fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::MapStart(len)));
+
+        self.visit_mapping(visitor)
+    }
+
+    fn visit_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::StructStart(name, len)));
+
+        self.visit_mapping(visitor)
+    }
+
+    fn visit_struct_variant<V>(&mut self,
+                               name: &str,
+                               _variant_index: usize,
+                               variant: &str,
+                               visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::EnumMapStart(name, variant, len)));
+
+        self.visit_mapping(visitor)
+    }
+
+    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
+        where K: ser::Serialize,
+              V: ser::Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::MapSep));
+
+        try!(key.serialize(self));
+        value.serialize(self)
+    }
+
+    fn format() -> &'static str {
+        "token"
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[derive(Clone, PartialEq, Debug)]
+enum Error {
+    SyntaxError,
+    EndOfStreamError,
+    UnknownFieldError(String),
+    MissingFieldError(&'static str),
+    InvalidName(&'static str),
+    UnexpectedToken(Token<'static>),
+    ValueError(value::Error),
+}
+
+impl de::Error for Error {
+    fn syntax(_: &str) -> Error { Error::SyntaxError }
+
+    fn end_of_stream() -> Error { Error::EndOfStreamError }
+
+    fn unknown_field(field: &str) -> Error {
+        Error::UnknownFieldError(field.to_string())
+    }
+
+    fn missing_field(field: &'static str) -> Error {
+        Error::MissingFieldError(field)
+    }
+}
+
+impl From<value::Error> for Error {
+    fn from(error: value::Error) -> Error {
+        Error::ValueError(error)
+    }
+}
+
+struct Deserializer<I> where I: Iterator<Item=Token<'static>> {
+    tokens: iter::Peekable<I>,
+}
+
+impl<I> Deserializer<I>
+    where I: Iterator<Item=Token<'static>>
+{
+    fn new(tokens: I) -> Deserializer<I> {
+        Deserializer {
+            tokens: tokens.peekable(),
+        }
+    }
+
+    fn visit_seq<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_seq(DeserializerSeqVisitor {
+            de: self,
+            len: len,
+        })
+    }
+
+    fn visit_map<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_map(DeserializerMapVisitor {
+            de: self,
+            len: len,
+        })
+    }
+}
+
+impl<I> de::Deserializer for Deserializer<I>
+    where I: Iterator<Item=Token<'static>>
+{
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        println!("visit {:?}", self.tokens.peek());
+        match self.tokens.next() {
+            Some(Token::Bool(v)) => visitor.visit_bool(v),
+            Some(Token::Isize(v)) => visitor.visit_isize(v),
+            Some(Token::I8(v)) => visitor.visit_i8(v),
+            Some(Token::I16(v)) => visitor.visit_i16(v),
+            Some(Token::I32(v)) => visitor.visit_i32(v),
+            Some(Token::I64(v)) => visitor.visit_i64(v),
+            Some(Token::Usize(v)) => visitor.visit_usize(v),
+            Some(Token::U8(v)) => visitor.visit_u8(v),
+            Some(Token::U16(v)) => visitor.visit_u16(v),
+            Some(Token::U32(v)) => visitor.visit_u32(v),
+            Some(Token::U64(v)) => visitor.visit_u64(v),
+            Some(Token::F32(v)) => visitor.visit_f32(v),
+            Some(Token::F64(v)) => visitor.visit_f64(v),
+            Some(Token::Char(v)) => visitor.visit_char(v),
+            Some(Token::Str(v)) => visitor.visit_str(v),
+            Some(Token::String(v)) => visitor.visit_string(v),
+            Some(Token::Bytes(v)) => visitor.visit_bytes(v),
+            Some(Token::Option(false)) => visitor.visit_none(),
+            Some(Token::Option(true)) => visitor.visit_some(self),
+            Some(Token::Unit) => visitor.visit_unit(),
+            Some(Token::UnitStruct(name)) => visitor.visit_unit_struct(name),
+            Some(Token::SeqStart(len)) | Some(Token::TupleStructStart(_, len)) => {
+                self.visit_seq(len, visitor)
+            }
+            Some(Token::MapStart(len)) | Some(Token::StructStart(_, len)) => {
+                self.visit_map(len, visitor)
+            }
+            //Some(Token::Name(_)) => self.visit(visitor),
+            Some(token) => Err(Error::UnexpectedToken(token)),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    /// Hook into `Option` deserializing so we can treat `Unit` as a
+    /// `None`, or a regular value as `Some(value)`.
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::Option(false)) => {
+                self.tokens.next();
+                visitor.visit_none()
+            }
+            Some(&Token::Option(true)) => {
+                self.tokens.next();
+                visitor.visit_some(self)
+            }
+            Some(&Token::Unit) => {
+                self.tokens.next();
+                visitor.visit_none()
+            }
+            Some(_) => visitor.visit_some(self),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_enum<V>(&mut self,
+                     name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value, Error>
+        where V: de::EnumVisitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::EnumStart(n)) if name == n => {
+                self.tokens.next();
+
+                visitor.visit(DeserializerVariantVisitor {
+                    de: self,
+                })
+            }
+            Some(&Token::EnumUnit(n, _))
+            | Some(&Token::EnumNewtype(n, _))
+            | Some(&Token::EnumSeqStart(n, _, _))
+            | Some(&Token::EnumMapStart(n, _, _)) if name == n => {
+                visitor.visit(DeserializerVariantVisitor {
+                    de: self,
+                })
+            }
+            Some(_) => {
+                let token = self.tokens.next().unwrap();
+                Err(Error::UnexpectedToken(token))
+            }
+            None => { return Err(Error::EndOfStreamError); }
+        }
+    }
+
+    fn visit_unit_struct<V>(&mut self, name: &str, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::UnitStruct(n)) => {
+                self.tokens.next();
+                if name == n {
+                    visitor.visit_unit()
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(_) => self.visit(visitor),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_newtype_struct<V>(&mut self,
+                               name: &str,
+                               mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::StructNewtype(n)) => {
+                self.tokens.next();
+                if name == n {
+                    visitor.visit_newtype_struct(self)
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(_) => self.visit(visitor),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_tuple_struct<V>(&mut self,
+                             name: &str,
+                             len: usize,
+                             mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::UnitStruct(n)) => {
+                self.tokens.next();
+                if name == n {
+                    visitor.visit_unit()
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(&Token::TupleStructStart(n, _)) => {
+                self.tokens.next();
+                if name == n {
+                    self.visit_seq(Some(len), visitor)
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(&Token::SeqStart(_)) => {
+                self.tokens.next();
+                self.visit_seq(Some(len), visitor)
+            }
+            Some(_) => self.visit(visitor),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_struct<V>(&mut self,
+                       name: &str,
+                       fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::StructStart(n, _)) => {
+                self.tokens.next();
+                if name == n {
+                    self.visit_map(Some(fields.len()), visitor)
+                } else {
+                    Err(Error::InvalidName(n))
+                }
+            }
+            Some(&Token::MapStart(_)) => {
+                self.tokens.next();
+                self.visit_map(Some(fields.len()), visitor)
+            }
+            Some(_) => self.visit(visitor),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn format() -> &'static str {
+        "token"
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+struct DeserializerSeqVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> {
+    de: &'a mut Deserializer<I>,
+    len: Option<usize>,
+}
+
+impl<'a, I> de::SeqVisitor for DeserializerSeqVisitor<'a, I>
+    where I: Iterator<Item=Token<'static>>,
+{
+    type Error = Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::SeqSep) => {
+                self.de.tokens.next();
+                self.len = self.len.map(|len| len - 1);
+                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+            }
+            Some(&Token::SeqEnd) => Ok(None),
+            Some(_) => {
+                let token = self.de.tokens.next().unwrap();
+                Err(Error::UnexpectedToken(token))
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        //assert_eq!(self.len.unwrap_or(0), 0);
+        match self.de.tokens.next() {
+            Some(Token::SeqEnd) => Ok(()),
+            Some(token) => Err(Error::UnexpectedToken(token)),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len.unwrap_or(0);
+        (len, self.len)
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+struct DeserializerMapVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> {
+    de: &'a mut Deserializer<I>,
+    len: Option<usize>,
+}
+
+impl<'a, I> de::MapVisitor for DeserializerMapVisitor<'a, I>
+    where I: Iterator<Item=Token<'static>>,
+{
+    type Error = Error;
+
+    fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
+        where K: de::Deserialize,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::MapSep) => {
+                self.de.tokens.next();
+                self.len = self.len.map(|len| len - 1);
+                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+            }
+            Some(&Token::MapEnd) => Ok(None),
+            Some(_) => {
+                let token = self.de.tokens.next().unwrap();
+                Err(Error::UnexpectedToken(token))
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_value<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        Ok(try!(de::Deserialize::deserialize(self.de)))
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        //assert_eq!(self.len.unwrap_or(0), 0);
+        match self.de.tokens.next() {
+            Some(Token::MapEnd) => Ok(()),
+            Some(token) => Err(Error::UnexpectedToken(token)),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len.unwrap_or(0);
+        (len, self.len)
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+struct DeserializerVariantVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>> {
+    de: &'a mut Deserializer<I>,
+}
+
+impl<'a, I> de::VariantVisitor for DeserializerVariantVisitor<'a, I>
+    where I: Iterator<Item=Token<'static>>,
+{
+    type Error = Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumUnit(_, v))
+            | Some(&Token::EnumNewtype(_, v))
+            | Some(&Token::EnumSeqStart(_, v, _))
+            | Some(&Token::EnumMapStart(_, v, _)) => {
+                let value = try!(de::Deserialize::deserialize(&mut v.into_deserializer()));
+                Ok(value)
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumUnit(_, _)) => {
+                self.de.tokens.next();
+                Ok(())
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: de::Deserialize,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumNewtype(_, _)) => {
+                self.de.tokens.next();
+                de::Deserialize::deserialize(self.de)
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_tuple<V>(&mut self,
+                      len: usize,
+                      visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumSeqStart(_, _, Some(enum_len))) => {
+                let token = self.de.tokens.next().unwrap();
+
+                if len == enum_len {
+                    self.de.visit_seq(Some(len), visitor)
+                } else {
+                    Err(Error::UnexpectedToken(token))
+                }
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+    fn visit_struct<V>(&mut self,
+                       fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumMapStart(_, _, Some(enum_len))) => {
+                let token = self.de.tokens.next().unwrap();
+
+                if fields.len() == enum_len {
+                    self.de.visit_map(Some(fields.len()), visitor)
+                } else {
+                    Err(Error::UnexpectedToken(token))
+                }
+            }
+            Some(_) => {
+                de::Deserialize::deserialize(self.de)
+            }
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
+    where T: ser::Serialize,
+{
+    let mut ser = Serializer::new(tokens.iter());
+    assert_eq!(ser::Serialize::serialize(value, &mut ser), Ok(()));
+    assert_eq!(ser.tokens.next(), None);
+}
+
+pub fn assert_de_tokens<T>(value: &T, tokens: Vec<Token<'static>>)
+    where T: de::Deserialize + PartialEq + fmt::Debug,
+{
+    let mut de = Deserializer::new(tokens.into_iter());
+    let v: Result<T, Error> = de::Deserialize::deserialize(&mut de);
+    assert_eq!(v.as_ref(), Ok(value));
+    assert_eq!(de.tokens.next(), None);
+}
+
+pub fn assert_tokens<T>(value: &T, tokens: Vec<Token<'static>>)
+    where T: ser::Serialize + de::Deserialize + PartialEq + fmt::Debug,
+{
+    assert_ser_tokens(value, &tokens[..]);
+    assert_de_tokens(value, tokens);
+}