From 1631cb2d8089de6c17291714a3a7914a5cdfffcd Mon Sep 17 00:00:00 2001 From: Ty Overby Date: Fri, 24 Feb 2017 18:58:46 -0800 Subject: [PATCH] Make Reader and Writer generic on Endianness (#103) * Make Reader and Writer generic on Endianness * make alternate API modules * add test asserting that big endian encoding is different from little endian encoding * clean up tests --- src/lib.rs | 58 ++++++++++++++++- src/serde/mod.rs | 20 +++--- src/serde/reader.rs | 40 ++++++------ src/serde/writer.rs | 75 +++++++++++----------- tests/test.rs | 148 +++++++++++++++++++++++--------------------- 5 files changed, 205 insertions(+), 136 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index c76e219..2982637 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -43,7 +43,63 @@ extern crate serde as serde_crate; pub mod refbox; mod serde; -pub use serde::*; +pub mod endian_choice { + pub use super::serde::{serialize, serialize_into, deserialize, deserialize_from}; +} + +use std::io::{Read, Write}; + +pub use serde::{Deserializer, Serializer, ErrorKind, Error, Result, serialized_size, serialized_size_bounded}; + +/// Deserializes a slice of bytes into an object. +/// +/// This method does not have a size-limit because if you already have the bytes +/// in memory, then you don't gain anything by having a limiter. +pub fn deserialize(bytes: &[u8]) -> serde::Result + where T: serde_crate::Deserialize, +{ + serde::deserialize::<_, byteorder::LittleEndian>(bytes) +} + +/// Deserializes an object directly from a `Buffer`ed Reader. +/// +/// If the provided `SizeLimit` is reached, the deserialization will bail immediately. +/// A SizeLimit can help prevent an attacker from flooding your server with +/// a neverending stream of values that runs your server out of memory. +/// +/// If this returns an `Error`, assume that the buffer that you passed +/// in is in an invalid state, as the error could be returned during any point +/// in the reading. +pub fn deserialize_from(reader: &mut R, size_limit: SizeLimit) -> serde::Result + where R: Read, + T: serde_crate::Deserialize, +{ + serde::deserialize_from::<_, _, byteorder::LittleEndian>(reader, size_limit) +} + +/// Serializes an object directly into a `Writer`. +/// +/// If the serialization would take more bytes than allowed by `size_limit`, an error +/// is returned and *no bytes* will be written into the `Writer`. +/// +/// If this returns an `Error` (other than SizeLimit), assume that the +/// writer is in an invalid state, as writing could bail out in the middle of +/// serializing. +pub fn serialize_into(writer: &mut W, value: &T, size_limit: SizeLimit) -> serde::Result<()> + where W: Write, T: serde_crate::Serialize +{ + serde::serialize_into::<_, _, byteorder::LittleEndian>(writer, value, size_limit) +} + +/// Serializes a serializable object into a `Vec` of bytes. +/// +/// If the serialization would take more bytes than allowed by `size_limit`, +/// an error is returned. +pub fn serialize(value: &T, size_limit: SizeLimit) -> serde::Result> + where T: serde_crate::Serialize +{ + serde::serialize::<_, byteorder::LittleEndian>(value, size_limit) +} /// A limit on the amount of bytes that can be read or written. /// diff --git a/src/serde/mod.rs b/src/serde/mod.rs index 3ac623a..9caeb0a 100644 --- a/src/serde/mod.rs +++ b/src/serde/mod.rs @@ -6,6 +6,7 @@ use std::io::{Write, Read}; use std::io::Error as IoError; use std::{error, fmt, result}; use ::SizeLimit; +use byteorder::{ByteOrder}; pub use self::reader::{ Deserializer, @@ -118,9 +119,8 @@ impl serde::ser::Error for Error { /// If this returns an `Error` (other than SizeLimit), assume that the /// writer is in an invalid state, as writing could bail out in the middle of /// serializing. -pub fn serialize_into(writer: &mut W, value: &T, size_limit: SizeLimit) -> Result<()> - where W: Write, - T: serde::Serialize, +pub fn serialize_into(writer: &mut W, value: &T, size_limit: SizeLimit) -> Result<()> + where W: Write, T: serde::Serialize, E: ByteOrder { match size_limit { SizeLimit::Infinite => { } @@ -130,7 +130,7 @@ pub fn serialize_into(writer: &mut W, value: &T, size_limi } } - let mut serializer = Serializer::new(writer); + let mut serializer = Serializer::<_, E>::new(writer); serde::Serialize::serialize(value, &mut serializer) } @@ -138,7 +138,7 @@ pub fn serialize_into(writer: &mut W, value: &T, size_limi /// /// If the serialization would take more bytes than allowed by `size_limit`, /// an error is returned. -pub fn serialize(value: &T, size_limit: SizeLimit) -> Result> +pub fn serialize(value: &T, size_limit: SizeLimit) -> Result> where T: serde::Serialize { // Since we are putting values directly into a vector, we can do size @@ -152,7 +152,7 @@ pub fn serialize(value: &T, size_limit: SizeLimit) -> Result> SizeLimit::Infinite => Vec::new() }; - try!(serialize_into(&mut writer, value, SizeLimit::Infinite)); + try!(serialize_into::<_, _, E>(&mut writer, value, SizeLimit::Infinite)); Ok(writer) } @@ -190,11 +190,11 @@ pub fn serialized_size_bounded(value: &T, max: u64) -> Option /// If this returns an `Error`, assume that the buffer that you passed /// in is in an invalid state, as the error could be returned during any point /// in the reading. -pub fn deserialize_from(reader: &mut R, size_limit: SizeLimit) -> Result +pub fn deserialize_from(reader: &mut R, size_limit: SizeLimit) -> Result where R: Read, T: serde::Deserialize, { - let mut deserializer = Deserializer::new(reader, size_limit); + let mut deserializer = Deserializer::<_, E>::new(reader, size_limit); serde::Deserialize::deserialize(&mut deserializer) } @@ -202,9 +202,9 @@ pub fn deserialize_from(reader: &mut R, size_limit: SizeLimit) -> /// /// This method does not have a size-limit because if you already have the bytes /// in memory, then you don't gain anything by having a limiter. -pub fn deserialize(bytes: &[u8]) -> Result +pub fn deserialize(bytes: &[u8]) -> Result where T: serde::Deserialize, { let mut reader = bytes; - deserialize_from(&mut reader, SizeLimit::Infinite) + deserialize_from::<_, _, E>(&mut reader, SizeLimit::Infinite) } diff --git a/src/serde/reader.rs b/src/serde/reader.rs index 29d2db7..8d6e2db 100644 --- a/src/serde/reader.rs +++ b/src/serde/reader.rs @@ -1,6 +1,7 @@ use std::io::Read; +use std::marker::PhantomData; -use byteorder::{BigEndian, ReadBytesExt}; +use byteorder::{ReadBytesExt, ByteOrder}; use serde_crate as serde; use serde_crate::de::value::ValueDeserializer; use serde_crate::de::Error as DeError; @@ -17,18 +18,20 @@ use super::{Result, Error, ErrorKind}; /// serde::Deserialize::deserialize(&mut deserializer); /// let bytes_read = d.bytes_read(); /// ``` -pub struct Deserializer { +pub struct Deserializer { reader: R, size_limit: SizeLimit, - read: u64 + read: u64, + _phantom: PhantomData, } -impl Deserializer { - pub fn new(r: R, size_limit: SizeLimit) -> Deserializer { +impl Deserializer { + pub fn new(r: R, size_limit: SizeLimit) -> Deserializer { Deserializer { reader: r, size_limit: size_limit, - read: 0 + read: 0, + _phantom: PhantomData } } @@ -78,14 +81,13 @@ macro_rules! impl_nums { where V: serde::de::Visitor, { try!(self.read_type::<$ty>()); - let value = try!(self.reader.$reader_method::()); + let value = try!(self.reader.$reader_method::()); visitor.$visitor_method(value) } } } - -impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer { +impl<'a, R: Read, E: ByteOrder> serde::Deserializer for &'a mut Deserializer { type Error = Error; #[inline] @@ -212,7 +214,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer { visitor: V) -> Result where V: serde::de::Visitor, { - impl<'a, R: Read + 'a> serde::de::EnumVisitor for &'a mut Deserializer { + impl<'a, R: Read + 'a, E: ByteOrder> serde::de::EnumVisitor for &'a mut Deserializer { type Error = Error; type Variant = Self; @@ -233,9 +235,9 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer { visitor: V) -> Result where V: serde::de::Visitor, { - struct TupleVisitor<'a, R: Read + 'a>(&'a mut Deserializer); + struct TupleVisitor<'a, R: Read + 'a, E: ByteOrder + 'a>(&'a mut Deserializer); - impl<'a, 'b: 'a, R: Read + 'b> serde::de::SeqVisitor for TupleVisitor<'a, R> { + impl<'a, 'b: 'a, R: Read + 'b, E: ByteOrder> serde::de::SeqVisitor for TupleVisitor<'a, R, E> { type Error = Error; fn visit_seed(&mut self, seed: T) -> Result> @@ -254,12 +256,12 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer { visitor: V) -> Result where V: serde::de::Visitor, { - struct SeqVisitor<'a, R: Read + 'a> { - deserializer: &'a mut Deserializer, + struct SeqVisitor<'a, R: Read + 'a, E: ByteOrder + 'a> { + deserializer: &'a mut Deserializer, len: usize, } - impl<'a, 'b: 'a, R: Read + 'b> serde::de::SeqVisitor for SeqVisitor<'a, R> { + impl<'a, 'b: 'a, R: Read + 'b, E: ByteOrder> serde::de::SeqVisitor for SeqVisitor<'a, R, E> { type Error = Error; fn visit_seed(&mut self, seed: T) -> Result> @@ -303,12 +305,12 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer { fn deserialize_map(self, visitor: V) -> Result where V: serde::de::Visitor, { - struct MapVisitor<'a, R: Read + 'a> { - deserializer: &'a mut Deserializer, + struct MapVisitor<'a, R: Read + 'a, E: ByteOrder + 'a> { + deserializer: &'a mut Deserializer, len: usize, } - impl<'a, 'b: 'a, R: Read + 'b> serde::de::MapVisitor for MapVisitor<'a, R> { + impl<'a, 'b: 'a, R: Read + 'b, E: ByteOrder> serde::de::MapVisitor for MapVisitor<'a, R, E> { type Error = Error; fn visit_key_seed(&mut self, seed: K) -> Result> @@ -387,7 +389,7 @@ impl<'a, R: Read> serde::Deserializer for &'a mut Deserializer { } } -impl<'a, R: Read> serde::de::VariantVisitor for &'a mut Deserializer { +impl<'a, R: Read, E: ByteOrder> serde::de::VariantVisitor for &'a mut Deserializer { type Error = Error; fn visit_unit(self) -> Result<()> { diff --git a/src/serde/writer.rs b/src/serde/writer.rs index b44a6bf..3bb10fc 100644 --- a/src/serde/writer.rs +++ b/src/serde/writer.rs @@ -1,9 +1,10 @@ use std::io::Write; use std::u32; +use std::marker::PhantomData; use serde_crate as serde; -use byteorder::{BigEndian, WriteBytesExt}; +use byteorder::{WriteBytesExt, ByteOrder}; use super::{Result, Error, ErrorKind}; @@ -11,14 +12,16 @@ use super::{Result, Error, ErrorKind}; /// /// This struct should not be used often. /// For most cases, prefer the `encode_into` function. -pub struct Serializer { +pub struct Serializer { writer: W, + _phantom: PhantomData, } -impl Serializer { - pub fn new(w: W) -> Serializer { +impl Serializer { + pub fn new(w: W) -> Serializer { Serializer { writer: w, + _phantom: PhantomData, } } @@ -31,16 +34,16 @@ impl Serializer { } } -impl<'a, W: Write> serde::Serializer for &'a mut Serializer { +impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer { type Ok = (); type Error = Error; - type SerializeSeq = Compound<'a, W>; - type SerializeTuple = Compound<'a, W>; - type SerializeTupleStruct = Compound<'a, W>; - type SerializeTupleVariant = Compound<'a, W>; - type SerializeMap = Compound<'a, W>; - type SerializeStruct = Compound<'a, W>; - type SerializeStructVariant = Compound<'a, W>; + type SerializeSeq = Compound<'a, W, E>; + type SerializeTuple = Compound<'a, W, E>; + type SerializeTupleStruct = Compound<'a, W, E>; + type SerializeTupleVariant = Compound<'a, W, E>; + type SerializeMap = Compound<'a, W, E>; + type SerializeStruct = Compound<'a, W, E>; + type SerializeStructVariant = Compound<'a, W, E>; fn serialize_unit(self) -> Result<()> { Ok(()) } @@ -55,15 +58,15 @@ impl<'a, W: Write> serde::Serializer for &'a mut Serializer { } fn serialize_u16(self, v: u16) -> Result<()> { - self.writer.write_u16::(v).map_err(Into::into) + self.writer.write_u16::(v).map_err(Into::into) } fn serialize_u32(self, v: u32) -> Result<()> { - self.writer.write_u32::(v).map_err(Into::into) + self.writer.write_u32::(v).map_err(Into::into) } fn serialize_u64(self, v: u64) -> Result<()> { - self.writer.write_u64::(v).map_err(Into::into) + self.writer.write_u64::(v).map_err(Into::into) } fn serialize_i8(self, v: i8) -> Result<()> { @@ -71,23 +74,23 @@ impl<'a, W: Write> serde::Serializer for &'a mut Serializer { } fn serialize_i16(self, v: i16) -> Result<()> { - self.writer.write_i16::(v).map_err(Into::into) + self.writer.write_i16::(v).map_err(Into::into) } fn serialize_i32(self, v: i32) -> Result<()> { - self.writer.write_i32::(v).map_err(Into::into) + self.writer.write_i32::(v).map_err(Into::into) } fn serialize_i64(self, v: i64) -> Result<()> { - self.writer.write_i64::(v).map_err(Into::into) + self.writer.write_i64::(v).map_err(Into::into) } fn serialize_f32(self, v: f32) -> Result<()> { - self.writer.write_f32::(v).map_err(Into::into) + self.writer.write_f32::(v).map_err(Into::into) } fn serialize_f64(self, v: f64) -> Result<()> { - self.writer.write_f64::(v).map_err(Into::into) + self.writer.write_f64::(v).map_err(Into::into) } fn serialize_str(self, v: &str) -> Result<()> { @@ -384,12 +387,12 @@ impl<'a> serde::Serializer for &'a mut SizeChecker { } #[doc(hidden)] -pub struct Compound<'a, W: 'a> { - ser: &'a mut Serializer, +pub struct Compound<'a, W: 'a, E: ByteOrder + 'a> { + ser: &'a mut Serializer, } -impl<'a, W> serde::ser::SerializeSeq for Compound<'a, W> - where W: Write +impl<'a, W, E> serde::ser::SerializeSeq for Compound<'a, W, E> + where W: Write, E: ByteOrder { type Ok = (); type Error = Error; @@ -407,8 +410,8 @@ impl<'a, W> serde::ser::SerializeSeq for Compound<'a, W> } } -impl<'a, W> serde::ser::SerializeTuple for Compound<'a, W> - where W: Write +impl<'a, W, E> serde::ser::SerializeTuple for Compound<'a, W, E> + where W: Write, E: ByteOrder { type Ok = (); type Error = Error; @@ -426,8 +429,8 @@ impl<'a, W> serde::ser::SerializeTuple for Compound<'a, W> } } -impl<'a, W> serde::ser::SerializeTupleStruct for Compound<'a, W> - where W: Write +impl<'a, W, E> serde::ser::SerializeTupleStruct for Compound<'a, W, E> + where W: Write, E: ByteOrder { type Ok = (); type Error = Error; @@ -445,8 +448,8 @@ impl<'a, W> serde::ser::SerializeTupleStruct for Compound<'a, W> } } -impl<'a, W> serde::ser::SerializeTupleVariant for Compound<'a, W> - where W: Write +impl<'a, W, E> serde::ser::SerializeTupleVariant for Compound<'a, W, E> + where W: Write, E: ByteOrder { type Ok = (); type Error = Error; @@ -464,8 +467,8 @@ impl<'a, W> serde::ser::SerializeTupleVariant for Compound<'a, W> } } -impl<'a, W> serde::ser::SerializeMap for Compound<'a, W> - where W: Write +impl<'a, W, E> serde::ser::SerializeMap for Compound<'a, W, E> + where W: Write, E: ByteOrder { type Ok = (); type Error = Error; @@ -490,8 +493,8 @@ impl<'a, W> serde::ser::SerializeMap for Compound<'a, W> } } -impl<'a, W> serde::ser::SerializeStruct for Compound<'a, W> - where W: Write +impl<'a, W, E> serde::ser::SerializeStruct for Compound<'a, W, E> + where W: Write, E: ByteOrder { type Ok = (); type Error = Error; @@ -509,8 +512,8 @@ impl<'a, W> serde::ser::SerializeStruct for Compound<'a, W> } } -impl<'a, W> serde::ser::SerializeStructVariant for Compound<'a, W> - where W: Write +impl<'a, W, E> serde::ser::SerializeStructVariant for Compound<'a, W, E> + where W: Write, E: ByteOrder { type Ok = (); type Error = Error; diff --git a/tests/test.rs b/tests/test.rs index 2d109e3..2c8fe8b 100644 --- a/tests/test.rs +++ b/tests/test.rs @@ -3,6 +3,7 @@ extern crate serde_derive; extern crate bincode; extern crate serde; +extern crate byteorder; use std::fmt::Debug; use std::collections::HashMap; @@ -10,29 +11,13 @@ use std::ops::Deref; use bincode::refbox::{RefBox, StrBox, SliceBox}; -use bincode::SizeLimit::{self, Infinite, Bounded}; -use bincode::{serialize, serialized_size, deserialize, deserialize_from, ErrorKind, Result}; +use bincode::SizeLimit::{Infinite, Bounded}; +use bincode::{serialized_size, ErrorKind, Result}; +use bincode::endian_choice::{serialize, deserialize}; -fn proxy_encode(element: &V, size_limit: SizeLimit) -> Vec - where V: serde::Serialize + serde::Deserialize + PartialEq + Debug + 'static -{ - let v2 = serialize(element, size_limit).unwrap(); - v2 -} - -fn proxy_decode(slice: &[u8]) -> V - where V: serde::Serialize + serde::Deserialize + PartialEq + Debug + 'static -{ - let e2 = deserialize(slice).unwrap(); - e2 -} - -fn proxy_encoded_size(element: &V) -> u64 - where V: serde::Serialize + PartialEq + Debug + 'static -{ - let serde_size = serialized_size(element); - serde_size -} +use bincode::serialize as serialize_little; +use bincode::deserialize as deserialize_little; +use bincode::deserialize_from as deserialize_from_little; fn the_same(element: V) where V: serde::Serialize+serde::Deserialize+PartialEq+Debug+'static @@ -42,20 +27,35 @@ fn the_same(element: V) where V: serde::Serialize + serde::Deserialize + PartialEq + Debug + 'static { let rf = RefBox::new(v); - let encoded = serialize(&rf, Infinite).unwrap(); - let decoded: RefBox<'static, V> = deserialize(&encoded[..]).unwrap(); + let encoded = serialize_little(&rf, Infinite).unwrap(); + let decoded: RefBox<'static, V> = deserialize_little(&encoded[..]).unwrap(); decoded.take().deref() == v } - let size = proxy_encoded_size(&element); + let size = serialized_size(&element); - let encoded = proxy_encode(&element, Infinite); - let decoded = proxy_decode(&encoded[..]); + { + let encoded = serialize_little(&element, Infinite); + let encoded = encoded.unwrap(); + let decoded = deserialize_little(&encoded[..]); + let decoded = decoded.unwrap(); - assert_eq!(element, decoded); - assert_eq!(size, encoded.len() as u64); - assert!(ref_box_correct(&element)); + assert_eq!(element, decoded); + assert_eq!(size, encoded.len() as u64); + assert!(ref_box_correct(&element)); + } + + { + let encoded = serialize::<_, byteorder::BigEndian>(&element, Infinite); + let encoded = encoded.unwrap(); + let decoded = deserialize::<_, byteorder::BigEndian>(&encoded[..]); + let decoded = decoded.unwrap(); + + assert_eq!(element, decoded); + assert_eq!(size, encoded.len() as u64); + assert!(ref_box_correct(&element)); + } } #[test] @@ -220,26 +220,26 @@ fn deserializing_errors() { } } - isize_invalid_deserialize(deserialize::(&vec![0xA][..])); - isize_invalid_deserialize(deserialize::(&vec![0, 0, 0, 0, 0, 0, 0, 1, 0xFF][..])); + isize_invalid_deserialize(deserialize_little::(&vec![0xA][..])); + isize_invalid_deserialize(deserialize_little::(&vec![0, 0, 0, 0, 0, 0, 0, 1, 0xFF][..])); // Out-of-bounds variant #[derive(Serialize, Deserialize, Debug)] enum Test { One, Two, }; - isize_invalid_deserialize(deserialize::(&vec![0, 0, 0, 5][..])); - isize_invalid_deserialize(deserialize::>(&vec![5, 0][..])); + isize_invalid_deserialize(deserialize_little::(&vec![0, 0, 0, 5][..])); + isize_invalid_deserialize(deserialize_little::>(&vec![5, 0][..])); } #[test] fn too_big_deserialize() { let serialized = vec![0,0,0,3]; - let deserialized: Result = deserialize_from(&mut &serialized[..], Bounded(3)); + let deserialized: Result = deserialize_from_little::<_, _>(&mut &serialized[..], Bounded(3)); assert!(deserialized.is_err()); let serialized = vec![0,0,0,3]; - let deserialized: Result = deserialize_from(&mut &serialized[..], Bounded(4)); + let deserialized: Result = deserialize_from_little::<_, _>(&mut &serialized[..], Bounded(4)); assert!(deserialized.is_ok()); } @@ -247,8 +247,8 @@ fn too_big_deserialize() { fn char_serialization() { let chars = "Aa\0☺♪"; for c in chars.chars() { - let encoded = serialize(&c, Bounded(4)).expect("serializing char failed"); - let decoded: char = deserialize(&encoded).expect("deserializing failed"); + let encoded = serialize_little(&c, Bounded(4)).expect("serializing char failed"); + let decoded: char = deserialize_little(&encoded).expect("deserializing failed"); assert_eq!(decoded, c); } } @@ -256,47 +256,47 @@ fn char_serialization() { #[test] fn too_big_char_deserialize() { let serialized = vec![0x41]; - let deserialized: Result = deserialize_from(&mut &serialized[..], Bounded(1)); + let deserialized: Result = deserialize_from_little::<_, _>(&mut &serialized[..], Bounded(1)); assert!(deserialized.is_ok()); assert_eq!(deserialized.unwrap(), 'A'); } #[test] fn too_big_serialize() { - assert!(serialize(&0u32, Bounded(3)).is_err()); - assert!(serialize(&0u32, Bounded(4)).is_ok()); + assert!(serialize_little(&0u32, Bounded(3)).is_err()); + assert!(serialize_little(&0u32, Bounded(4)).is_ok()); - assert!(serialize(&"abcde", Bounded(8 + 4)).is_err()); - assert!(serialize(&"abcde", Bounded(8 + 5)).is_ok()); + assert!(serialize_little(&"abcde", Bounded(8 + 4)).is_err()); + assert!(serialize_little(&"abcde", Bounded(8 + 5)).is_ok()); } #[test] fn test_proxy_encoded_size() { - assert!(proxy_encoded_size(&0u8) == 1); - assert!(proxy_encoded_size(&0u16) == 2); - assert!(proxy_encoded_size(&0u32) == 4); - assert!(proxy_encoded_size(&0u64) == 8); + assert!(serialized_size(&0u8) == 1); + assert!(serialized_size(&0u16) == 2); + assert!(serialized_size(&0u32) == 4); + assert!(serialized_size(&0u64) == 8); // length isize stored as u64 - assert!(proxy_encoded_size(&"") == 8); - assert!(proxy_encoded_size(&"a") == 8 + 1); + assert!(serialized_size(&"") == 8); + assert!(serialized_size(&"a") == 8 + 1); - assert!(proxy_encoded_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) + assert!(serialized_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) } #[test] fn test_serialized_size() { - assert!(proxy_encoded_size(&0u8) == 1); - assert!(proxy_encoded_size(&0u16) == 2); - assert!(proxy_encoded_size(&0u32) == 4); - assert!(proxy_encoded_size(&0u64) == 8); + assert!(serialized_size(&0u8) == 1); + assert!(serialized_size(&0u16) == 2); + assert!(serialized_size(&0u32) == 4); + assert!(serialized_size(&0u64) == 8); // length isize stored as u64 - assert!(proxy_encoded_size(&"") == 8); - assert!(proxy_encoded_size(&"a") == 8 + 1); + assert!(serialized_size(&"") == 8); + assert!(serialized_size(&"a") == 8 + 1); - assert!(proxy_encoded_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) + assert!(serialized_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) } #[test] @@ -319,8 +319,8 @@ fn test_refbox_serialize() { // Test 1 { - let serialized = serialize(&Message::M1(RefBox::new(&large_object)), Infinite).unwrap(); - let deserialized: Message<'static> = deserialize_from(&mut &serialized[..], Infinite).unwrap(); + let serialized = serialize_little(&Message::M1(RefBox::new(&large_object)), Infinite).unwrap(); + let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); match deserialized { Message::M1(b) => assert!(b.take().deref() == &large_object), @@ -330,8 +330,8 @@ fn test_refbox_serialize() { // Test 2 { - let serialized = serialize(&Message::M2(RefBox::new(&large_map)), Infinite).unwrap(); - let deserialized: Message<'static> = deserialize_from(&mut &serialized[..], Infinite).unwrap(); + let serialized = serialize_little(&Message::M2(RefBox::new(&large_map)), Infinite).unwrap(); + let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); match deserialized { Message::M2(b) => assert!(b.take().deref() == &large_map), @@ -343,8 +343,8 @@ fn test_refbox_serialize() { #[test] fn test_strbox_serialize() { let strx: &'static str = "hello world"; - let serialized = serialize(&StrBox::new(strx), Infinite).unwrap(); - let deserialized: StrBox<'static> = deserialize_from(&mut &serialized[..], Infinite).unwrap(); + let serialized = serialize_little(&StrBox::new(strx), Infinite).unwrap(); + let deserialized: StrBox<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); let stringx: String = deserialized.take(); assert!(strx == &stringx[..]); } @@ -352,8 +352,8 @@ fn test_strbox_serialize() { #[test] fn test_slicebox_serialize() { let slice = [1u32, 2, 3 ,4, 5]; - let serialized = serialize(&SliceBox::new(&slice), Infinite).unwrap(); - let deserialized: SliceBox<'static, u32> = deserialize_from(&mut &serialized[..], Infinite).unwrap(); + let serialized = serialize_little(&SliceBox::new(&slice), Infinite).unwrap(); + let deserialized: SliceBox<'static, u32> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap(); { let sb: &[u32] = &deserialized; assert!(slice == sb); @@ -364,7 +364,7 @@ fn test_slicebox_serialize() { #[test] fn test_multi_strings_serialize() { - assert!(serialize(&("foo", "bar", "baz"), Infinite).is_ok()); + assert!(serialize_little(&("foo", "bar", "baz"), Infinite).is_ok()); } /* @@ -384,8 +384,8 @@ fn test_oom_protection() { fn path_buf() { use std::path::{Path, PathBuf}; let path = Path::new("foo").to_path_buf(); - let serde_encoded = serialize(&path, Infinite).unwrap(); - let decoded: PathBuf = deserialize(&serde_encoded).unwrap(); + let serde_encoded = serialize_little(&path, Infinite).unwrap(); + let decoded: PathBuf = deserialize_little(&serde_encoded).unwrap(); assert!(path.to_str() == decoded.to_str()); } @@ -394,8 +394,16 @@ fn bytes() { use serde::bytes::Bytes; let data = b"abc\0123"; - let s = serialize(&data, Infinite).unwrap(); - let s2 = serialize(&Bytes::new(data), Infinite).unwrap(); + let s = serialize_little(&data, Infinite).unwrap(); + let s2 = serialize_little(&Bytes::new(data), Infinite).unwrap(); assert_eq!(s[..], s2[8..]); } + +#[test] +fn endian_difference() { + let x = 10u64; + let little = serialize_little(&x, Infinite).unwrap(); + let big = serialize::<_, byteorder::BigEndian>(&x, Infinite).unwrap(); + assert_ne!(little, big); +}