add unit tests for FileHeader

Added tests that check:
- if valid headers do indeed parse sucessfully,
- if correct values are stored into the FileHeader struct,
- if correct error is thrown when file ends unexprectedly,
- that the header data is not completely incorrect.

Author: ev3nvy

src/parser/header.rs

@@ -87,3 +87,240 @@ impl TryFrom<&[u8]> for FileHeader {
         Ok(file_header)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod helpers {
+        pub const VALID_HEADER: [u8; 32] = [
+            0x52, 0x4D, 0x41, 0x4E, 0x02, 0x00, 0x00, 0x02, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0xD2, 0x17, 0xC3, 0xEF, 0xAB, 0x4A, 0x9C, 0x2B, 0x60, 0xA4, 0xD0, 0x01,
+            0x00, 0x00, 0x00, 0x00,
+        ];
+
+        macro_rules! assert_error {
+            ($buf: ident, $error: ident) => {
+                let Err(error) = crate::FileHeader::try_from(&$buf[..]) else {
+                                                    panic!("did not throw an error");
+                                                };
+                let crate::error::ManifestError::$error(..) = error else {
+                                                    panic!("some other error was thrown");
+                                                };
+            };
+        }
+
+        pub(crate) use assert_error;
+    }
+
+    #[test]
+    fn should_parse_when_valid_header() {
+        if let Err(error) = FileHeader::try_from(&helpers::VALID_HEADER[..]) {
+            panic!(
+                "there was an error when parsing header, header: {:?}",
+                error
+            );
+        };
+    }
+
+    #[test]
+    fn should_have_correct_values_when_valid_header() {
+        let header = FileHeader::try_from(&helpers::VALID_HEADER[..]).unwrap();
+
+        assert_eq!(header.magic, 0x4E414D52, "magic bytes did not match");
+        assert_eq!(header.major, 2, "major version did not match");
+        assert_eq!(header.minor, 0, "minor version did not match");
+        assert_eq!(header.flags, 512, "flags did not match");
+        assert_eq!(header.offset, 28, "offset did not match");
+        assert_eq!(header.compressed_size, 0, "compressed size did not match");
+        assert_eq!(
+            header.manifest_id, 3142468742320166866,
+            "manifest id did not match"
+        );
+        assert_eq!(
+            header.uncompressed_size, 30450784,
+            "unompressed size did not match"
+        );
+    }
+
+    #[test]
+    fn should_throw_correct_errors_when_eof() {
+        // EOF when reading magic bytes
+        let error = FileHeader::try_from(&helpers::VALID_HEADER[..3])
+            .err()
+            .expect("did not throw an error on missing bytes");
+        match error {
+            crate::error::ManifestError::ReadBytesError(_) => (),
+            _ => panic!("invalid ManifestError error when eof"),
+        };
+
+        // EOF when reading major
+        let error = FileHeader::try_from(&helpers::VALID_HEADER[..4])
+            .err()
+            .expect("did not throw an error on missing bytes");
+        match error {
+            crate::error::ManifestError::ReadBytesError(_) => (),
+            _ => panic!("invalid ManifestError error when eof"),
+        };
+
+        // EOF when reading minor
+        let error = FileHeader::try_from(&helpers::VALID_HEADER[..5])
+            .err()
+            .expect("did not throw an error on missing bytes");
+        match error {
+            crate::error::ManifestError::ReadBytesError(_) => (),
+            _ => panic!("invalid ManifestError error when eof"),
+        };
+
+        // EOF when reading flags
+        let error = FileHeader::try_from(&helpers::VALID_HEADER[..7])
+            .err()
+            .expect("did not throw an error on missing bytes");
+        match error {
+            crate::error::ManifestError::ReadBytesError(_) => (),
+            _ => panic!("invalid ManifestError error when eof"),
+        };
+
+        // EOF when reading offset
+        let error = FileHeader::try_from(&helpers::VALID_HEADER[..11])
+            .err()
+            .expect("did not throw an error on missing bytes");
+        match error {
+            crate::error::ManifestError::ReadBytesError(_) => (),
+            _ => panic!("invalid ManifestError error when eof"),
+        };
+
+        // it should be impossible for reading to fail at this point, because
+        // offset must be greater than 28 and and less then file size, which
+        // in turn ensures that the file size is at least 28 bytes
+    }
+
+    #[test]
+    fn should_error_when_invalid_magic_bytes() {
+        let buf = [&[0x53], &helpers::VALID_HEADER[1..]].concat();
+
+        helpers::assert_error!(buf, InvalidMagicBytes);
+    }
+
+    #[test]
+    fn should_error_when_invalid_major() {
+        let buf = [
+            &helpers::VALID_HEADER[..4],
+            &[0x01],
+            &helpers::VALID_HEADER[5..],
+        ]
+        .concat();
+
+        #[cfg(not(feature = "version_error"))]
+        if let Err(_) = FileHeader::try_from(&buf[..]) {
+            panic!("error was thrown");
+        }
+
+        #[cfg(feature = "version_error")]
+        helpers::assert_error!(buf, InvalidMajor);
+    }
+
+    #[test]
+    fn should_error_when_invalid_minor() {
+        let buf = [
+            &helpers::VALID_HEADER[..5],
+            &[0x01],
+            &helpers::VALID_HEADER[6..],
+        ]
+        .concat();
+
+        #[cfg(not(feature = "version_error"))]
+        if let Err(_) = FileHeader::try_from(&buf[..]) {
+            panic!("error was thrown")
+        }
+
+        #[cfg(feature = "version_error")]
+        helpers::assert_error!(buf, InvalidMinor);
+    }
+
+    #[test]
+    fn should_error_when_offset_too_small() {
+        // too small
+        let buf = [
+            &helpers::VALID_HEADER[..8],
+            &0u32.to_le_bytes(),
+            &helpers::VALID_HEADER[12..],
+        ]
+        .concat();
+
+        helpers::assert_error!(buf, InvalidOffset);
+
+        // slightly too small
+        let buf = [
+            &helpers::VALID_HEADER[..8],
+            &27u32.to_le_bytes(),
+            &helpers::VALID_HEADER[12..],
+        ]
+        .concat();
+
+        helpers::assert_error!(buf, InvalidOffset);
+    }
+
+    #[test]
+    fn should_error_when_offset_too_large() {
+        // slightly too large
+        let size = u32::try_from(helpers::VALID_HEADER.len()).unwrap();
+        let buf = [
+            &helpers::VALID_HEADER[..8],
+            &size.to_le_bytes(),
+            &helpers::VALID_HEADER[12..],
+        ]
+        .concat();
+
+        helpers::assert_error!(buf, InvalidOffset);
+
+        // too large
+        let buf = [
+            &helpers::VALID_HEADER[..8],
+            &u32::MAX.to_le_bytes(),
+            &helpers::VALID_HEADER[12..],
+        ]
+        .concat();
+
+        helpers::assert_error!(buf, InvalidOffset);
+    }
+
+    #[test]
+    fn should_error_when_compressed_size_too_large() {
+        // slightly too large
+        let size = u32::try_from(helpers::VALID_HEADER.len()).unwrap();
+        let buf = [
+            &helpers::VALID_HEADER[..12],
+            &(size - 27).to_le_bytes(),
+            &helpers::VALID_HEADER[16..],
+        ]
+        .concat();
+
+        helpers::assert_error!(buf, CompressedSizeTooLarge);
+
+        // too large
+        let buf = [
+            &helpers::VALID_HEADER[..12],
+            &u32::MAX.to_le_bytes(),
+            &helpers::VALID_HEADER[16..],
+        ]
+        .concat();
+
+        helpers::assert_error!(buf, CompressedSizeTooLarge);
+    }
+
+    #[test]
+    fn should_error_when_compressed_size_and_offset_too_large() {
+        let offset = 28u32;
+        let size = u32::try_from(helpers::VALID_HEADER.len()).unwrap();
+        let buf = [
+            &helpers::VALID_HEADER[..8],
+            &offset.to_le_bytes(),
+            &(size - offset + 1).to_le_bytes(),
+            &helpers::VALID_HEADER[16..],
+        ]
+        .concat();
+
+        helpers::assert_error!(buf, CompressedSizeTooLarge);
+    }
+}