zip-core 0.0.4

use super::{
    super::{DataDescriptor, DataDescriptorSignature, DataDescriptorZip64, DataDescriptorZip64Signature},
    validate_length, FixedSizeError, Parse,
};

impl Parse for DataDescriptor {
    type Error = FixedSizeError;

    fn from_buf<T: bytes::Buf>(buf: &mut T) -> Result<Self, Self::Error>
    where
        Self: Sized,
    {
        let remaining = buf.remaining();
        validate_length(remaining, Self::SIZE_IN_BYTES, FixedSizeError::UnsufficientExactBytes)?;
        Ok(Self {
            crc_32: buf.get_u32_le(),
            compressed_size: buf.get_u32_le(),
            uncompressed_size: buf.get_u32_le(),
        })
    }

    fn to_buf<T: bytes::BufMut>(&self, buf: &mut T) -> Result<(), Self::Error> {
        let remaining = buf.remaining_mut();
        validate_length(remaining, Self::SIZE_IN_BYTES, FixedSizeError::UnsufficientExactBytes)?;
        buf.put_u32_le(self.crc_32);
        buf.put_u32_le(self.compressed_size);
        buf.put_u32_le(self.uncompressed_size);
        Ok(())
    }
}

impl Parse for DataDescriptorSignature {
    type Error = FixedSizeError;

    fn from_buf<T: bytes::Buf>(buf: &mut T) -> Result<Self, Self::Error>
    where
        Self: Sized,
    {
        let remaining = buf.remaining();
        validate_length(remaining, Self::SIZE_IN_BYTES, FixedSizeError::UnsufficientExactBytes)?;
        Ok(Self {
            signature: buf.get_u32_le(),
            crc_32: buf.get_u32_le(),
            compressed_size: buf.get_u32_le(),
            uncompressed_size: buf.get_u32_le(),
        })
    }

    fn to_buf<T: bytes::BufMut>(&self, buf: &mut T) -> Result<(), Self::Error> {
        let remaining = buf.remaining_mut();
        validate_length(remaining, Self::SIZE_IN_BYTES, FixedSizeError::UnsufficientExactBytes)?;
        buf.put_u32_le(self.signature);
        buf.put_u32_le(self.crc_32);
        buf.put_u32_le(self.compressed_size);
        buf.put_u32_le(self.uncompressed_size);
        Ok(())
    }
}

impl Parse for DataDescriptorZip64 {
    type Error = FixedSizeError;

    fn from_buf<T: bytes::Buf>(buf: &mut T) -> Result<Self, Self::Error>
    where
        Self: Sized,
    {
        let remaining = buf.remaining();
        validate_length(remaining, Self::SIZE_IN_BYTES, FixedSizeError::UnsufficientExactBytes)?;
        Ok(Self {
            crc_32: buf.get_u32_le(),
            compressed_size: buf.get_u64_le(),
            uncompressed_size: buf.get_u64_le(),
        })
    }

    fn to_buf<T: bytes::BufMut>(&self, buf: &mut T) -> Result<(), Self::Error> {
        let remaining = buf.remaining_mut();
        validate_length(remaining, Self::SIZE_IN_BYTES, FixedSizeError::UnsufficientExactBytes)?;
        buf.put_u32_le(self.crc_32);
        buf.put_u64_le(self.compressed_size);
        buf.put_u64_le(self.uncompressed_size);
        Ok(())
    }
}

impl Parse for DataDescriptorZip64Signature {
    type Error = FixedSizeError;

    fn from_buf<T: bytes::Buf>(buf: &mut T) -> Result<Self, Self::Error>
    where
        Self: Sized,
    {
        let remaining = buf.remaining();
        validate_length(remaining, Self::SIZE_IN_BYTES, FixedSizeError::UnsufficientExactBytes)?;
        Ok(Self {
            signature: buf.get_u32_le(),
            crc_32: buf.get_u32_le(),
            compressed_size: buf.get_u64_le(),
            uncompressed_size: buf.get_u64_le(),
        })
    }

    fn to_buf<T: bytes::BufMut>(&self, buf: &mut T) -> Result<(), Self::Error> {
        let remaining = buf.remaining_mut();
        validate_length(remaining, Self::SIZE_IN_BYTES, FixedSizeError::UnsufficientExactBytes)?;
        buf.put_u32_le(self.signature);
        buf.put_u32_le(self.crc_32);
        buf.put_u64_le(self.compressed_size);
        buf.put_u64_le(self.uncompressed_size);
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::{super::*, *};

    #[test]
    fn cycle_data_descriptor() {
        let dd = DataDescriptor {
            crc_32: 1,
            compressed_size: 2,
            uncompressed_size: 3,
        };
        let mut buf = vec![];
        dd.to_buf(&mut buf).unwrap();
        assert_eq!(buf.len(), DataDescriptor::SIZE_IN_BYTES);
        let mut readbuf = buf.as_slice();
        let dd2 = DataDescriptor::from_buf(&mut readbuf).unwrap();
        assert_eq!(dd, dd2);
    }

    #[test]
    fn cycle_data_descriptor_signature() {
        let dd = DataDescriptorSignature {
            signature: 1,
            crc_32: 2,
            compressed_size: 3,
            uncompressed_size: 4,
        };
        let mut buf = vec![];
        dd.to_buf(&mut buf).unwrap();
        assert_eq!(buf.len(), DataDescriptorSignature::SIZE_IN_BYTES);
        let mut readbuf = buf.as_slice();
        let dd2 = DataDescriptorSignature::from_buf(&mut readbuf).unwrap();
        assert_eq!(dd, dd2);
    }

    #[test]
    fn cycle_data_descriptor_zip64() {
        let dd = DataDescriptorZip64 {
            crc_32: 1,
            compressed_size: 2,
            uncompressed_size: 3,
        };
        let mut buf = vec![];
        dd.to_buf(&mut buf).unwrap();
        assert_eq!(buf.len(), DataDescriptorZip64::SIZE_IN_BYTES);
        let mut readbuf = buf.as_slice();
        let dd2 = DataDescriptorZip64::from_buf(&mut readbuf).unwrap();
        assert_eq!(dd, dd2);
    }

    #[test]
    fn cycle_data_descriptor_zip64_signature() {
        let dd = DataDescriptorZip64Signature {
            signature: 1,
            crc_32: 2,
            compressed_size: 3,
            uncompressed_size: 4,
        };
        let mut buf = vec![];
        dd.to_buf(&mut buf).unwrap();
        assert_eq!(buf.len(), DataDescriptorZip64Signature::SIZE_IN_BYTES);
        let mut readbuf = buf.as_slice();
        let dd2 = DataDescriptorZip64Signature::from_buf(&mut readbuf).unwrap();
        assert_eq!(dd, dd2);
    }
}