these-android-re/androscalpel
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

init

Browse source
This commit is contained in:
Jean-Marie Mineau 2023-07-21 11:36:33 +02:00
commit ab1d6f4f8c
9 changed files with 1452 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
androscalpel_serializer/.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
/target
/Cargo.lock

7
androscalpel_serializer/Cargo.toml Normal file
View file

@ -0,0 +1,7 @@
[package]
name = "androscalpel_serializer"
version = "0.1.0"
edition = "2021"
[dependencies]
androscalpel_serializer_derive = { path = "../androscalpel_serializer_derive" }

846
androscalpel_serializer/src/lib.rs Normal file
View file

@ -0,0 +1,846 @@
use std::io::{Cursor, Read, Seek, SeekFrom, Write};
pub use androscalpel_serializer_derive::*;
#[derive(Debug, PartialEq, Eq)]
pub enum Error {
InputTooSmall(String), // TODO: find a better name
SerializeationError(String),
}
pub type Result<T> = core::result::Result<T, Error>;
pub trait ReadSeek: Read + Seek {}
impl<T: Read + Seek> ReadSeek for T {}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::InputTooSmall(msg) => write!(f, "Error: {}", msg),
Self::SerializeationError(msg) => write!(f, "Error: {}", msg),
}
}
}
impl std::error::Error for Error {}
pub trait Serializable {
fn serialize(&self, output: &mut dyn Write) -> Result<()>;
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self>
where
Self: Sized;
fn size(&self) -> usize;
fn serialize_to_vec(&self) -> Result<Vec<u8>> {
let mut output = Cursor::new(Vec::<u8>::new());
self.serialize(&mut output)?;
Ok(output.into_inner())
}
fn deserialize_from_slice(input: &[u8]) -> Result<Self>
where
Self: Sized,
{
let mut buffer = Cursor::new(input);
Self::deserialize(&mut buffer)
}
}
pub trait SerializableUntil<D: Serializable, U: Serializable + Eq> {
fn serialize(&self, output: &mut dyn Write, end_val: U) -> Result<()>;
fn deserialize(input: &mut dyn ReadSeek, end_val: U) -> Result<Self>
where
Self: Sized;
fn size(&self, end_val: U) -> usize;
fn serialize_to_vec(&self, end_val: U) -> Result<Vec<u8>> {
let mut output = Cursor::new(Vec::<u8>::new());
self.serialize(&mut output, end_val)?;
Ok(output.into_inner())
}
fn deserialize_from_slice(input: &[u8], end_val: U) -> Result<Self>
where
Self: Sized,
{
let mut buffer = Cursor::new(input);
Self::deserialize(&mut buffer, end_val)
}
}
impl<D: Serializable, U: Serializable + Eq> SerializableUntil<D, U> for Vec<D> {
fn serialize(&self, output: &mut dyn Write, end_val: U) -> Result<()> {
for data in self {
data.serialize(output)?;
}
end_val.serialize(output)
}
fn deserialize(input: &mut dyn ReadSeek, end_val: U) -> Result<Self>
where
Self: Sized,
{
let mut data = Self::new();
loop {
let pos = input.stream_position().map_err(|err| {
Error::SerializeationError(format!("Failled to get position in steam: {err}"))
})?;
match U::deserialize(input) {
Ok(val) if val == end_val => break Ok(data),
Err(err) => break Err(err),
Ok(_) => input.seek(SeekFrom::Start(pos)).map_err(|err| {
Error::SerializeationError(format!(
"Failled to get to position in steam: {err}"
))
})?,
};
data.push(D::deserialize(input)?);
}
}
fn size(&self, end_val: U) -> usize {
self.iter().map(|data| data.size()).sum::<usize>() + end_val.size()
}
}
impl Serializable for u8 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize u8 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 1];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for u8 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
1
}
}
impl Serializable for i8 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize i8 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 1];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for i8 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
1
}
}
impl Serializable for u16 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize u16 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 2];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for u16 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
2
}
}
impl Serializable for i16 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize i16 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 2];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for i16 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
2
}
}
impl Serializable for u32 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize u32 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 4];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for u32 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
4
}
}
impl Serializable for i32 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize i32 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 4];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for i32 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
4
}
}
impl Serializable for u64 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize u64 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 8];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for u64 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
8
}
}
impl Serializable for i64 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize i64 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 8];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for i64 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
8
}
}
impl Serializable for u128 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize u128 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 16];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for u128 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
16
}
}
impl Serializable for i128 {
fn serialize(&self, output: &mut dyn Write) -> Result<()> {
output.write_all(&self.to_be_bytes()).map_err(|err| {
Error::SerializeationError(format!("Failed to write serialize i128 to output: {err}"))
})?;
Ok(())
}
fn deserialize(input: &mut dyn ReadSeek) -> Result<Self> {
let mut buffer = [0u8; 16];
input.read_exact(&mut buffer).map_err(|_| {
Error::InputTooSmall("Failed to read all bytes for i128 from the input".into())
})?;
Ok(Self::from_be_bytes(buffer))
}
fn size(&self) -> usize {
16
}
}
#[cfg(test)]
mod test {
use super::*;
// Hacky hack to refere to "crate" by its name
use crate as androscalpel_serializer;
#[test]
fn serialize_u8() {
assert_eq!(42u8.serialize_to_vec().unwrap(), vec![42u8]);
}
#[test]
fn deserialize_u8() {
assert_eq!(u8::deserialize_from_slice(&[42u8]).unwrap(), 42u8);
}
#[test]
fn size_u8() {
assert_eq!(42u8.size(), 1);
}
#[test]
fn serialize_u16() {
assert_eq!(0x1234u16.serialize_to_vec().unwrap(), vec![0x12u8, 0x34u8]);
}
#[test]
fn deserialize_u16() {
assert_eq!(
u16::deserialize_from_slice(&[0x12u8, 0x34u8]).unwrap(),
0x1234u16
);
}
#[test]
fn size_u16() {
assert_eq!(0x1234u16.size(), 2);
}
#[test]
fn serialize_u32() {
assert_eq!(
0x12345678u32.serialize_to_vec().unwrap(),
vec![0x12u8, 0x34u8, 0x56u8, 0x78u8]
);
}
#[test]
fn deserialize_u32() {
assert_eq!(
u32::deserialize_from_slice(&[0x12u8, 0x34u8, 0x56u8, 0x78u8]).unwrap(),
0x12345678u32
);
}
#[test]
fn size_u32() {
assert_eq!(0x12345678u32.size(), 4);
}
#[test]
fn serialize_u64() {
assert_eq!(
0x123456789ABCDEF0u64.serialize_to_vec().unwrap(),
vec![0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8]
);
}
#[test]
fn deserialize_u64() {
assert_eq!(
u64::deserialize_from_slice(&[
0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8
])
.unwrap(),
0x123456789ABCDEF0u64
);
}
#[test]
fn size_u64() {
assert_eq!(0x123456789ABCDEF0u64.size(), 8);
}
#[test]
fn serialize_u128() {
assert_eq!(
0x123456789ABCDEF0123456789ABCDEF0u128
.serialize_to_vec()
.unwrap(),
vec![
0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8,
0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8
]
);
}
#[test]
fn deserialize_u128() {
assert_eq!(
u128::deserialize_from_slice(&[
0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8,
0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8
])
.unwrap(),
0x123456789ABCDEF0123456789ABCDEF0u128
);
}
#[test]
fn size_u128() {
assert_eq!(0x123456789ABCDEF0123456789ABCDEF0u128.size(), 16);
}
#[derive(Serializable, Debug, PartialEq, Eq)]
struct NamedComposedTest {
a: u8,
b: u16,
c: u32,
d: u64,
f: u128,
}
#[derive(Serializable, Debug, PartialEq, Eq)]
struct UnamedComposedTest(u8, u16, u32, u64, u128);
#[test]
fn serialize_unnamed_derived() {
let t = UnamedComposedTest(
42u8,
0x1234u16,
0x12345678u32,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0123456789ABCDEF0u128,
);
assert_eq!(
t.serialize_to_vec().unwrap(),
vec![
42u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8,
0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8
]
);
}
#[test]
fn deserialize_named_derived() {
let t = UnamedComposedTest(
42u8,
0x1234u16,
0x12345678u32,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0123456789ABCDEF0u128,
);
let serialized = vec![
42u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8,
0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8,
];
assert_eq!(
UnamedComposedTest::deserialize_from_slice(&serialized).unwrap(),
t
);
}
#[test]
fn size_unnamed_derived() {
let t = UnamedComposedTest(
42u8,
0x1234u16,
0x12345678u32,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0123456789ABCDEF0u128,
);
assert_eq!(t.size(), 1 + 2 + 4 + 8 + 16);
}
#[derive(Serializable, Debug, PartialEq, Eq)]
struct NamedArrayComposedTest {
a: [u8; 1],
b: [u16; 2],
c: [u32; 3],
d: [u64; 4],
e: [u128; 5],
}
#[derive(Serializable, Debug, PartialEq, Eq)]
struct UnamedArrayComposedTest([u8; 1], [u16; 2], [u32; 3], [u64; 4], [u128; 5]);
#[test]
fn serialize_array_unamed_derived() {
let t = UnamedArrayComposedTest(
[42u8],
[0x1234u16, 0x1234u16],
[0x12345678u32, 0x12345678u32, 0x12345678u32],
[
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
],
[
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
],
);
assert_eq!(
t.serialize_to_vec().unwrap(),
vec![
42u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8,
0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8,
0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8,
0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8,
0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8,
0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8,
0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8
]
);
}
#[test]
fn deserialize_array_unamed_derived() {
let t = UnamedArrayComposedTest(
[42u8],
[0x1234u16, 0x1234u16],
[0x12345678u32, 0x12345678u32, 0x12345678u32],
[
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
],
[
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
],
);
let serialized = vec![
42u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8,
0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8,
0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8,
0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8,
0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8,
0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8,
0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8,
0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8,
0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8,
];
assert_eq!(
UnamedArrayComposedTest::deserialize_from_slice(&serialized).unwrap(),
t
);
}
#[test]
fn size_array_unamed_derived() {
let t = UnamedArrayComposedTest(
[42u8],
[0x1234u16, 0x1234u16],
[0x12345678u32, 0x12345678u32, 0x12345678u32],
[
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
],
[
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
],
);
assert_eq!(t.size(), 1 + 2 * 2 + 4 * 3 + 8 * 4 + 16 * 5);
}
#[test]
fn serialize_array_named_derived() {
let t = NamedArrayComposedTest {
a: [42u8],
b: [0x1234u16, 0x1234u16],
c: [0x12345678u32, 0x12345678u32, 0x12345678u32],
d: [
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
],
e: [
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
],
};
assert_eq!(
t.serialize_to_vec().unwrap(),
vec![
42u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8,
0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8,
0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8,
0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8,
0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8,
0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8,
0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8
]
);
}
#[test]
fn deserialize_array_named_derived() {
let t = NamedArrayComposedTest {
a: [42u8],
b: [0x1234u16, 0x1234u16],
c: [0x12345678u32, 0x12345678u32, 0x12345678u32],
d: [
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
],
e: [
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
],
};
let serialized = vec![
42u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8,
0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8,
0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8,
0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8,
0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8,
0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8,
0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8,
0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8,
0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8,
0xBCu8, 0xDEu8, 0xF0u8, 0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8,
0x12u8, 0x34u8, 0x56u8, 0x78u8, 0x9Au8, 0xBCu8, 0xDEu8, 0xF0u8,
];
assert_eq!(
NamedArrayComposedTest::deserialize_from_slice(&serialized).unwrap(),
t
);
}
#[test]
fn size_array_named_derived() {
let t = NamedArrayComposedTest {
a: [42u8],
b: [0x1234u16, 0x1234u16],
c: [0x12345678u32, 0x12345678u32, 0x12345678u32],
d: [
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
0x123456789ABCDEF0u64,
],
e: [
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
0x123456789ABCDEF0123456789ABCDEF0u128,
],
};
assert_eq!(t.size(), 1 + 2 * 2 + 4 * 3 + 8 * 4 + 16 * 5);
}
#[test]
fn size_vec_serializable_until() {
#[derive(Serializable, PartialEq, Eq)]
struct UntilArray([u8; 3]);
let v = vec![0u8, 1u8, 2u8, 3u8];
assert_eq!(v.size(UntilArray([0, 0, 0])), 7);
assert_eq!(v.size(0u8), 5);
}
#[test]
fn serialize_vec_serializable_until() {
#[derive(Serializable, PartialEq, Eq)]
struct UntilArray([u8; 3]);
let v = vec![0u8, 1u8, 2u8, 3u8];
assert_eq!(
v.serialize_to_vec(UntilArray([0, 0, 0])).unwrap(),
vec![0u8, 1u8, 2u8, 3u8, 0u8, 0u8, 0u8]
);
assert_eq!(
v.serialize_to_vec(0u8).unwrap(),
vec![0u8, 1u8, 2u8, 3u8, 0u8]
);
}
#[test]
fn deserialize_vec_serializable_until() {
#[derive(Serializable, PartialEq, Eq)]
struct UntilArray([u8; 3]);
let v1 = vec![0u8, 1u8, 2u8, 3u8];
let serialized_1 = &[0u8, 1u8, 2u8, 3u8, 0u8, 0u8, 0u8];
let serialized_2 = &[0u8, 1u8, 2u8, 3u8, 0u8];
assert_eq!(
v1,
Vec::<u8>::deserialize_from_slice(serialized_1, UntilArray([0, 0, 0])).unwrap()
);
assert_eq!(
Vec::<u8>::new(),
Vec::<u8>::deserialize_from_slice(serialized_2, 0u8).unwrap()
);
}
#[derive(Serializable, PartialEq, Eq, Debug)]
struct UntilArray2([u8; 2]);
#[derive(Serializable, Debug, PartialEq, Eq)]
struct SerializableUntilNamed {
pr: u16,
#[until(u8, UntilArray2, UntilArray2([0u8, 0u8]))]
v: Vec<u8>,
ps: u32,
}
#[test]
fn size_named_serializable_until() {
let v = SerializableUntilNamed {
pr: 0,
v: vec![1, 2, 3],
ps: 0,
};
assert_eq!(v.size(), 2 + 3 + 2 + 4);
}
#[test]
fn serialize_named_serializable_until() {
let v = SerializableUntilNamed {
pr: 0,
v: vec![1, 2, 3],
ps: 0x80000000,
};
assert_eq!(
v.serialize_to_vec().unwrap(),
vec![0, 0, 1, 2, 3, 0, 0, 0x80, 0, 0, 0],
);
}
#[test]
fn deserialize_named_serializable_until() {
let v = SerializableUntilNamed {
pr: 0,
v: vec![1, 2, 3],
ps: 0x80000000,
};
let s = &[0, 0, 1, 2, 3, 0, 0, 0x80, 0, 0, 0];
assert_eq!(
v,
SerializableUntilNamed::deserialize_from_slice(s).unwrap()
);
}
#[derive(Serializable, PartialEq, Eq, Debug)]
#[prefix_type(u8)]
enum TestEnum {
#[prefix(0)]
Zero,
#[prefix(1)]
One(u32),
#[prefix(2)]
Two { a: u16, b: u32 },
}
#[test]
fn size_enum() {
assert_eq!(TestEnum::Zero.size(), 1);
assert_eq!(TestEnum::One(42).size(), 5);
assert_eq!(TestEnum::Two { a: 1, b: 2 }.size(), 7);
}
#[test]
fn serialize_enum() {
assert_eq!(TestEnum::Zero.serialize_to_vec().unwrap(), vec![0u8]);
assert_eq!(
TestEnum::One(42).serialize_to_vec().unwrap(),
vec![1u8, 0u8, 0u8, 0u8, 42u8]
);
assert_eq!(
TestEnum::Two { a: 1, b: 2 }.serialize_to_vec().unwrap(),
vec![2u8, 0u8, 1u8, 0u8, 0u8, 0u8, 2u8]
);
}
#[test]
fn deserialize_enum() {
assert_eq!(
TestEnum::deserialize_from_slice(&[0u8]).unwrap(),
TestEnum::Zero
);
assert_eq!(
TestEnum::deserialize_from_slice(&[1u8, 0u8, 0u8, 0u8, 42u8]).unwrap(),
TestEnum::One(42)
);
assert_eq!(
TestEnum::deserialize_from_slice(&[2u8, 0u8, 1u8, 0u8, 0u8, 0u8, 2u8]).unwrap(),
TestEnum::Two { a: 1, b: 2 }
);
assert!(TestEnum::deserialize_from_slice(&[255u8]).is_err());
}
}