serde_macros 0.4.4

#![feature(no_std)]
#![no_std]
#![feature(test, custom_attribute, custom_derive, plugin)]
#![plugin(serde_macros)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std as std;

extern crate serde;
extern crate test;

mod test_ser {
    #[prelude_import]
    use std::prelude::v1::*;
    use std::vec;
    use std::collections::BTreeMap;
    use serde::ser::{Serialize, Serializer, SeqVisitor, MapVisitor,
                     TupleStructVisitor, StructVisitor, Variant,
                     EnumSeqVisitor, EnumMapVisitor};
    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),
        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,
    }
    #[automatically_derived]
    impl <'a> ::std::fmt::Debug for Token<'a> {
        fn fmt(&self, __arg_0: &mut ::std::fmt::Formatter)
         -> ::std::fmt::Result {
            match (&*self,) {
                (&Token::Bool(ref __self_0),) =>
                __arg_0.debug_tuple("Bool").field(&&(*__self_0)).finish(),
                (&Token::Isize(ref __self_0),) =>
                __arg_0.debug_tuple("Isize").field(&&(*__self_0)).finish(),
                (&Token::I8(ref __self_0),) =>
                __arg_0.debug_tuple("I8").field(&&(*__self_0)).finish(),
                (&Token::I16(ref __self_0),) =>
                __arg_0.debug_tuple("I16").field(&&(*__self_0)).finish(),
                (&Token::I32(ref __self_0),) =>
                __arg_0.debug_tuple("I32").field(&&(*__self_0)).finish(),
                (&Token::I64(ref __self_0),) =>
                __arg_0.debug_tuple("I64").field(&&(*__self_0)).finish(),
                (&Token::Usize(ref __self_0),) =>
                __arg_0.debug_tuple("Usize").field(&&(*__self_0)).finish(),
                (&Token::U8(ref __self_0),) =>
                __arg_0.debug_tuple("U8").field(&&(*__self_0)).finish(),
                (&Token::U16(ref __self_0),) =>
                __arg_0.debug_tuple("U16").field(&&(*__self_0)).finish(),
                (&Token::U32(ref __self_0),) =>
                __arg_0.debug_tuple("U32").field(&&(*__self_0)).finish(),
                (&Token::U64(ref __self_0),) =>
                __arg_0.debug_tuple("U64").field(&&(*__self_0)).finish(),
                (&Token::F32(ref __self_0),) =>
                __arg_0.debug_tuple("F32").field(&&(*__self_0)).finish(),
                (&Token::F64(ref __self_0),) =>
                __arg_0.debug_tuple("F64").field(&&(*__self_0)).finish(),
                (&Token::Char(ref __self_0),) =>
                __arg_0.debug_tuple("Char").field(&&(*__self_0)).finish(),
                (&Token::Str(ref __self_0),) =>
                __arg_0.debug_tuple("Str").field(&&(*__self_0)).finish(),
                (&Token::Option(ref __self_0),) =>
                __arg_0.debug_tuple("Option").field(&&(*__self_0)).finish(),
                (&Token::Unit,) => __arg_0.debug_tuple("Unit").finish(),
                (&Token::UnitStruct(ref __self_0),) =>
                __arg_0.debug_tuple("UnitStruct").field(&&(*__self_0)).finish(),
                (&Token::EnumUnit(ref __self_0, ref __self_1),) =>
                __arg_0.debug_tuple("EnumUnit").field(&&(*__self_0)).field(&&(*__self_1)).finish(),
                (&Token::SeqStart(ref __self_0),) =>
                __arg_0.debug_tuple("SeqStart").field(&&(*__self_0)).finish(),
                (&Token::TupleStructStart(ref __self_0, ref __self_1),) =>
                __arg_0.debug_tuple("TupleStructStart").field(&&(*__self_0)).field(&&(*__self_1)).finish(),
                (&Token::EnumSeqStart(ref __self_0, ref __self_1,
                                      ref __self_2),) =>
                __arg_0.debug_tuple("EnumSeqStart").field(&&(*__self_0)).field(&&(*__self_1)).field(&&(*__self_2)).finish(),
                (&Token::SeqSep,) => __arg_0.debug_tuple("SeqSep").finish(),
                (&Token::SeqEnd,) => __arg_0.debug_tuple("SeqEnd").finish(),
                (&Token::MapStart(ref __self_0),) =>
                __arg_0.debug_tuple("MapStart").field(&&(*__self_0)).finish(),
                (&Token::StructStart(ref __self_0, ref __self_1),) =>
                __arg_0.debug_tuple("StructStart").field(&&(*__self_0)).field(&&(*__self_1)).finish(),
                (&Token::EnumMapStart(ref __self_0, ref __self_1,
                                      ref __self_2),) =>
                __arg_0.debug_tuple("EnumMapStart").field(&&(*__self_0)).field(&&(*__self_1)).field(&&(*__self_2)).finish(),
                (&Token::MapSep,) => __arg_0.debug_tuple("MapSep").finish(),
                (&Token::MapEnd,) => __arg_0.debug_tuple("MapEnd").finish(),
            }
        }
    }
    #[automatically_derived]
    impl <'a> ::std::cmp::PartialEq for Token<'a> {
        #[inline]
        fn eq(&self, __arg_0: &Token<'a>) -> bool {
            {
                let __self_vi =
                    unsafe { ::std::intrinsics::discriminant_value(&*self) }
                        as i32;
                let __arg_1_vi =
                    unsafe {
                        ::std::intrinsics::discriminant_value(&*__arg_0)
                    } as i32;
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*__arg_0) {
                        (&Token::Bool(ref __self_0),
                         &Token::Bool(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::Isize(ref __self_0),
                         &Token::Isize(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::I8(ref __self_0), &Token::I8(ref __arg_1_0))
                        => true && (*__self_0) == (*__arg_1_0),
                        (&Token::I16(ref __self_0),
                         &Token::I16(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::I32(ref __self_0),
                         &Token::I32(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::I64(ref __self_0),
                         &Token::I64(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::Usize(ref __self_0),
                         &Token::Usize(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::U8(ref __self_0), &Token::U8(ref __arg_1_0))
                        => true && (*__self_0) == (*__arg_1_0),
                        (&Token::U16(ref __self_0),
                         &Token::U16(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::U32(ref __self_0),
                         &Token::U32(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::U64(ref __self_0),
                         &Token::U64(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::F32(ref __self_0),
                         &Token::F32(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::F64(ref __self_0),
                         &Token::F64(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::Char(ref __self_0),
                         &Token::Char(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::Str(ref __self_0),
                         &Token::Str(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::Option(ref __self_0),
                         &Token::Option(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::Unit, &Token::Unit) => true,
                        (&Token::UnitStruct(ref __self_0),
                         &Token::UnitStruct(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::EnumUnit(ref __self_0, ref __self_1),
                         &Token::EnumUnit(ref __arg_1_0, ref __arg_1_1)) =>
                        true && (*__self_0) == (*__arg_1_0) &&
                            (*__self_1) == (*__arg_1_1),
                        (&Token::SeqStart(ref __self_0),
                         &Token::SeqStart(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::TupleStructStart(ref __self_0, ref __self_1),
                         &Token::TupleStructStart(ref __arg_1_0,
                                                  ref __arg_1_1)) =>
                        true && (*__self_0) == (*__arg_1_0) &&
                            (*__self_1) == (*__arg_1_1),
                        (&Token::EnumSeqStart(ref __self_0, ref __self_1,
                                              ref __self_2),
                         &Token::EnumSeqStart(ref __arg_1_0, ref __arg_1_1,
                                              ref __arg_1_2)) =>
                        true && (*__self_0) == (*__arg_1_0) &&
                            (*__self_1) == (*__arg_1_1) &&
                            (*__self_2) == (*__arg_1_2),
                        (&Token::SeqSep, &Token::SeqSep) => true,
                        (&Token::SeqEnd, &Token::SeqEnd) => true,
                        (&Token::MapStart(ref __self_0),
                         &Token::MapStart(ref __arg_1_0)) =>
                        true && (*__self_0) == (*__arg_1_0),
                        (&Token::StructStart(ref __self_0, ref __self_1),
                         &Token::StructStart(ref __arg_1_0, ref __arg_1_1)) =>
                        true && (*__self_0) == (*__arg_1_0) &&
                            (*__self_1) == (*__arg_1_1),
                        (&Token::EnumMapStart(ref __self_0, ref __self_1,
                                              ref __self_2),
                         &Token::EnumMapStart(ref __arg_1_0, ref __arg_1_1,
                                              ref __arg_1_2)) =>
                        true && (*__self_0) == (*__arg_1_0) &&
                            (*__self_1) == (*__arg_1_1) &&
                            (*__self_2) == (*__arg_1_2),
                        (&Token::MapSep, &Token::MapSep) => true,
                        (&Token::MapEnd, &Token::MapEnd) => true,
                        _ => unsafe { ::std::intrinsics::unreachable() }
                    }
                } else { false }
            }
        }
        #[inline]
        fn ne(&self, __arg_0: &Token<'a>) -> bool {
            {
                let __self_vi =
                    unsafe { ::std::intrinsics::discriminant_value(&*self) }
                        as i32;
                let __arg_1_vi =
                    unsafe {
                        ::std::intrinsics::discriminant_value(&*__arg_0)
                    } as i32;
                if true && __self_vi == __arg_1_vi {
                    match (&*self, &*__arg_0) {
                        (&Token::Bool(ref __self_0),
                         &Token::Bool(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::Isize(ref __self_0),
                         &Token::Isize(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::I8(ref __self_0), &Token::I8(ref __arg_1_0))
                        => false || (*__self_0) != (*__arg_1_0),
                        (&Token::I16(ref __self_0),
                         &Token::I16(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::I32(ref __self_0),
                         &Token::I32(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::I64(ref __self_0),
                         &Token::I64(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::Usize(ref __self_0),
                         &Token::Usize(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::U8(ref __self_0), &Token::U8(ref __arg_1_0))
                        => false || (*__self_0) != (*__arg_1_0),
                        (&Token::U16(ref __self_0),
                         &Token::U16(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::U32(ref __self_0),
                         &Token::U32(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::U64(ref __self_0),
                         &Token::U64(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::F32(ref __self_0),
                         &Token::F32(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::F64(ref __self_0),
                         &Token::F64(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::Char(ref __self_0),
                         &Token::Char(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::Str(ref __self_0),
                         &Token::Str(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::Option(ref __self_0),
                         &Token::Option(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::Unit, &Token::Unit) => false,
                        (&Token::UnitStruct(ref __self_0),
                         &Token::UnitStruct(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::EnumUnit(ref __self_0, ref __self_1),
                         &Token::EnumUnit(ref __arg_1_0, ref __arg_1_1)) =>
                        false || (*__self_0) != (*__arg_1_0) ||
                            (*__self_1) != (*__arg_1_1),
                        (&Token::SeqStart(ref __self_0),
                         &Token::SeqStart(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::TupleStructStart(ref __self_0, ref __self_1),
                         &Token::TupleStructStart(ref __arg_1_0,
                                                  ref __arg_1_1)) =>
                        false || (*__self_0) != (*__arg_1_0) ||
                            (*__self_1) != (*__arg_1_1),
                        (&Token::EnumSeqStart(ref __self_0, ref __self_1,
                                              ref __self_2),
                         &Token::EnumSeqStart(ref __arg_1_0, ref __arg_1_1,
                                              ref __arg_1_2)) =>
                        false || (*__self_0) != (*__arg_1_0) ||
                            (*__self_1) != (*__arg_1_1) ||
                            (*__self_2) != (*__arg_1_2),
                        (&Token::SeqSep, &Token::SeqSep) => false,
                        (&Token::SeqEnd, &Token::SeqEnd) => false,
                        (&Token::MapStart(ref __self_0),
                         &Token::MapStart(ref __arg_1_0)) =>
                        false || (*__self_0) != (*__arg_1_0),
                        (&Token::StructStart(ref __self_0, ref __self_1),
                         &Token::StructStart(ref __arg_1_0, ref __arg_1_1)) =>
                        false || (*__self_0) != (*__arg_1_0) ||
                            (*__self_1) != (*__arg_1_1),
                        (&Token::EnumMapStart(ref __self_0, ref __self_1,
                                              ref __self_2),
                         &Token::EnumMapStart(ref __arg_1_0, ref __arg_1_1,
                                              ref __arg_1_2)) =>
                        false || (*__self_0) != (*__arg_1_0) ||
                            (*__self_1) != (*__arg_1_1) ||
                            (*__self_2) != (*__arg_1_2),
                        (&Token::MapSep, &Token::MapSep) => false,
                        (&Token::MapEnd, &Token::MapEnd) => false,
                        _ => unsafe { ::std::intrinsics::unreachable() }
                    }
                } else { true }
            }
        }
    }
    #[automatically_derived]
    impl <'a> ::std::clone::Clone for Token<'a> {
        #[inline]
        fn clone(&self) -> Token<'a> {
            match (&*self,) {
                (&Token::Bool(ref __self_0),) =>
                Token::Bool(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::Isize(ref __self_0),) =>
                Token::Isize(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::I8(ref __self_0),) =>
                Token::I8(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::I16(ref __self_0),) =>
                Token::I16(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::I32(ref __self_0),) =>
                Token::I32(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::I64(ref __self_0),) =>
                Token::I64(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::Usize(ref __self_0),) =>
                Token::Usize(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::U8(ref __self_0),) =>
                Token::U8(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::U16(ref __self_0),) =>
                Token::U16(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::U32(ref __self_0),) =>
                Token::U32(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::U64(ref __self_0),) =>
                Token::U64(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::F32(ref __self_0),) =>
                Token::F32(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::F64(ref __self_0),) =>
                Token::F64(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::Char(ref __self_0),) =>
                Token::Char(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::Str(ref __self_0),) =>
                Token::Str(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::Option(ref __self_0),) =>
                Token::Option(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::Unit,) => Token::Unit,
                (&Token::UnitStruct(ref __self_0),) =>
                Token::UnitStruct(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::EnumUnit(ref __self_0, ref __self_1),) =>
                Token::EnumUnit(::std::clone::Clone::clone(&(*__self_0)),
                                ::std::clone::Clone::clone(&(*__self_1))),
                (&Token::SeqStart(ref __self_0),) =>
                Token::SeqStart(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::TupleStructStart(ref __self_0, ref __self_1),) =>
                Token::TupleStructStart(::std::clone::Clone::clone(&(*__self_0)),
                                        ::std::clone::Clone::clone(&(*__self_1))),
                (&Token::EnumSeqStart(ref __self_0, ref __self_1,
                                      ref __self_2),) =>
                Token::EnumSeqStart(::std::clone::Clone::clone(&(*__self_0)),
                                    ::std::clone::Clone::clone(&(*__self_1)),
                                    ::std::clone::Clone::clone(&(*__self_2))),
                (&Token::SeqSep,) => Token::SeqSep,
                (&Token::SeqEnd,) => Token::SeqEnd,
                (&Token::MapStart(ref __self_0),) =>
                Token::MapStart(::std::clone::Clone::clone(&(*__self_0))),
                (&Token::StructStart(ref __self_0, ref __self_1),) =>
                Token::StructStart(::std::clone::Clone::clone(&(*__self_0)),
                                   ::std::clone::Clone::clone(&(*__self_1))),
                (&Token::EnumMapStart(ref __self_0, ref __self_1,
                                      ref __self_2),) =>
                Token::EnumMapStart(::std::clone::Clone::clone(&(*__self_0)),
                                    ::std::clone::Clone::clone(&(*__self_1)),
                                    ::std::clone::Clone::clone(&(*__self_2))),
                (&Token::MapSep,) => Token::MapSep,
                (&Token::MapEnd,) => Token::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 {
            loop  {
                match match visitor.visit(self) {
                          ::std::result::Result::Ok(val) => val,
                          ::std::result::Result::Err(err) => {
                              return ::std::result::Result::Err(::std::convert::From::from(err))
                          }
                      } {
                    Some(()) => { }
                    _ => break ,
                }
            }
            {
                match (&(self.iter.next()), &(Some(Token::SeqEnd))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     69u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_mapping<V>(&mut self, mut visitor: V) -> Result<(), ()> where
         V: MapVisitor {
            loop  {
                match match visitor.visit(self) {
                          ::std::result::Result::Ok(val) => val,
                          ::std::result::Result::Err(err) => {
                              return ::std::result::Result::Err(::std::convert::From::from(err))
                          }
                      } {
                    Some(()) => { }
                    _ => break ,
                }
            }
            {
                match (&(self.iter.next()), &(Some(Token::MapEnd))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     79u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
    }
    impl <'a> Serializer for AssertSerializer<'a> {
        type
        Error
        =
        ();
        fn visit_unit(&mut self) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::Unit))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     89u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_unit_struct(&mut self, name: &str) -> Result<(), ()> {
            {
                match (&(self.iter.next().unwrap()),
                       &(Token::UnitStruct(name))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     94u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_enum_unit<V>(&mut self, _variant: V) -> Result<(), ()> where
         V: Variant {
            {
                match (&(self.iter.next().unwrap()),
                       &(Token::EnumUnit(V::enum_name(), V::name()))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     101u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_bool(&mut self, v: bool) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::Bool(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     110u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_isize(&mut self, v: isize) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::Isize(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     115u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_i8(&mut self, v: i8) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::I8(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     120u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_i16(&mut self, v: i16) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::I16(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     125u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_i32(&mut self, v: i32) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::I32(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     130u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_i64(&mut self, v: i64) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::I64(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     135u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_usize(&mut self, v: usize) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::Usize(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     140u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_u8(&mut self, v: u8) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::U8(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     145u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_u16(&mut self, v: u16) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::U16(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     150u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_u32(&mut self, v: u32) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::U32(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     155u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_u64(&mut self, v: u64) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::U64(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     160u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_f32(&mut self, v: f32) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::F32(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     165u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_f64(&mut self, v: f64) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::F64(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     170u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_char(&mut self, v: char) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::Char(v)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     175u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_str(&mut self, v: &str) -> Result<(), ()> {
            {
                match (&(self.iter.next().unwrap()), &(Token::Str(v))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     180u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_none(&mut self) -> Result<(), ()> {
            {
                match (&(self.iter.next()), &(Some(Token::Option(false)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     185u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            Ok(())
        }
        fn visit_some<V>(&mut self, value: V) -> Result<(), ()> where
         V: Serialize {
            {
                match (&(self.iter.next()), &(Some(Token::Option(true)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     192u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            value.serialize(self)
        }
        fn visit_seq<V>(&mut self, visitor: V) -> Result<(), ()> where
         V: SeqVisitor {
            let len = visitor.len();
            {
                match (&(self.iter.next()), &(Some(Token::SeqStart(len)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     202u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            self.visit_sequence(visitor)
        }
        fn visit_tuple_struct<V>(&mut self, visitor: V) -> Result<(), ()>
         where V: TupleStructVisitor {
            let len = visitor.len();
            {
                match (&(self.iter.next().unwrap()),
                       &(Token::TupleStructStart(V::name(), len))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     212u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            self.visit_sequence(visitor)
        }
        fn visit_enum_seq<V>(&mut self, visitor: V) -> Result<(), ()> where
         V: EnumSeqVisitor {
            let len = visitor.len();
            {
                match (&(self.iter.next().unwrap()),
                       &(Token::EnumSeqStart(V::enum_name(), V::name(), len)))
                    {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     225u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            self.visit_sequence(visitor)
        }
        fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()> where
         T: Serialize {
            {
                match (&(self.iter.next()), &(Some(Token::SeqSep))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     236u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            value.serialize(self)
        }
        fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()> where
         V: MapVisitor {
            let len = visitor.len();
            {
                match (&(self.iter.next()), &(Some(Token::MapStart(len)))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     245u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            self.visit_mapping(visitor)
        }
        fn visit_struct<V>(&mut self, visitor: V) -> Result<(), ()> where
         V: StructVisitor {
            let len = visitor.len();
            {
                match (&(self.iter.next().unwrap()),
                       &(Token::StructStart(V::name(), len))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     255u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            self.visit_mapping(visitor)
        }
        fn visit_enum_map<V>(&mut self, visitor: V) -> Result<(), ()> where
         V: EnumMapVisitor {
            let len = visitor.len();
            {
                match (&(self.iter.next().unwrap()),
                       &(Token::EnumMapStart(V::enum_name(), V::name(), len)))
                    {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     268u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            self.visit_mapping(visitor)
        }
        fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
         where K: Serialize, V: Serialize {
            {
                match (&(self.iter.next()), &(Some(Token::MapSep))) {
                    (left_val, right_val) => {
                        if !(*left_val == *right_val) {
                            {
                                ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                              static __STATIC_FMTSTR:
                                                                                                     &'static [&'static str]
                                                                                                     =
                                                                                                  &["assertion failed: `(left == right)` (left: `",
                                                                                                    "`, right: `",
                                                                                                    "`)"];
                                                                                              __STATIC_FMTSTR
                                                                                          },
                                                                                          &match (&*left_val,
                                                                                                  &*right_val)
                                                                                               {
                                                                                               (__arg0,
                                                                                                __arg1)
                                                                                               =>
                                                                                               [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                            ::std::fmt::Debug::fmt),
                                                                                                ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                            ::std::fmt::Debug::fmt)],
                                                                                           }),
                                                            {
                                                                static _FILE_LINE:
                                                                       (&'static str,
                                                                        u32) =
                                                                    ("tests/../../serde_tests/tests/test_ser.rs",
                                                                     280u32);
                                                                &_FILE_LINE
                                                            })
                            }
                        }
                    }
                }
            };
            match key.serialize(self) {
                ::std::result::Result::Ok(val) => val,
                ::std::result::Result::Err(err) => {
                    return ::std::result::Result::Err(::std::convert::From::from(err))
                }
            };
            value.serialize(self)
        }
    }
    struct UnitStruct;
    #[automatically_derived]
    impl ::serde::ser::Serialize for UnitStruct {
        fn serialize<__S>(&self, serializer: &mut __S)
         -> ::std::result::Result<(), __S::Error> where
         __S: ::serde::ser::Serializer {
            serializer.visit_unit_struct("UnitStruct")
        }
    }
    struct TupleStruct(i32, i32, i32);
    #[automatically_derived]
    impl ::serde::ser::Serialize for TupleStruct {
        fn serialize<__S>(&self, serializer: &mut __S)
         -> ::std::result::Result<(), __S::Error> where
         __S: ::serde::ser::Serializer {
            {
                struct Visitor<'__a> {
                    state: usize,
                    value: &'__a TupleStruct,
                    _structure_ty: ::std::marker::PhantomData<&'__a TupleStruct>,
                }
                impl <'__a> ::serde::ser::Name for Visitor<'__a> {
                    #[inline]
                    fn name() -> &'static str { "TupleStruct" }
                }
                impl <'__a> ::serde::ser::SeqVisitor for Visitor<'__a> {
                    #[inline]
                    fn visit<S>(&mut self, serializer: &mut S)
                     -> ::std::result::Result<Option<()>, S::Error> where
                     S: ::serde::ser::Serializer {
                        match self.state {
                            0usize => {
                                self.state += 1;
                                let v =
                                    match serializer.visit_tuple_struct_elt(&self.value.0)
                                        {
                                        ::std::result::Result::Ok(val) => val,
                                        ::std::result::Result::Err(err) => {
                                            return ::std::result::Result::Err(::std::convert::From::from(err))
                                        }
                                    };
                                Ok(Some(v))
                            }
                            1usize => {
                                self.state += 1;
                                let v =
                                    match serializer.visit_tuple_struct_elt(&self.value.1)
                                        {
                                        ::std::result::Result::Ok(val) => val,
                                        ::std::result::Result::Err(err) => {
                                            return ::std::result::Result::Err(::std::convert::From::from(err))
                                        }
                                    };
                                Ok(Some(v))
                            }
                            2usize => {
                                self.state += 1;
                                let v =
                                    match serializer.visit_tuple_struct_elt(&self.value.2)
                                        {
                                        ::std::result::Result::Ok(val) => val,
                                        ::std::result::Result::Err(err) => {
                                            return ::std::result::Result::Err(::std::convert::From::from(err))
                                        }
                                    };
                                Ok(Some(v))
                            }
                            _ => Ok(None),
                        }
                    }
                    #[inline]
                    fn len(&self) -> Option<usize> { Some(3usize) }
                }
                impl <'__a> ::serde::ser::TupleStructVisitor for Visitor<'__a>
                 {
                }
                serializer.visit_tuple_struct(Visitor{value: self,
                                                      state: 0,
                                                      _structure_ty:
                                                          ::std::marker::PhantomData,})
            }
        }
    }
    struct Struct {
        a: i32,
        b: i32,
        c: i32,
    }
    #[automatically_derived]
    impl ::serde::ser::Serialize for Struct {
        fn serialize<__S>(&self, serializer: &mut __S)
         -> ::std::result::Result<(), __S::Error> where
         __S: ::serde::ser::Serializer {
            {
                struct Visitor<'__a> {
                    state: usize,
                    value: &'__a Struct,
                    _structure_ty: ::std::marker::PhantomData<&'__a Struct>,
                }
                impl <'__a> ::serde::ser::Name for Visitor<'__a> {
                    #[inline]
                    fn name() -> &'static str { "Struct" }
                }
                impl <'__a> ::serde::ser::MapVisitor for Visitor<'__a> {
                    #[inline]
                    fn visit<S>(&mut self, serializer: &mut S)
                     -> ::std::result::Result<Option<()>, S::Error> where
                     S: ::serde::ser::Serializer {
                        match self.state {
                            0usize => {
                                self.state += 1;
                                Ok(Some(match serializer.visit_struct_elt("a",
                                                                          &self.value.a)
                                            {
                                            ::std::result::Result::Ok(val) =>
                                            val,
                                            ::std::result::Result::Err(err) =>
                                            {
                                                return ::std::result::Result::Err(::std::convert::From::from(err))
                                            }
                                        }))
                            }
                            1usize => {
                                self.state += 1;
                                Ok(Some(match serializer.visit_struct_elt("b",
                                                                          &self.value.b)
                                            {
                                            ::std::result::Result::Ok(val) =>
                                            val,
                                            ::std::result::Result::Err(err) =>
                                            {
                                                return ::std::result::Result::Err(::std::convert::From::from(err))
                                            }
                                        }))
                            }
                            2usize => {
                                self.state += 1;
                                Ok(Some(match serializer.visit_struct_elt("c",
                                                                          &self.value.c)
                                            {
                                            ::std::result::Result::Ok(val) =>
                                            val,
                                            ::std::result::Result::Err(err) =>
                                            {
                                                return ::std::result::Result::Err(::std::convert::From::from(err))
                                            }
                                        }))
                            }
                            _ => Ok(None),
                        }
                    }
                    #[inline]
                    fn len(&self) -> Option<usize> { Some(3usize) }
                }
                impl <'__a> ::serde::ser::StructVisitor for Visitor<'__a> {
                    #[inline]
                    fn fields() -> &'static [&'static str] {
                        const FIELDS: &'static [&'static str] =
                            &["a", "b", "c"];
                        FIELDS
                    }
                }
                serializer.visit_struct(Visitor{value: self,
                                                state: 0,
                                                _structure_ty:
                                                    ::std::marker::PhantomData,})
            }
        }
    }
    enum Enum {
        Unit,
        Seq(i32, i32),
        Map {
            a: i32,
            b: i32,
        },
    }
    #[automatically_derived]
    impl ::serde::ser::Serialize for Enum {
        fn serialize<__S>(&self, serializer: &mut __S)
         -> ::std::result::Result<(), __S::Error> where
         __S: ::serde::ser::Serializer {
            match *self {
                Enum::Unit => {
                    {
                        struct Visitor;
                        impl ::serde::ser::Name for Visitor {
                            #[inline]
                            fn name() -> &'static str { "Unit" }
                        }
                        impl ::serde::ser::Variant for Visitor {
                            #[inline]
                            fn enum_name() -> &'static str { "Enum" }
                            #[inline]
                            fn variant_index() -> usize { 0usize }
                        }
                        serializer.visit_enum_unit(Visitor)
                    }
                }
                Enum::Seq(ref __field0, ref __field1) => {
                    {
                        struct Visitor<'__a> {
                            state: usize,
                            value: (&'__a i32, &'__a i32),
                            _structure_ty: ::std::marker::PhantomData<&'__a Enum>,
                        }
                        impl <'__a> ::serde::ser::Name for Visitor<'__a> {
                            #[inline]
                            fn name() -> &'static str { "Seq" }
                        }
                        impl <'__a> ::serde::ser::SeqVisitor for Visitor<'__a>
                         {
                            #[inline]
                            fn visit<S>(&mut self, serializer: &mut S)
                             -> ::std::result::Result<Option<()>, S::Error>
                             where S: ::serde::ser::Serializer {
                                match self.state {
                                    0usize => {
                                        self.state += 1;
                                        let v =
                                            match serializer.visit_tuple_struct_elt(&self.value.0)
                                                {
                                                ::std::result::Result::Ok(val)
                                                => val,
                                                ::std::result::Result::Err(err)
                                                => {
                                                    return ::std::result::Result::Err(::std::convert::From::from(err))
                                                }
                                            };
                                        Ok(Some(v))
                                    }
                                    1usize => {
                                        self.state += 1;
                                        let v =
                                            match serializer.visit_tuple_struct_elt(&self.value.1)
                                                {
                                                ::std::result::Result::Ok(val)
                                                => val,
                                                ::std::result::Result::Err(err)
                                                => {
                                                    return ::std::result::Result::Err(::std::convert::From::from(err))
                                                }
                                            };
                                        Ok(Some(v))
                                    }
                                    _ => Ok(None),
                                }
                            }
                            #[inline]
                            fn len(&self) -> Option<usize> { Some(2usize) }
                        }
                        impl <'__a> ::serde::ser::TupleStructVisitor for
                         Visitor<'__a> {
                        }
                        impl <'__a> ::serde::ser::EnumSeqVisitor for
                         Visitor<'__a> {
                        }
                        impl <'__a> ::serde::ser::Variant for Visitor<'__a> {
                            #[inline]
                            fn enum_name() -> &'static str { "Enum" }
                            #[inline]
                            fn variant_index() -> usize { 1usize }
                        }
                        serializer.visit_enum_seq(Visitor{value:
                                                              (&__field0,
                                                               &__field1),
                                                          state: 0,
                                                          _structure_ty:
                                                              ::std::marker::PhantomData,})
                    }
                }
                Enum::Map(ref __field0, ref __field1) => {
                    {
                        struct Visitor<'__a> {
                            state: usize,
                            value: (&'__a i32, &'__a i32),
                            _structure_ty: ::std::marker::PhantomData<&'__a Enum>,
                        }
                        impl <'__a> ::serde::ser::Name for Visitor<'__a> {
                            #[inline]
                            fn name() -> &'static str { "Map" }
                        }
                        impl <'__a> ::serde::ser::MapVisitor for Visitor<'__a>
                         {
                            #[inline]
                            fn visit<S>(&mut self, serializer: &mut S)
                             -> ::std::result::Result<Option<()>, S::Error>
                             where S: ::serde::ser::Serializer {
                                match self.state {
                                    0usize => {
                                        self.state += 1;
                                        Ok(Some(match serializer.visit_struct_elt("a",
                                                                                  self.value.0)
                                                    {
                                                    ::std::result::Result::Ok(val)
                                                    => val,
                                                    ::std::result::Result::Err(err)
                                                    => {
                                                        return ::std::result::Result::Err(::std::convert::From::from(err))
                                                    }
                                                }))
                                    }
                                    1usize => {
                                        self.state += 1;
                                        Ok(Some(match serializer.visit_struct_elt("b",
                                                                                  self.value.1)
                                                    {
                                                    ::std::result::Result::Ok(val)
                                                    => val,
                                                    ::std::result::Result::Err(err)
                                                    => {
                                                        return ::std::result::Result::Err(::std::convert::From::from(err))
                                                    }
                                                }))
                                    }
                                    _ => Ok(None),
                                }
                            }
                            #[inline]
                            fn len(&self) -> Option<usize> { Some(2usize) }
                        }
                        impl <'__a> ::serde::ser::StructVisitor for
                         Visitor<'__a> {
                            #[inline]
                            fn fields() -> &'static [&'static str] {
                                const FIELDS: &'static [&'static str] =
                                    &["a", "b"];
                                FIELDS
                            }
                        }
                        impl <'__a> ::serde::ser::EnumMapVisitor for
                         Visitor<'__a> {
                        }
                        impl <'__a> ::serde::ser::Variant for Visitor<'__a> {
                            #[inline]
                            fn enum_name() -> &'static str { "Enum" }
                            #[inline]
                            fn variant_index() -> usize { 2usize }
                        }
                        serializer.visit_enum_map(Visitor{value:
                                                              (&__field0,
                                                               &__field1),
                                                          state: 0,
                                                          _structure_ty:
                                                              ::std::marker::PhantomData,})
                    }
                }
            }
        }
    }
    #[test]
    pub fn test_unit() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Unit])));
        {
            match (&(().serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_bool() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Bool(true)])));
        {
            match (&(true.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Bool(false)])));
        {
            match (&(false.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_isizes() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Isize(0)])));
        {
            match (&(0isize.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::I8(0)])));
        {
            match (&(0i8.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::I16(0)])));
        {
            match (&(0i16.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::I32(0)])));
        {
            match (&(0i32.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::I64(0)])));
        {
            match (&(0i64.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_usizes() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Usize(0)])));
        {
            match (&(0usize.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::U8(0)])));
        {
            match (&(0u8.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::U16(0)])));
        {
            match (&(0u16.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::U32(0)])));
        {
            match (&(0u32.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::U64(0)])));
        {
            match (&(0u64.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_floats() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::F32(0.)])));
        {
            match (&(0f32.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::F64(0.)])));
        {
            match (&(0f64.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_char() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Char('a')])));
        {
            match (&('a'.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_str() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Str("abc")])));
        {
            match (&("abc".serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Str("abc")])));
        {
            match (&("abc".to_string().serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_option() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Option(false)])));
        {
            match (&(None::<i32>.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::Option(true),
                                                                          Token::I32(1)])));
        {
            match (&(Some(1).serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_slice() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::SeqStart(Some(0)),
                                                                          Token::SeqEnd])));
        {
            match (&(&[0][..0].serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::SeqStart(Some(3)),
                                                                          Token::SeqSep,
                                                                          Token::I32(1),
                                                                          Token::SeqSep,
                                                                          Token::I32(2),
                                                                          Token::SeqSep,
                                                                          Token::I32(3),
                                                                          Token::SeqEnd])));
        {
            match (&(&[1, 2, 3][..].serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_array() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::SeqStart(Some(0)),
                                                                          Token::SeqEnd])));
        {
            match (&([0; 0].serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::SeqStart(Some(3)),
                                                                          Token::SeqSep,
                                                                          Token::I32(1),
                                                                          Token::SeqSep,
                                                                          Token::I32(2),
                                                                          Token::SeqSep,
                                                                          Token::I32(3),
                                                                          Token::SeqEnd])));
        {
            match (&([1, 2, 3].serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_vec() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::SeqStart(Some(0)),
                                                                          Token::SeqEnd])));
        {
            match (&(Vec::<isize>::new().serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::SeqStart(Some(3)),
                                                                          Token::SeqSep,
                                                                          Token::SeqStart(Some(0)),
                                                                          Token::SeqEnd,
                                                                          Token::SeqSep,
                                                                          Token::SeqStart(Some(1)),
                                                                          Token::SeqSep,
                                                                          Token::I32(1),
                                                                          Token::SeqEnd,
                                                                          Token::SeqSep,
                                                                          Token::SeqStart(Some(2)),
                                                                          Token::SeqSep,
                                                                          Token::I32(2),
                                                                          Token::SeqSep,
                                                                          Token::I32(3),
                                                                          Token::SeqEnd,
                                                                          Token::SeqEnd])));
        {
            match (&(<[_]>::into_vec(::std::boxed::Box::new([<[_]>::into_vec(::std::boxed::Box::new([])),
                                                             <[_]>::into_vec(::std::boxed::Box::new([1])),
                                                             <[_]>::into_vec(::std::boxed::Box::new([2,
                                                                                                     3]))])).serialize(&mut ser)),
                   &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_tuple() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::SeqStart(Some(1)),
                                                                          Token::SeqSep,
                                                                          Token::I32(1),
                                                                          Token::SeqEnd])));
        {
            match (&((1,).serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::SeqStart(Some(3)),
                                                                          Token::SeqSep,
                                                                          Token::I32(1),
                                                                          Token::SeqSep,
                                                                          Token::I32(2),
                                                                          Token::SeqSep,
                                                                          Token::I32(3),
                                                                          Token::SeqEnd])));
        {
            match (&((1, 2, 3).serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_btreemap() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::MapStart(Some(1)),
                                                                          Token::MapSep,
                                                                          Token::I32(1),
                                                                          Token::I32(2),
                                                                          Token::MapEnd])));
        {
            match (&({
                         let mut map = BTreeMap::new();
                         map.insert(1, 2);
                         map
                     }.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::MapStart(Some(2)),
                                                                          Token::MapSep,
                                                                          Token::I32(1),
                                                                          Token::I32(2),
                                                                          Token::MapSep,
                                                                          Token::I32(3),
                                                                          Token::I32(4),
                                                                          Token::MapEnd])));
        {
            match (&({
                         let mut map = BTreeMap::new();
                         map.insert(1, 2);
                         map.insert(3, 4);
                         map
                     }.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::MapStart(Some(2)),
                                                                          Token::MapSep,
                                                                          Token::I32(1),
                                                                          Token::MapStart(Some(0)),
                                                                          Token::MapEnd,
                                                                          Token::MapSep,
                                                                          Token::I32(2),
                                                                          Token::MapStart(Some(2)),
                                                                          Token::MapSep,
                                                                          Token::I32(3),
                                                                          Token::I32(4),
                                                                          Token::MapSep,
                                                                          Token::I32(5),
                                                                          Token::I32(6),
                                                                          Token::MapEnd,
                                                                          Token::MapEnd])));
        {
            match (&({
                         let mut map = BTreeMap::new();
                         map.insert(1, BTreeMap::new());
                         map.insert(2,
                                    {
                                        let mut map = BTreeMap::new();
                                        map.insert(3, 4);
                                        map.insert(5, 6);
                                        map
                                    });
                         map
                     }.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_unit_struct() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::UnitStruct("UnitStruct")])));
        {
            match (&(UnitStruct.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_tuple_struct() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::TupleStructStart("TupleStruct",
                                                                                                  Some(3)),
                                                                          Token::SeqSep,
                                                                          Token::I32(1),
                                                                          Token::SeqSep,
                                                                          Token::I32(2),
                                                                          Token::SeqSep,
                                                                          Token::I32(3),
                                                                          Token::SeqEnd])));
        {
            match (&(TupleStruct(1, 2, 3).serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_struct() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::StructStart("Struct",
                                                                                             Some(3)),
                                                                          Token::MapSep,
                                                                          Token::Str("a"),
                                                                          Token::I32(1),
                                                                          Token::MapSep,
                                                                          Token::Str("b"),
                                                                          Token::I32(2),
                                                                          Token::MapSep,
                                                                          Token::Str("c"),
                                                                          Token::I32(3),
                                                                          Token::MapEnd])));
        {
            match (&(Struct{a: 1, b: 2, c: 3,}.serialize(&mut ser)),
                   &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    #[test]
    pub fn test_enum() {
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::EnumUnit("Enum",
                                                                                          "Unit")])));
        {
            match (&(Enum::Unit.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::EnumSeqStart("Enum",
                                                                                              "Seq",
                                                                                              Some(2)),
                                                                          Token::SeqSep,
                                                                          Token::I32(1),
                                                                          Token::SeqSep,
                                                                          Token::I32(2),
                                                                          Token::SeqEnd])));
        {
            match (&(Enum::Seq(1, 2).serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
        let mut ser =
            AssertSerializer::new(<[_]>::into_vec(::std::boxed::Box::new([Token::EnumMapStart("Enum",
                                                                                              "Map",
                                                                                              Some(2)),
                                                                          Token::MapSep,
                                                                          Token::Str("a"),
                                                                          Token::I32(1),
                                                                          Token::MapSep,
                                                                          Token::Str("b"),
                                                                          Token::I32(2),
                                                                          Token::MapEnd])));
        {
            match (&(Enum::Map{a: 1, b: 2,}.serialize(&mut ser)), &(Ok(()))) {
                (left_val, right_val) => {
                    if !(*left_val == *right_val) {
                        {
                            ::std::rt::begin_unwind_fmt(::std::fmt::Arguments::new_v1({
                                                                                          static __STATIC_FMTSTR:
                                                                                                 &'static [&'static str]
                                                                                                 =
                                                                                              &["assertion failed: `(left == right)` (left: `",
                                                                                                "`, right: `",
                                                                                                "`)"];
                                                                                          __STATIC_FMTSTR
                                                                                      },
                                                                                      &match (&*left_val,
                                                                                              &*right_val)
                                                                                           {
                                                                                           (__arg0,
                                                                                            __arg1)
                                                                                           =>
                                                                                           [::std::fmt::ArgumentV1::new(__arg0,
                                                                                                                        ::std::fmt::Debug::fmt),
                                                                                            ::std::fmt::ArgumentV1::new(__arg1,
                                                                                                                        ::std::fmt::Debug::fmt)],
                                                                                       }),
                                                        {
                                                            static _FILE_LINE:
                                                                   (&'static str,
                                                                    u32) =
                                                                ("tests/../../serde_tests/tests/test_ser.rs",
                                                                 344u32);
                                                            &_FILE_LINE
                                                        })
                        }
                    }
                }
            }
        };
    }
    pub mod __test_reexports {
        #[prelude_import]
        use std::prelude::v1::*;
        pub use super::test_unit;
        pub use super::test_bool;
        pub use super::test_isizes;
        pub use super::test_usizes;
        pub use super::test_floats;
        pub use super::test_char;
        pub use super::test_str;
        pub use super::test_option;
        pub use super::test_slice;
        pub use super::test_array;
        pub use super::test_vec;
        pub use super::test_tuple;
        pub use super::test_btreemap;
        pub use super::test_unit_struct;
        pub use super::test_tuple_struct;
        pub use super::test_struct;
        pub use super::test_enum;
    }
}
pub mod __test_reexports {
    #[prelude_import]
    use std::prelude::v1::*;
    pub use super::test_ser::__test_reexports as test_ser;
}