varbincode-0.1.0/.gitignore0100644€zÍO€oÓ-º000000000611347311677300151120ustar0000000000000000.DS_Store /Cargo.lock /target/ **/*.rs.bk .*.sw* varbincode-0.1.0/Cargo.toml.orig0100644€zÍO€oÓ-º000000007041347311722100160020ustar0000000000000000[package] authors = ["Wez Furlong "] name = "varbincode" version = "0.1.0" edition = "2018" readme = "README.md" repository = "https://github.com/wez/varbincode" description = "A binary encoder / decoder with variable length integer encoding implementation in Rust." license = "MIT" documentation = "https://docs.rs/varbincode" [dependencies] byteorder = "1.3" leb128 = "0.2" serde = "1.0" [dev-dependencies] serde_derive = "1.0" varbincode-0.1.0/Cargo.toml0000644000000020170000000000000112030ustar00# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] edition = "2018" name = "varbincode" version = "0.1.0" authors = ["Wez Furlong "] description = "A binary encoder / decoder with variable length integer encoding implementation in Rust." documentation = "https://docs.rs/varbincode" readme = "README.md" license = "MIT" repository = "https://github.com/wez/varbincode" [dependencies.byteorder] version = "1.3" [dependencies.leb128] version = "0.2" [dependencies.serde] version = "1.0" [dev-dependencies.serde_derive] version = "1.0" varbincode-0.1.0/LICENSE.md0100644€zÍO€oÓ-º000000020541347311761500145260ustar0000000000000000MIT License Copyright (c) 2019 Wez Furlong Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. varbincode-0.1.0/README.md0100644€zÍO€oÓ-º000000005371347311731100143760ustar0000000000000000# varbincode varbincode is a binary serialization format that uses variable length encoding for integer values, which typically results in reduced size of the encoded data. It is losely based on the `bincode` crate which is offered under an MIT license (same as the wezterm crate from which `varbincode` originates) and is Copyright 2014 Ty Overby. varbincode-0.1.0/src/de.rs0100644€zÍO€oÓ-º000000242601347311752400146510ustar0000000000000000use crate::error::{Error, Result}; use byteorder::{LittleEndian, ReadBytesExt}; use serde::de::IntoDeserializer; pub struct Deserializer<'a> { reader: &'a mut std::io::Read, } impl<'a> Deserializer<'a> { pub fn new(reader: &'a mut std::io::Read) -> Self { Self { reader } } fn read_signed(&mut self) -> Result { leb128::read::signed(&mut self.reader).map_err(Into::into) } fn read_unsigned(&mut self) -> Result { leb128::read::unsigned(&mut self.reader).map_err(Into::into) } fn read_vec(&mut self) -> Result> { let len: usize = serde::Deserialize::deserialize(&mut *self)?; let mut result = vec![0u8; len]; self.reader.read_exact(&mut result)?; Ok(result) } fn read_string(&mut self) -> Result { let vec = self.read_vec()?; String::from_utf8(vec).map_err(|e| Error::InvalidUtf8Encoding(e.utf8_error())) } } macro_rules! impl_uint { ($ty:ty, $dser_method:ident, $visitor_method:ident, $reader_method:ident) => { #[inline] fn $dser_method(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { let value = self.$reader_method()?; if value > <$ty>::max_value() as u64 { Err(Error::NumberOutOfRange) } else { visitor.$visitor_method(value as $ty) } } } } macro_rules! impl_int { ($ty:ty, $dser_method:ident, $visitor_method:ident, $reader_method:ident) => { #[inline] fn $dser_method(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { let value = self.$reader_method()?; if value < <$ty>::min_value() as i64 || value > <$ty>::max_value() as i64 { Err(Error::NumberOutOfRange) } else { visitor.$visitor_method(value as $ty) } } } } macro_rules! impl_float { ($dser_method:ident, $visitor_method:ident, $reader_method:ident) => { #[inline] fn $dser_method(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { let value = self.reader.$reader_method::()?; visitor.$visitor_method(value) } } } impl<'de, 'a, 'b> serde::Deserializer<'de> for &'a mut Deserializer<'b> { type Error = Error; #[inline] fn deserialize_u8(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_u8(self.reader.read_u8()?) } #[inline] fn deserialize_i8(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_i8(self.reader.read_i8()?) } impl_uint!(u16, deserialize_u16, visit_u16, read_unsigned); impl_uint!(u32, deserialize_u32, visit_u32, read_unsigned); impl_uint!(u64, deserialize_u64, visit_u64, read_unsigned); impl_int!(i16, deserialize_i16, visit_i16, read_signed); impl_int!(i32, deserialize_i32, visit_i32, read_signed); impl_int!(i64, deserialize_i64, visit_i64, read_signed); impl_float!(deserialize_f32, visit_f32, read_f32); impl_float!(deserialize_f64, visit_f64, read_f64); #[inline] fn deserialize_any(self, _visitor: V) -> Result where V: serde::de::Visitor<'de>, { Err(Error::DeserializeAnyNotSupported) } fn deserialize_bool(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { let value: u8 = serde::Deserialize::deserialize(self)?; match value { 1 => visitor.visit_bool(true), 0 => visitor.visit_bool(false), value => Err(Error::InvalidBoolEncoding(value).into()), } } fn deserialize_unit(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_unit() } fn deserialize_char(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { let value: u32 = serde::Deserialize::deserialize(self)?; match std::char::from_u32(value) { Some(c) => visitor.visit_char(c), None => Err(Error::InvalidCharEncoding(value)), } } fn deserialize_str(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_string(self.read_string()?) } fn deserialize_string(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_string(self.read_string()?) } fn deserialize_bytes(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_byte_buf(self.read_vec()?) } fn deserialize_byte_buf(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_byte_buf(self.read_vec()?) } fn deserialize_enum( self, _enum: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_enum(self) } fn deserialize_tuple(self, len: usize, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_seq(Access { deserializer: self, len, }) } fn deserialize_option(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { let value: u8 = serde::de::Deserialize::deserialize(&mut *self)?; match value { 0 => visitor.visit_none(), 1 => visitor.visit_some(&mut *self), v => Err(Error::InvalidTagEncoding(v as usize)), } } fn deserialize_seq(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { let len = serde::Deserialize::deserialize(&mut *self)?; self.deserialize_tuple(len, visitor) } fn deserialize_map(self, visitor: V) -> Result where V: serde::de::Visitor<'de>, { let len = serde::Deserialize::deserialize(&mut *self)?; visitor.visit_map(Access { deserializer: self, len, }) } fn deserialize_struct( self, _name: &str, fields: &'static [&'static str], visitor: V, ) -> Result where V: serde::de::Visitor<'de>, { self.deserialize_tuple(fields.len(), visitor) } fn deserialize_identifier(self, _visitor: V) -> Result where V: serde::de::Visitor<'de>, { Err(Error::DeserializeIdentifierNotSupported) } fn deserialize_newtype_struct(self, _name: &str, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_newtype_struct(self) } fn deserialize_unit_struct(self, _name: &'static str, visitor: V) -> Result where V: serde::de::Visitor<'de>, { visitor.visit_unit() } fn deserialize_tuple_struct( self, _name: &'static str, len: usize, visitor: V, ) -> Result where V: serde::de::Visitor<'de>, { self.deserialize_tuple(len, visitor) } fn deserialize_ignored_any(self, _visitor: V) -> Result where V: serde::de::Visitor<'de>, { Err(Error::DeserializeIgnoredAnyNotSupported) } fn is_human_readable(&self) -> bool { false } } struct Access<'a, 'b> { deserializer: &'a mut Deserializer<'b>, len: usize, } impl<'de, 'a, 'b> serde::de::SeqAccess<'de> for Access<'a, 'b> { type Error = Error; fn next_element_seed(&mut self, seed: T) -> Result> where T: serde::de::DeserializeSeed<'de>, { if self.len > 0 { self.len -= 1; let value = serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?; Ok(Some(value)) } else { Ok(None) } } fn size_hint(&self) -> Option { Some(self.len) } } impl<'de, 'a, 'b> serde::de::MapAccess<'de> for Access<'a, 'b> { type Error = Error; fn next_key_seed(&mut self, seed: K) -> Result> where K: serde::de::DeserializeSeed<'de>, { if self.len > 0 { self.len -= 1; let key = serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?; Ok(Some(key)) } else { Ok(None) } } fn next_value_seed(&mut self, seed: V) -> Result where V: serde::de::DeserializeSeed<'de>, { let value = serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?; Ok(value) } fn size_hint(&self) -> Option { Some(self.len) } } impl<'de, 'a, 'b> serde::de::EnumAccess<'de> for &'a mut Deserializer<'b> { type Error = Error; type Variant = Self; fn variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant)> where V: serde::de::DeserializeSeed<'de>, { let idx: u32 = serde::de::Deserialize::deserialize(&mut *self)?; let val: Result<_> = seed.deserialize(idx.into_deserializer()); Ok((val?, self)) } } impl<'de, 'a, 'b> serde::de::VariantAccess<'de> for &'a mut Deserializer<'b> { type Error = Error; fn unit_variant(self) -> Result<()> { Ok(()) } fn newtype_variant_seed(self, seed: T) -> Result where T: serde::de::DeserializeSeed<'de>, { serde::de::DeserializeSeed::deserialize(seed, self) } fn tuple_variant(self, len: usize, visitor: V) -> Result where V: serde::de::Visitor<'de>, { serde::de::Deserializer::deserialize_tuple(self, len, visitor) } fn struct_variant(self, fields: &'static [&'static str], visitor: V) -> Result where V: serde::de::Visitor<'de>, { serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor) } } varbincode-0.1.0/src/error.rs0100644€zÍO€oÓ-º000000043011347311674400154070ustar0000000000000000use serde::{de, ser}; use std::fmt::{self, Display}; #[derive(Clone, Debug, PartialEq)] pub enum Error { Message(String), Io(String), SequenceMustHaveLength, LebOverflow, DeserializeAnyNotSupported, DeserializeIdentifierNotSupported, DeserializeIgnoredAnyNotSupported, InvalidBoolEncoding(u8), InvalidCharEncoding(u32), InvalidUtf8Encoding(std::str::Utf8Error), InvalidTagEncoding(usize), NumberOutOfRange, } pub type Result = std::result::Result; impl ser::Error for Error { fn custom(msg: T) -> Self { Error::Message(msg.to_string()) } } impl de::Error for Error { fn custom(msg: T) -> Self { Error::Message(msg.to_string()) } } impl From for Error { fn from(err: std::io::Error) -> Error { Error::Io(format!("{}", err)) } } impl From for Error { fn from(err: leb128::read::Error) -> Error { match err { leb128::read::Error::IoError(err) => Error::Io(format!("{}", err)), leb128::read::Error::Overflow => Error::LebOverflow, } } } impl Display for Error { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str(std::error::Error::description(self)) } } impl std::error::Error for Error { fn description(&self) -> &str { match *self { Error::Message(ref msg) => msg, Error::Io(ref msg) => msg, Error::SequenceMustHaveLength => "SequenceMustHaveLength", Error::DeserializeAnyNotSupported => "DeserializeAnyNotSupported", Error::LebOverflow => "LEB128 Overflow", Error::InvalidBoolEncoding(_) => "Invalid Bool Encoding", Error::InvalidCharEncoding(_) => "Invalid char encoding", Error::DeserializeIdentifierNotSupported => "DeserializeIdentifierNotSupported", Error::DeserializeIgnoredAnyNotSupported => "DeserializeIgnoredAnyNotSupported", Error::InvalidUtf8Encoding(_) => "InvalidUtf8Encoding", Error::InvalidTagEncoding(_) => "InvalidTagEncoding", Error::NumberOutOfRange => "NumberOutOfRange", } } } varbincode-0.1.0/src/lib.rs0100644€zÍO€oÓ-º000000015701347311674400150310ustar0000000000000000//! varbincode is a binary serialization format that uses variable //! length encoding for integer values, which typically results in //! reduced size of the encoded data. pub mod de; pub mod error; pub mod ser; #[cfg(test)] mod test; pub use de::Deserializer; pub use ser::Serializer; /// A convenience function for serializing a value as a byte vector /// See also `ser::Serializer`. pub fn serialize(t: &T) -> Result, error::Error> { let mut result = Vec::new(); let mut s = Serializer::new(&mut result); t.serialize(&mut s)?; Ok(result) } /// A convenience function for deserializing from a stream. /// See also `de::Deserializer`. pub fn deserialize( mut r: R, ) -> Result { let mut d = Deserializer::new(&mut r); serde::Deserialize::deserialize(&mut d) } varbincode-0.1.0/src/ser.rs0100644€zÍO€oÓ-º000000176111347311674400150570ustar0000000000000000use crate::error::Error; use byteorder::{LittleEndian, WriteBytesExt}; use serde::ser; pub struct Serializer<'a> { writer: &'a mut std::io::Write, } impl<'a> Serializer<'a> { pub fn new(writer: &'a mut std::io::Write) -> Self { Self { writer } } fn write_signed(&mut self, val: i64) -> Result { leb128::write::signed(&mut self.writer, val) } fn write_unsigned(&mut self, val: u64) -> Result { leb128::write::unsigned(&mut self.writer, val) } } impl<'a, 'b> ser::Serializer for &'a mut Serializer<'b> { type Ok = (); type Error = Error; type SerializeSeq = Self; type SerializeTuple = Self; type SerializeTupleStruct = Self; type SerializeTupleVariant = Self; type SerializeMap = Self; type SerializeStruct = Self; type SerializeStructVariant = Self; fn serialize_bool(self, v: bool) -> Result<(), Error> { self.write_unsigned(if v { 1 } else { 0 })?; Ok(()) } fn serialize_unit(self) -> Result<(), Error> { Ok(()) } fn serialize_unit_struct(self, _: &'static str) -> Result<(), Error> { Ok(()) } fn serialize_u8(self, v: u8) -> Result<(), Error> { self.writer.write_u8(v as _)?; Ok(()) } fn serialize_u16(self, v: u16) -> Result<(), Error> { self.write_unsigned(v as _)?; Ok(()) } fn serialize_u32(self, v: u32) -> Result<(), Error> { self.write_unsigned(v as _)?; Ok(()) } fn serialize_u64(self, v: u64) -> Result<(), Error> { self.write_unsigned(v as _)?; Ok(()) } fn serialize_i8(self, v: i8) -> Result<(), Error> { self.writer.write_i8(v as _)?; Ok(()) } fn serialize_i16(self, v: i16) -> Result<(), Error> { self.write_signed(v as _)?; Ok(()) } fn serialize_i32(self, v: i32) -> Result<(), Error> { self.write_signed(v as _)?; Ok(()) } fn serialize_i64(self, v: i64) -> Result<(), Error> { self.write_signed(v as _)?; Ok(()) } fn serialize_f32(self, v: f32) -> Result<(), Error> { self.writer.write_f32::(v)?; Ok(()) } fn serialize_f64(self, v: f64) -> Result<(), Error> { self.writer.write_f64::(v)?; Ok(()) } fn serialize_str(self, v: &str) -> Result<(), Error> { self.serialize_bytes(v.as_bytes()) } fn serialize_char(self, c: char) -> Result<(), Error> { self.serialize_u32(c as u32) } fn serialize_bytes(self, v: &[u8]) -> Result<(), Error> { self.serialize_u64(v.len() as u64)?; self.writer.write_all(v)?; Ok(()) } fn serialize_none(self) -> Result<(), Error> { self.serialize_u8(0) } fn serialize_some(self, v: &T) -> Result<(), Error> { self.serialize_u8(1)?; v.serialize(self) } fn serialize_seq(self, len: Option) -> Result { let len = len.ok_or(Error::SequenceMustHaveLength)?; self.serialize_u64(len as u64)?; Ok(self) } fn serialize_tuple(self, _len: usize) -> Result { Ok(self) } fn serialize_tuple_struct( self, _name: &'static str, _len: usize, ) -> Result { Ok(self) } fn serialize_tuple_variant( self, _name: &'static str, variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { self.serialize_u32(variant_index)?; Ok(self) } fn serialize_map(self, len: Option) -> Result { let len = len.ok_or(Error::SequenceMustHaveLength)?; self.serialize_u64(len as u64)?; Ok(self) } fn serialize_struct( self, _name: &'static str, _len: usize, ) -> Result { Ok(self) } fn serialize_struct_variant( self, _name: &'static str, variant_index: u32, _variant: &'static str, _len: usize, ) -> Result { self.serialize_u32(variant_index)?; Ok(self) } fn serialize_newtype_struct( self, _name: &'static str, value: &T, ) -> Result<(), Error> where T: serde::ser::Serialize, { value.serialize(self) } fn serialize_newtype_variant( self, _name: &'static str, variant_index: u32, _variant: &'static str, value: &T, ) -> Result<(), Error> where T: serde::ser::Serialize, { self.serialize_u32(variant_index)?; value.serialize(self) } fn serialize_unit_variant( self, _name: &'static str, variant_index: u32, _variant: &'static str, ) -> Result<(), Error> { self.serialize_u32(variant_index) } fn is_human_readable(&self) -> bool { false } } impl<'a, 'b> ser::SerializeSeq for &'a mut Serializer<'b> { type Ok = (); type Error = Error; #[inline] fn serialize_element(&mut self, value: &T) -> Result<(), Error> where T: serde::ser::Serialize, { value.serialize(&mut **self) } #[inline] fn end(self) -> Result<(), Error> { Ok(()) } } impl<'a, 'b> ser::SerializeTuple for &'a mut Serializer<'b> { type Ok = (); type Error = Error; #[inline] fn serialize_element(&mut self, value: &T) -> Result<(), Error> where T: serde::ser::Serialize, { value.serialize(&mut **self) } #[inline] fn end(self) -> Result<(), Error> { Ok(()) } } impl<'a, 'b> ser::SerializeTupleStruct for &'a mut Serializer<'b> { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, value: &T) -> Result<(), Error> where T: serde::ser::Serialize, { value.serialize(&mut **self) } #[inline] fn end(self) -> Result<(), Error> { Ok(()) } } impl<'a, 'b> ser::SerializeTupleVariant for &'a mut Serializer<'b> { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, value: &T) -> Result<(), Error> where T: serde::ser::Serialize, { value.serialize(&mut **self) } #[inline] fn end(self) -> Result<(), Error> { Ok(()) } } impl<'a, 'b> ser::SerializeMap for &'a mut Serializer<'b> { type Ok = (); type Error = Error; #[inline] fn serialize_key(&mut self, value: &K) -> Result<(), Error> where K: serde::ser::Serialize, { value.serialize(&mut **self) } #[inline] fn serialize_value(&mut self, value: &V) -> Result<(), Error> where V: serde::ser::Serialize, { value.serialize(&mut **self) } #[inline] fn end(self) -> Result<(), Error> { Ok(()) } } impl<'a, 'b> ser::SerializeStruct for &'a mut Serializer<'b> { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<(), Error> where T: serde::ser::Serialize, { value.serialize(&mut **self) } #[inline] fn end(self) -> Result<(), Error> { Ok(()) } } impl<'a, 'b> ser::SerializeStructVariant for &'a mut Serializer<'b> { type Ok = (); type Error = Error; #[inline] fn serialize_field(&mut self, _key: &'static str, value: &T) -> Result<(), Error> where T: serde::ser::Serialize, { value.serialize(&mut **self) } #[inline] fn end(self) -> Result<(), Error> { Ok(()) } } varbincode-0.1.0/src/test.rs0100644€zÍO€oÓ-º000000056051347311674400152450ustar0000000000000000use super::{deserialize, serialize}; use serde::Serialize; use serde_derive::*; use std::collections::HashMap; fn same<'de, T: serde::de::DeserializeOwned + Serialize + std::fmt::Debug + PartialEq>(a: T) { let encoded = serialize(&a).unwrap(); let decoded: T = deserialize(encoded.as_slice()).unwrap(); assert_eq!(decoded, a); eprintln!("{:?} encoded as {:?}", a, encoded); } #[test] fn test() { same(0u8); same(1u8); same(1i8); same(0i8); same(0u16); same(255u16); same(0xffffu16); same(0x7fffi16); same(-0x7fffi16); same(0x00ff_ffffu32); same(0xffff_ffffu32); same(0x00ff_ffffu64); same(0xffff_ffffu64); same(0xffff_ffff_ffffu64); same(0xffff_ffff_ffff_ffffu64); same(0f32); same(10.5f32); same(10.5f64); same(-10.5f64); same("".to_string()); same("hello".to_string()); same((1u8,)); same((1u8, 2, 3)); same((1u8, "foo".to_string())); same(true); same(false); same(Some(true)); same(None::); same('c'); same(b'c'); } #[test] fn test_structs() { #[derive(Serialize, Deserialize, PartialEq, Debug)] struct Struct { a: isize, b: String, c: bool, }; #[derive(Serialize, Deserialize, PartialEq, Debug)] struct Outer { inner: Struct, b: bool, second: Struct, }; same(Struct { a: -42, b: "hello".to_string(), c: true, }); same(Outer { inner: Struct { a: 1, b: "bee".to_string(), c: false, }, b: true, second: Struct { a: 2, b: "other".to_string(), c: true, }, }); #[derive(Serialize, Deserialize, PartialEq, Debug)] struct NewType(usize); same(NewType(123)); #[derive(Serialize, Deserialize, PartialEq, Debug)] struct NewTypeTuple(usize, bool); same(NewTypeTuple(123, true)); } #[test] fn test_enum() { #[derive(Serialize, Deserialize, PartialEq, Debug)] enum TestEnum { NoArg, OneArg(usize), Args(usize, usize), AnotherNoArg, StructLike { x: usize, y: f32 }, } same(TestEnum::NoArg); same(TestEnum::OneArg(4)); same(TestEnum::Args(4, 5)); same(TestEnum::AnotherNoArg); same(TestEnum::StructLike { x: 4, y: 3.14159 }); same(vec![ TestEnum::NoArg, TestEnum::OneArg(5), TestEnum::AnotherNoArg, TestEnum::StructLike { x: 4, y: 1.4 }, ]); } #[test] fn test_vec() { let v: Vec = vec![]; same(v); same(vec![1u64]); same(vec![1u64, 2, 3, 4, 5, 6]); } #[test] fn test_map() { let mut m = HashMap::new(); m.insert(4u64, "foo".to_string()); m.insert(0u64, "bar".to_string()); same(m); } #[test] fn test_fixed_size_array() { same([24u32; 32]); same([1u64, 2, 3, 4, 5, 6, 7, 8]); same([0u8; 19]); } varbincode-0.1.0/.cargo_vcs_info.json0000644000000001120000000000000131770ustar00{ "git": { "sha1": "1d349ef0723590a4bfcbc86aee17f528adc6587b" } }