use log::debug;
use serde::Deserialize;
use serde::de::{self, DeserializeSeed, MapAccess, SeqAccess, Visitor};
use bitvec::prelude::LittleEndian;
use bitvec::bits::BitsMut;
use crate::error::{Error, Result};
use std::convert::TryFrom;
use crate::{U8_SIZE, U16_SIZE, U32_SIZE, U64_SIZE};
use std::slice::SliceIndex;
pub struct Deserializer<'de> {
input: &'de [u8],
}
impl<'de> Deserializer<'de> {
pub fn from_bytes(input: &'de [u8]) -> Self {
Self { input }
}
fn peek_byte(&self) -> Result<u8> {
match self.input.get(0) {
Some(b) => Ok(*b),
None => Err(Error::Eof),
}
}
fn peek_bytes<I: SliceIndex<[u8]>>(&self, index: I) -> Result<&<I as SliceIndex<[u8]>>::Output> {
match self.input.get(index) {
Some(b) => Ok(b),
None => Err(Error::Eof),
}
}
fn consume_padding(&mut self) -> Result<()> {
while self.peek_byte()? == 0x00 {
self.consume_bytes(1);
}
Ok(())
}
fn next_byte(&mut self) -> Result<u8> {
let b = self.peek_byte()?;
self.consume_bytes(1);
Ok(b)
}
fn consume_bytes(&mut self, n: usize) {
self.input = &self.input[n..];
}
fn consume_header(&mut self) {
self.consume_bytes(1);
}
fn consume_u8(&mut self) -> Result<u8> {
let mut bytes: [u8; U8_SIZE] = Default::default();
bytes.copy_from_slice(self.peek_bytes(..U8_SIZE)?);
self.consume_bytes(U8_SIZE);
Ok(u8::from_le_bytes(bytes))
}
fn consume_u16(&mut self) -> Result<u16> {
let mut bytes: [u8; U16_SIZE] = Default::default();
bytes.copy_from_slice(self.peek_bytes(..U16_SIZE)?);
self.consume_bytes(U16_SIZE);
Ok(u16::from_le_bytes(bytes))
}
fn consume_u32(&mut self) -> Result<u32> {
let mut bytes: [u8; U32_SIZE] = Default::default();
bytes.copy_from_slice(self.peek_bytes(..U32_SIZE)?);
self.consume_bytes(U32_SIZE);
Ok(u32::from_le_bytes(bytes))
}
fn consume_u64(&mut self) -> Result<u64> {
let mut bytes: [u8; U64_SIZE] = Default::default();
bytes.copy_from_slice(self.peek_bytes(..U64_SIZE)?);
self.consume_bytes(U64_SIZE);
Ok(u64::from_le_bytes(bytes))
}
fn parse_bool(&mut self) -> Result<bool> {
match self.peek_byte()? {
0x19 => {
debug!("0x19 -> deserializing boolean [false]");
self.consume_bytes(1);
Ok(false)
},
0x1a => {
debug!("0x1a -> deserializing boolean [true]");
self.consume_bytes(1);
Ok(true)
},
_ => Err(Error::ExpectedBoolean),
}
}
fn parse_double(&mut self) -> Result<f64> {
match self.peek_byte()? {
0x1b => {
debug!("0x1b -> deserializing double");
self.consume_bytes(1)
},
_ => return Err(Error::ExpectedDouble),
}
let mut bytes: [u8; 8] = Default::default();
bytes.copy_from_slice(&self.input[..8]);
let v = f64::from_bits(u64::from_le_bytes(bytes));
self.consume_bytes(8);
Ok(v)
}
fn parse_signed<T: TryFrom<i64> + TryFrom<u64>>(&mut self) -> Result<T> {
match self.peek_byte()? {
b if b >= 0x3a && b <= 0x3f => {
debug!("0x{:x?} -> deserializing small negative integer", b);
self.consume_bytes(1);
Ok(T::try_from(-(0x40 - (b as i64))).unwrap_or_else(|_| panic!("Unable to convert to signed")))
},
b if b >= 0x20 && b <= 0x27 => {
debug!("0x{:x?} -> deserializing signed integer (1 to 8 bytes)", b);
let n_bytes = (b - 0x1f) as usize;
self.consume_header();
let v: i64 = match n_bytes {
1 => {
let mut le_bytes: [u8; 1] = [0x00; 1];
le_bytes[..n_bytes].copy_from_slice(&self.input[..n_bytes]);
i8::from_le_bytes(le_bytes) as i64
},
2 => {
let mut le_bytes: [u8; 2] = [0x00; 2];
le_bytes[..n_bytes].copy_from_slice(&self.input[..n_bytes]);
i16::from_le_bytes(le_bytes) as i64
},
4 => {
let mut le_bytes: [u8; 4] = [0x00; 4];
le_bytes[..n_bytes].copy_from_slice(&self.input[..n_bytes]);
i32::from_le_bytes(le_bytes) as i64
},
8 => {
let mut le_bytes: [u8; 8] = [0x00; 8];
le_bytes[..n_bytes].copy_from_slice(&self.input[..n_bytes]);
i64::from_le_bytes(le_bytes)
},
n => {
let msg = format!("Invalid byte length for signed integer: {} (valid: 1, 2, 4, 8)", n);
return Err(Error::Message(msg));
},
};
let value = match T::try_from(v) {
Ok(v) => v,
Err(_) => return Err(Error::NumberTooLarge),
};
self.consume_bytes(n_bytes); // number of bytes header plus bytes
Ok(value)
},
_ => {
// else parse into a u64, then attempt to fit into current signed type
let v_u64: u64 = self.parse_unsigned()?;
T::try_from(v_u64).map_err(|_| Error::NumberTooLarge)
}
}
}
fn parse_unsigned<T: TryFrom<u64>>(&mut self) -> Result<T> {
match self.peek_byte()? {
b if b >= 0x28 && b <= 0x2f => {
debug!("0x{:x?} -> deserializing unsigned integer (1 to 8 bytes)", b);
let n_bytes = (b - 0x27) as usize;
self.consume_bytes(1);
let mut le_bytes: [u8; 8] = [0; 8];
le_bytes[..n_bytes].copy_from_slice(&self.input[..n_bytes]);
let v = match T::try_from(u64::from_le_bytes(le_bytes)) {
Ok(v) => v,
Err(_) => return Err(Error::NumberTooLarge),
};
self.consume_bytes(n_bytes); // number of bytes header plus bytes
Ok(v)
},
b if b >= 0x30 && b <= 0x39 => {
debug!("0x{:x?} -> deserializing unsigned integer (1 to 9)", b);
let v = match T::try_from((b - 0x30) as u64) {
Ok(v) => v,
Err(_) => return Err(Error::NumberTooLarge),
};
self.consume_bytes(1);
Ok(v)
},
_ => Err(Error::ExpectedInteger),
}
}
fn parse_string(&mut self) -> Result<String> {
match self.peek_byte()? {
0xbf => {
self.consume_bytes(1);
let mut le_bytes: [u8; 8] = [0; 8];
le_bytes[..8].copy_from_slice(&self.input[..8]);
let length = u64::from_le_bytes(le_bytes) as usize;
self.consume_bytes(8);
match std::str::from_utf8(&self.input[..length]) {
Ok(s) => {
self.consume_bytes(length);
Ok(s.to_owned())
},
Err(utf8err) => Err(Error::InvalidUtf8(utf8err)),
}
},
b if b >= 0x40 && b <= 0xbe => {
self.consume_header();
let length = (b - 0x40) as usize;
if length == 0 {
return Ok(String::new())
}
match std::str::from_utf8(&self.input[..length]) {
Ok(s) => {
self.consume_bytes(length);
Ok(s.to_owned())
},
Err(utf8err) => Err(Error::InvalidUtf8(utf8err)),
}
},
_ => Err(Error::ExpectedString),
}
}
}
/// Deserialize a single VelocyPack's bytes into a struct.
pub fn from_bytes<'a, T: Deserialize<'a>>(s: &'a [u8]) -> Result<T> {
let (t, remaining_bytes) = first_from_bytes(s)?;
if remaining_bytes.is_empty() {
Ok(t)
} else {
Err(Error::TrailingBytes(remaining_bytes.len()))
}
}
/// Deserialize the first VelocyPack found in given bytes, and return it along with any remaining
/// bytes. Typically used when dealing with
/// [VelocyStream](https://github.com/arangodb/velocystream), which packs either multiple
/// VelocyPacks into bytes, or packs a VelocyPack header followed by other data into bytes.
pub fn first_from_bytes<'a, T: Deserialize<'a>>(s: &'a [u8]) -> Result<(T, &'a [u8])> {
let mut deserializer = Deserializer::from_bytes(s);
let t = T::deserialize(&mut deserializer)?;
Ok((t, deserializer.input))
}
impl<'de> Deserializer<'de> {
}
impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
match self.peek_byte()? {
b if (b >= 0x01 && b <= 0x09) || b == 0x13 => self.deserialize_seq(visitor),
b if (b >= 0x0a && b <= 0x12) || b == 0x14 => self.deserialize_map(visitor),
0x18 => self.deserialize_unit(visitor),
0x19 | 0x1a => self.deserialize_bool(visitor),
0x1b => self.deserialize_f64(visitor),
b if (b >= 0x20 && b <= 0x27) || (b >= 0x3a && b <= 0x3f) => self.deserialize_i64(visitor),
b if b >= 0x28 && b <= 0x39 => self.deserialize_u64(visitor),
b if b >= 0x40 && b <= 0xbf => self.deserialize_string(visitor),
b => Err(Error::Unimplemented(b)),
}
}
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_bool(self.parse_bool()?)
}
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_i8(self.parse_signed()?)
}
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_i16(self.parse_signed()?)
}
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_i32(self.parse_signed()?)
}
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_i64(self.parse_signed()?)
}
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_u8(self.parse_unsigned()?)
}
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_u16(self.parse_unsigned()?)
}
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_u32(self.parse_unsigned()?)
}
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_u64(self.parse_unsigned()?)
}
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_f32(self.parse_double()? as f32)
}
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_f64(self.parse_double()?)
}
fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
unimplemented!()
}
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_string(self.parse_string()?)
}
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_string(self.parse_string()?)
}
fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
unimplemented!()
}
fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
unimplemented!()
}
fn deserialize_option<V>(self, _visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
unimplemented!()
}
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
match self.peek_byte()? {
0x18 => {
debug!("0x18 -> deserializing null");
self.consume_bytes(1);
visitor.visit_unit()
},
_ => Err(Error::ExpectedNull)
}
}
fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
self.deserialize_unit(visitor)
}
fn deserialize_newtype_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
unimplemented!()
}
fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_seq(ArrayDeserializer::new(&mut self))
}
fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
unimplemented!()
}
fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, _visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
unimplemented!()
}
fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_map(MapDeserializer::new(&mut self))
}
fn deserialize_struct<V>(mut self, _name: &'static str, _fields: &'static [&'static str], visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
visitor.visit_map(MapDeserializer::new(&mut self))
}
fn deserialize_enum<V>(self, _name: &'static str, _variants: &'static [&'static str], _visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
unimplemented!()
}
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
self.deserialize_string(visitor)
}
fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value> where
V: Visitor<'de> {
unimplemented!()
}
fn is_human_readable(&self) -> bool {
false
}
}
struct MapDeserializer<'a, 'de: 'a> {
de: &'a mut Deserializer<'de>,
index_size: Option<usize>,
remaining_items: Option<usize>,
}
impl<'a, 'de> MapDeserializer<'a, 'de> {
fn new(de: &'a mut Deserializer<'de>) -> Self {
Self { de, index_size: None, remaining_items: None }
}
}
impl<'de, 'a> MapAccess<'de> for MapDeserializer<'a, 'de> {
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>> where
K: DeserializeSeed<'de> {
if self.remaining_items.is_none() {
match self.de.peek_byte()? {
0x0a => {
self.de.consume_header();
return Ok(None);
},
0x0b | 0x0f => {
self.de.consume_header();
let _byte_len = self.de.consume_u8()? as usize - 1 - 2*U8_SIZE; // sub header, bytelen, nitems
let num_items = self.de.consume_u8()? as usize;
self.remaining_items = Some(num_items);
self.index_size = Some(U8_SIZE * num_items);
self.de.consume_padding()?;
},
0x0c | 0x10 => {
self.de.consume_header();
let _byte_len = self.de.consume_u16()? as usize - 1 - 2*U16_SIZE; // sub header, bytelen, nitems
let num_items = self.de.consume_u16()? as usize;
self.remaining_items = Some(num_items);
self.index_size = Some(U16_SIZE * num_items);
self.de.consume_padding()?;
},
0x0d | 0x11 => {
self.de.consume_header();
let _byte_len = self.de.consume_u32()? as usize - 1 - 2*U32_SIZE; // sub header, bytelen, nitems
let num_items = self.de.consume_u32()? as usize;
self.remaining_items = Some(num_items);
self.index_size = Some(U32_SIZE * num_items);
self.de.consume_padding()?;
},
0x0e | 0x12 => {
// FIXME: num items is at end
self.de.consume_header();
let _byte_len = self.de.consume_u64()? as usize - 1 - 2*U64_SIZE; // sub header, bytelen, nitems
let num_items = self.de.consume_u64()? as usize;
self.remaining_items = Some(num_items);
self.index_size = Some(U64_SIZE * num_items);
self.de.consume_padding()?;
},
0x14 => {
// compact object
self.de.consume_header();
let mut buf: [u8; 8] = [0; 8];
let length_bits = buf.as_mut_bitslice::<LittleEndian>();
let mut header_size = 1; // header, increment with bytelen bytes
let mut idx = 0;
loop {
let b = self.de.next_byte()?;
for n in 0..7 {
if (b & (1 << n)) != 0 {
*length_bits.at(idx) = true;
}
idx += 1;
}
header_size += 1;
if (b & (1 << 7)) == 0 { // check high bit set
break;
}
}
let bytelength = u64::from_le_bytes(buf) as usize;
let remaining_bytes = bytelength - header_size;
let mut buf: [u8; 8] = [0; 8];
let length_bits = buf.as_mut_bitslice::<LittleEndian>();
let mut index_size = 0;
let mut idx = 0;
for b in self.de.input[..remaining_bytes].iter().rev() {
for n in 0..7 {
if (b & (1 << n)) != 0 {
*length_bits.at(idx) = true;
}
idx += 1;
}
index_size += 1;
if (b & (1 << 7)) == 0 { // check high bit set
break;
}
}
let num_items = u64::from_le_bytes(buf) as usize;
self.remaining_items = Some(num_items);
self.index_size = Some(index_size);
},
_ => return Err(Error::ExpectedObject)
}
}
let remaining_items = self.remaining_items.unwrap();
if remaining_items == 0 {
if let Some(index_size) = self.index_size {
// index is unused, but consume bytes
self.de.consume_bytes(index_size as usize);
}
return Ok(None);
}
let v = seed.deserialize(&mut *self.de).map(Some);
self.remaining_items = Some(remaining_items - 1);
v
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> where
V: DeserializeSeed<'de> {
seed.deserialize(&mut *self.de)
}
}
struct ArrayDeserializer<'a, 'de: 'a> {
de: &'a mut Deserializer<'de>,
index_size: Option<usize>,
remaining_items: Option<usize>,
}
impl<'a, 'de> ArrayDeserializer<'a, 'de> {
fn new(de: &'a mut Deserializer<'de>) -> Self {
Self { de, index_size: None, remaining_items: None }
}
}
impl <'de, 'a> SeqAccess<'de> for ArrayDeserializer<'a, 'de> {
type Error = Error;
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> where
T: DeserializeSeed<'de> {
if self.remaining_items.is_none() {
match self.de.peek_byte()? {
0x01 => {
debug!("0x01 -> deserializing empty array");
self.de.consume_header();
self.remaining_items = Some(0);
},
0x02 => {
debug!("0x02 -> deserializing array without index table (1 byte length)");
self.de.consume_header();
let byte_length = self.de.consume_u8()? as usize - 1 - U8_SIZE; // sub header + bytelen
self.de.consume_padding()?;
// num items is unknown until first item is consumed
let old_size = self.de.input.len();
let v = seed.deserialize(&mut *self.de).map(Some);
let item_size = old_size - self.de.input.len();
let n_items = byte_length / item_size;
self.remaining_items = Some(n_items - 1);
return v;
},
0x03 => {
debug!("0x03 -> deserializing array without index table (2 byte length)");
self.de.consume_header();
let byte_length = self.de.consume_u16()? as usize - 1 - U16_SIZE; // header + bytelen
self.de.consume_padding()?;
// num items is unknown until first item is consumed
let old_size = self.de.input.len();
let v = seed.deserialize(&mut *self.de).map(Some);
let item_size = old_size - self.de.input.len();
let n_items = byte_length / item_size;
self.remaining_items = Some(n_items - 1);
return v;
},
0x04 => {
debug!("0x04 -> deserializing array without index table (4 byte length)");
self.de.consume_header();
let byte_length = self.de.consume_u32()? as usize - 1 - U32_SIZE; // header + bytelen
self.de.consume_padding()?;
// num items is unknown until first item is consumed
let old_size = self.de.input.len();
let v = seed.deserialize(&mut *self.de).map(Some);
let item_size = old_size - self.de.input.len();
let n_items = byte_length / item_size;
self.remaining_items = Some(n_items - 1);
return v;
},
0x05 => {
debug!("0x05 -> deserializing array without index table (8 byte length)");
self.de.consume_header();
let byte_length = self.de.consume_u64()? as usize - 1 - U64_SIZE; // header + bytelen
self.de.consume_padding()?;
// num items is unknown until first item is consumed
let old_size = self.de.input.len();
let v = seed.deserialize(&mut *self.de).map(Some);
let item_size = old_size - self.de.input.len();
let n_items = byte_length / item_size;
self.remaining_items = Some(n_items - 1);
return v;
},
0x06 => {
debug!("0x06 -> deserializing array with index table (1 byte length)");
self.de.consume_bytes(1 + U8_SIZE); // header + bytelength (unused)
let length = self.de.consume_u8()? as usize;
self.de.consume_padding()?;
self.remaining_items = Some(length);
self.index_size = Some(length * U8_SIZE);
},
0x07 => {
debug!("0x07 -> deserializing array with index table (2 byte length)");
self.de.consume_bytes(1 + U16_SIZE); // header + bytelength (unused)
let length = self.de.consume_u16()? as usize;
self.de.consume_padding()?;
self.remaining_items = Some(length);
self.index_size = Some(length * U16_SIZE);
},
0x08 => {
debug!("0x08 -> deserializing array with index table (4 byte length)");
self.de.consume_bytes(1 + U32_SIZE); // header + bytelength (unused)
let length = self.de.consume_u32()? as usize;
self.de.consume_padding()?;
self.remaining_items = Some(length);
self.index_size = Some(length * U32_SIZE);
},
0x09 => {
debug!("0x09 -> deserializing array with index table (8 byte length)");
// nritems at end of data for 8-byte case
self.de.consume_header();
let bytelength = self.de.consume_u64()? - 1 - 8; // sub header and bytelength
let start = (bytelength - 8) as usize;
let end = bytelength as usize;
let mut bytes: [u8; U64_SIZE] = Default::default();
bytes.copy_from_slice(&self.de.input[start..end]);
let length = u64::from_le_bytes(bytes) as usize;
self.remaining_items = Some(length);
self.index_size = Some((length * U64_SIZE) + U64_SIZE); // consume nritems
},
0x13 => {
self.de.consume_header();
let mut buf: [u8; 8] = [0; 8];
let length_bits = buf.as_mut_bitslice::<LittleEndian>();
let mut header_size = 1; // header, increment with bytelen bytes
let mut idx = 0;
loop {
let b = self.de.next_byte()?;
for n in 0..7 {
if (b & (1 << n)) != 0 {
*length_bits.at(idx) = true;
}
idx += 1;
}
header_size += 1;
if (b & (1 << 7)) == 0 { // check high bit set
break;
}
}
let bytelength = u64::from_le_bytes(buf) as usize;
let remaining_bytes = bytelength - header_size;
let mut buf: [u8; 8] = [0; 8];
let length_bits = buf.as_mut_bitslice::<LittleEndian>();
let mut index_size = 0;
let mut idx = 0;
for b in self.de.input[..remaining_bytes].iter().rev() {
for n in 0..7 {
if (b & (1 << n)) != 0 {
*length_bits.at(idx) = true;
}
idx += 1;
}
index_size += 1;
if (b & (1 << 7)) == 0 { // check high bit set
break;
}
}
let num_items = u64::from_le_bytes(buf) as usize;
self.remaining_items = Some(num_items);
self.index_size = Some(index_size);
}
_ => return Err(Error::ExpectedArray)
}
}
let remaining_items = self.remaining_items.unwrap();
if remaining_items == 0 {
if let Some(index_size) = self.index_size {
// index is unused, but consume bytes
self.de.consume_bytes(index_size as usize);
}
return Ok(None);
}
let v = seed.deserialize(&mut *self.de).map(Some);
self.remaining_items = Some(remaining_items - 1);
v
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
use serde_json::json;
#[test]
fn bool_false() {
assert_eq!(from_bytes::<bool>(&[0x19]).unwrap(), false);
}
#[test]
fn bool_true() {
assert_eq!(from_bytes::<bool>(&[0x1a]).unwrap(), true);
}
#[test]
fn unit() {
assert_eq!(from_bytes::<()>(&[0x18]).unwrap(), ());
}
#[test]
fn f32() {
assert_eq!(from_bytes::<f32>(&[0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]).unwrap(), 0.0);
assert_eq!(from_bytes::<f32>(&[0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f]).unwrap(), 1.0);
assert_eq!(from_bytes::<f32>(&[0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xbf]).unwrap(), -1.0);
}
#[test]
fn f64() {
assert_eq!(from_bytes::<f64>(&[0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]).unwrap(), 0.0);
assert_eq!(from_bytes::<f64>(&[0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f]).unwrap(), 1.0);
assert_eq!(from_bytes::<f64>(&[0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xbf]).unwrap(), -1.0);
}
#[test]
fn u8() {
for i in 0..10 {
assert_eq!(from_bytes::<u8>(&[0x30 + i]).unwrap(), i);
}
// uint, little endian, 1 byte
assert_eq!(from_bytes::<u8>(&[0x28, 0x0a]).unwrap(), 10);
assert_eq!(from_bytes::<u8>(&[0x28, 0xff]).unwrap(), std::u8::MAX);
}
#[test]
fn u64() {
for i in 0..10 {
assert_eq!(from_bytes::<u64>(&[0x30 + i]).unwrap(), i as u64);
}
assert_eq!(from_bytes::<u64>(&[0x28, 0x0a]).unwrap(), 10);
assert_eq!(from_bytes::<u64>(&[0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]).unwrap(), std::u64::MAX);
}
#[test]
fn i8() {
// small negative integers
for i in 1..7 {
assert_eq!(from_bytes::<i8>(&[0x40 - i]).unwrap(), -(i as i8));
}
for i in 0..10 {
assert_eq!(from_bytes::<i8>(&[0x30 + i]).unwrap(), i as i8);
}
// signed int, little endian, 1 byte
assert_eq!(from_bytes::<i8>(&[0x20, 0x80]).unwrap(), std::i8::MIN);
assert_eq!(from_bytes::<i8>(&[0x28, 0x7f]).unwrap(), std::i8::MAX);
assert_eq!(from_bytes::<i8>(&[0x20, 0xf9]).unwrap(), -7_i8);
assert_eq!(from_bytes::<i8>(&[0x28, 0x0a]).unwrap(), 10_i8);
}
#[test]
fn i16() {
// small negative integers
for i in 1..7 {
assert_eq!(from_bytes::<i16>(&[0x40 - i]).unwrap(), -(i as i16));
}
for i in 0..10 {
assert_eq!(from_bytes::<i16>(&[0x30 + i]).unwrap(), i as i16);
}
// signed int, little endian, 1 byte
assert_eq!(from_bytes::<i16>(&[0x20, 0x80]).unwrap(), std::i8::MIN as i16);
assert_eq!(from_bytes::<i16>(&[0x28, 0x7f]).unwrap(), std::i8::MAX as i16);
assert_eq!(from_bytes::<i16>(&[0x20, 0xf9]).unwrap(), -7_i16);
assert_eq!(from_bytes::<i16>(&[0x28, 0x0a]).unwrap(), 10_i16);
// signed int, little endian, 2 bytes
assert_eq!(from_bytes::<i16>(&[0x21, 0x00, 0x80]).unwrap(), std::i16::MIN);
assert_eq!(from_bytes::<i16>(&[0x29, 0xff, 0x7f]).unwrap(), std::i16::MAX);
assert_eq!(from_bytes::<i16>(&[0x21, 0xc8, 0x00]).unwrap(), 200_i16);
}
#[test]
fn string() {
assert_eq!(from_bytes::<String>(&[0x40]).unwrap(), "".to_owned());
assert_eq!(from_bytes::<String>(&[0x43, 0x66, 0x6f, 0x6f]).unwrap(), "foo".to_owned());
assert_eq!(from_bytes::<String>(&[0xa7, 0xe2, 0x88, 0x80, 0xe2, 0x88, 0x82, 0xe2, 0x88, 0x88, 0xe2, 0x84, 0x9d, 0xe2, 0x88, 0xa7,
0xe2, 0x88, 0xaa, 0xe2, 0x89, 0xa1, 0xe2, 0x88, 0x9e, 0x20, 0xe2, 0x86, 0x91, 0xe2, 0x86, 0x97,
0xe2, 0x86, 0xa8, 0xe2, 0x86, 0xbb, 0xe2, 0x87, 0xa3, 0x20, 0xe2, 0x94, 0x90, 0xe2, 0x94, 0xbc,
0xe2, 0x95, 0x94, 0xe2, 0x95, 0x98, 0xe2, 0x96, 0x91, 0xe2, 0x96, 0xba, 0xe2, 0x98, 0xba, 0xe2,
0x99, 0x80, 0x20, 0xef, 0xac, 0x81, 0xef, 0xbf, 0xbd, 0xe2, 0x91, 0x80, 0xe2, 0x82, 0x82, 0xe1,
0xbc, 0xa0, 0xe1, 0xb8, 0x82, 0xd3, 0xa5, 0xe1, 0xba, 0x84, 0xc9, 0x90, 0xcb, 0x90, 0xe2, 0x8d,
0x8e, 0xd7, 0x90, 0xd4, 0xb1, 0xe1, 0x83, 0x90]).unwrap(), "∀∂∈ℝ∧∪≡∞ ↑↗↨↻⇣ ┐┼╔╘░►☺♀ fi�⑀₂ἠḂӥẄɐː⍎אԱა".to_owned());
assert_eq!(from_bytes::<String>(&[0xbf, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61]).unwrap(), "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".to_owned());
}
#[test]
fn array_empty() {
assert_eq!(from_bytes::<Vec<u32>>(&[0x01]).unwrap(), Vec::<u32>::new());
}
#[test]
fn array_no_index() {
assert_eq!(from_bytes::<Vec<u8>>(&[0x02, 0x05, 0x31, 0x32, 0x33]).unwrap(), vec![1, 2, 3]);
assert_eq!(from_bytes::<Vec<String>>(&[0x02, 0x06, 0x43, 0x66, 0x6f, 0x6f]).unwrap(), vec!["foo".to_owned()]);
assert_eq!(from_bytes::<Vec<u8>>(&vec![0x03, 0x02, 0x01, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31]).unwrap(),
vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
}
#[test]
fn array_with_index() {
assert_eq!(from_bytes::<Vec<u16>>(&[0x06, 0x09, 0x02, 0x31, 0x29, 0x00, 0x01, 0x03, 0x04]).unwrap(), vec![1, 256]);
assert_eq!(from_bytes::<Vec<Vec<String>>>(&[0x06, 0x1e, 0x03, 0x02, 0x06, 0x43, 0x66, 0x6f, 0x6f, 0x02, 0x0a, 0x43, 0x62, 0x61, 0x72, 0x43,
0x62, 0x61, 0x7a, 0x02, 0x08, 0x41, 0x61, 0x41, 0x62, 0x41, 0x63, 0x03, 0x09, 0x13]).unwrap(),
vec![vec!["foo".to_owned()],
vec!["bar".to_owned(), "baz".to_owned()],
vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]]);
assert_eq!(
from_bytes::<Vec<String>>(&vec![0x07, 0x1f, 0x01, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbf, 0xdd, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x61, 0x61, 0x61, 0x64, 0x6b, 0x6c, 0x6a, 0x66, 0x68, 0x64, 0x6b, 0x6c, 0x6a, 0x68,
0x66, 0x6b, 0x6c, 0x64, 0x6a, 0x68, 0x66, 0x6c, 0x6b, 0x6a, 0x64, 0x68, 0x73, 0x64, 0x66, 0x6a,
0x6c, 0x73, 0x68, 0x61, 0x6c, 0x6b, 0x66, 0x6a, 0x73, 0x68, 0x64, 0x66, 0x6c, 0x6b, 0x6a, 0x73,
0x64, 0x68, 0x66, 0x6c, 0x6b, 0x6a, 0x64, 0x68, 0x66, 0x6b, 0x61, 0x6c, 0x6a, 0x68, 0x66, 0x6c,
0x6b, 0x61, 0x73, 0x6a, 0x64, 0x68, 0x66, 0x6c, 0x6b, 0x6a, 0x64, 0x73, 0x68, 0x66, 0x6b, 0x6c,
0x6a, 0x73, 0x64, 0x68, 0x66, 0x6c, 0x6b, 0x6a, 0x64, 0x68, 0x6c, 0x66, 0x6b, 0x6a, 0x68, 0x64,
0x6c, 0x6b, 0x66, 0x6a, 0x68, 0x64, 0x73, 0x6c, 0x6b, 0x66, 0x6a, 0x64, 0x68, 0x61, 0x73, 0x6c,
0x66, 0x6b, 0x6a, 0x61, 0x73, 0x68, 0x64, 0x6c, 0x66, 0x6b, 0x6a, 0x64, 0x73, 0x68, 0x61, 0x6c,
0x66, 0x6b, 0x6a, 0x64, 0x73, 0x68, 0x66, 0x6c, 0x6b, 0x64, 0x6a, 0x73, 0x68, 0x66, 0x6c, 0x6b,
0x73, 0x6a, 0x68, 0x66, 0x6c, 0x73, 0x64, 0x6b, 0x6a, 0x66, 0x68, 0x64, 0x73, 0x6b, 0x6c, 0x6a,
0x66, 0x68, 0x73, 0x61, 0x6c, 0x6b, 0x6a, 0x66, 0x68, 0x64, 0x6c, 0x6b, 0x6a, 0x66, 0x68, 0x61,
0x73, 0x64, 0x6b, 0x6c, 0x6a, 0x68, 0x66, 0x6c, 0x6b, 0x64, 0x73, 0x61, 0x6a, 0x68, 0x66, 0x6c,
0x6b, 0x6a, 0x64, 0x73, 0x68, 0x66, 0x6b, 0x6c, 0x64, 0x6a, 0x68, 0x66, 0x6c, 0x6b, 0x6a, 0x64,
0x73, 0x68, 0x66, 0x6c, 0x6b, 0x6a, 0x61, 0x64, 0x68, 0x66, 0x6c, 0x6b, 0x6a, 0x64, 0x68, 0x41,
0x61, 0x41, 0x61, 0x41, 0x61, 0x42, 0x62, 0x62, 0x43, 0x63, 0x63, 0x63, 0x44, 0x64, 0x64, 0x64,
0x64, 0x44, 0x65, 0x65, 0x65, 0x65, 0x46, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x09, 0x00, 0xef,
0x00, 0xf1, 0x00, 0xf3, 0x00, 0xf5, 0x00, 0xf8, 0x00, 0xfc, 0x00, 0x01, 0x01, 0x06, 0x01]).unwrap(),
vec!["aaadkljfhdkljhfkldjhflkjdhsdfjlshalkfjshdflkjsdhflkjdhfkaljhflkasjdhflkjdshfkljsdhflkjdhlfkjhdlkfjhdslkfjdhaslfkjashdlfkjdshalfkjdshflkdjshflksjhflsdkjfhdskljfhsalkjfhdlkjfhasdkljhflkdsajhflkjdshfkldjhflkjdshflkjadhflkjdh".to_owned(), "a".to_owned(), "a".to_owned(), "a".to_owned(), "bb".to_owned(), "ccc".to_owned(), "dddd".to_owned(), "eeee".to_owned(), "ffffff".to_owned()]);
}
#[test]
fn array_compact() {
assert_eq!(from_bytes::<Vec<u8>>(&[0x13, 0x06, 0x31, 0x32, 0x33, 0x03]).unwrap(), vec![1, 2, 3]);
assert_eq!(from_bytes::<Vec<u8>>(&[0x13, 0x06, 0x31, 0x28, 0x10, 0x02]).unwrap(), vec![1, 16]);
assert_eq!(from_bytes::<Vec<u8>>(&[0x13, 0xef, 0x05, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x05, 0xea]).unwrap(), vec![1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]);
}
#[test]
fn array_123_examples() {
let expected = vec![1, 2, 3];
assert_eq!(from_bytes::<Vec<u64>>(&[0x02, 0x05, 0x31, 0x32, 0x33]).unwrap(), expected);
assert_eq!(from_bytes::<Vec<u64>>(&[0x03, 0x06, 0x00, 0x31, 0x32, 0x33]).unwrap(), expected);
assert_eq!(from_bytes::<Vec<u64>>(&[0x04, 0x08, 0x00, 0x00, 0x00, 0x31, 0x32, 0x33]).unwrap(), expected);
assert_eq!(from_bytes::<Vec<u64>>(&[0x05, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x32, 0x33]).unwrap(), expected);
assert_eq!(from_bytes::<Vec<u64>>(&[0x06, 0x09, 0x03, 0x31, 0x32, 0x33, 0x03, 0x04, 0x05]).unwrap(), expected);
assert_eq!(from_bytes::<Vec<u64>>(&[0x07, 0x0e, 0x00, 0x03, 0x00, 0x31, 0x32, 0x33, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00]).unwrap(), expected);
assert_eq!(from_bytes::<Vec<u64>>(&[0x08, 0x18, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x31, 0x32, 0x33, 0x09, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00]).unwrap(), expected);
assert_eq!(from_bytes::<Vec<u64>>(&[0x09, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x32, 0x33, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]).unwrap(), expected);
}
#[test]
fn object_empty() {
assert_eq!(from_bytes::<HashMap<String, u8>>(&[0x0a]).unwrap(), HashMap::new());
}
#[test]
fn object_1byte() {
let mut m = HashMap::new();
m.insert("a".to_owned(), 1);
m.insert("b".to_owned(), 2);
assert_eq!(from_bytes::<HashMap<String, u8>>(&[0x0b, 0x0b, 0x02, 0x41, 0x61, 0x31, 0x41, 0x62, 0x32, 0x03, 0x06]).unwrap(), m);
}
#[test]
fn object_to_struct() {
#[derive(Debug, Deserialize, PartialEq, Eq)]
struct Person {
name: String,
age: u32,
}
assert_eq!(from_bytes::<Person>(&[0x0b, 0x14, 0x02, 0x44, 0x6e, 0x61, 0x6d, 0x65, 0x43, 0x42, 0x6f, 0x62, 0x43, 0x61, 0x67, 0x65,
0x28, 0x17, 0x0c, 0x03]).unwrap(), Person { name: "Bob".to_owned(), age: 23 });
}
#[test]
fn object_compact() {
let mut expected = HashMap::new();
expected.insert("a".to_owned(), 1);
assert_eq!(from_bytes::<HashMap<String, u8>>(&[0x14, 0x06, 0x41, 0x61, 0x31, 0x01]).unwrap(), expected);
}
#[test]
fn vst_header() {
// VelocyStream header returned by ArangoDB 3.5.3 for /_admin/echo query
let expected = json!(
{
"authorized": true,
"client": {
"address": "172.17.0.1",
"id": "0",
"port": 33402
},
"database": "_system",
"headers": {},
"internals": {},
"isAdminUser": true,
"parameters": {},
"path": "/",
"portType": "tcp/ip",
"prefix": "/",
"protocol": "vst",
"rawRequestBody": {
"data": [],
"type": "Buffer"
},
"rawSuffix": [],
"requestType": "GET",
"server": {
"address": "0.0.0.0",
"endpoint": "http://0.0.0.0:8529",
"port": 8529
},
"suffix": [],
"url": "/_admin/echo",
"user": null
}
);
let data = vec![
0x0c,0x73,0x01,0x12,0x00,0x00,0x00,0x00,0x00,0x4a,0x61,0x75,0x74,0x68,0x6f,0x72,0x69,0x7a,0x65,0x64,0x1a,0x44,0x75,0x73,0x65,0x72,0x18,0x4b,0x69,0x73,0x41,0x64,0x6d,0x69,0x6e,0x55,0x73,0x65,0x72,0x1a,0x48,0x64,0x61,0x74,0x61,0x62,0x61,0x73,0x65,0x47,0x5f,0x73,0x79,0x73,0x74,0x65,0x6d,0x43,0x75,0x72,0x6c,0x4c,0x2f,0x5f,0x61,0x64,0x6d,0x69,0x6e,0x2f,0x65,0x63,0x68,0x6f,0x48,0x70,0x72,0x6f,0x74,0x6f,0x63,0x6f,0x6c,0x43,0x76,0x73,0x74,0x46,0x73,0x65,0x72,0x76,0x65,0x72,0x0b,0x3b,0x03,0x47,0x61,0x64,0x64,0x72,0x65,0x73,0x73,0x47,0x30,0x2e,0x30,0x2e,0x30,0x2e,0x30,0x44,0x70,0x6f,0x72,0x74,0x29,0x51,0x21,0x48,0x65,0x6e,0x64,0x70,0x6f,0x69,0x6e,0x74,0x53,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x30,0x2e,0x30,0x2e,0x30,0x2e,0x30,0x3a,0x38,0x35,0x32,0x39,0x03,0x1b,0x13,0x48,0x70,0x6f,0x72,0x74,0x54,0x79,0x70,0x65,0x46,0x74,0x63,0x70,0x2f,0x69,0x70,0x46,0x63,0x6c,0x69,0x65,0x6e,0x74,0x0b,0x26,0x03,0x47,0x61,0x64,0x64,0x72,0x65,0x73,0x73,0x4a,0x31,0x37,0x32,0x2e,0x31,0x37,0x2e,0x30,0x2e,0x31,0x44,0x70,0x6f,0x72,0x74,0x29,0x7a,0x82,0x42,0x69,0x64,0x41,0x30,0x03,0x1e,0x16,0x49,0x69,0x6e,0x74,0x65,0x72,0x6e,0x61,0x6c,0x73,0x0a,0x46,0x70,0x72,0x65,0x66,0x69,0x78,0x41,0x2f,0x47,0x68,0x65,0x61,0x64,0x65,0x72,0x73,0x0a,0x4b,0x72,0x65,0x71,0x75,0x65,0x73,0x74,0x54,0x79,0x70,0x65,0x43,0x47,0x45,0x54,0x4a,0x70,0x61,0x72,0x61,0x6d,0x65,0x74,0x65,0x72,0x73,0x0a,0x46,0x73,0x75,0x66,0x66,0x69,0x78,0x01,0x49,0x72,0x61,0x77,0x53,0x75,0x66,0x66,0x69,0x78,0x01,0x44,0x70,0x61,0x74,0x68,0x41,0x2f,0x4e,0x72,0x61,0x77,0x52,0x65,0x71,0x75,0x65,0x73,0x74,0x42,0x6f,0x64,0x79,0x0b,0x17,0x02,0x44,0x74,0x79,0x70,0x65,0x46,0x42,0x75,0x66,0x66,0x65,0x72,0x44,0x64,0x61,0x74,0x61,0x01,0x0f,0x03,0x09,0x00,0xa9,0x00,0x28,0x00,0xea,0x00,0xd6,0x00,0x1b,0x00,0x03,0x01,0x22,0x01,0x99,0x00,0xe1,0x00,0x4a,0x00,0x29,0x01,0x17,0x01,0xf3,0x00,0x57,0x00,0x0f,0x01,0x39,0x00,0x15,0x00
];
assert_eq!(from_bytes::<serde_json::Value>(&data).unwrap(), expected);
}
}