chore: Move tests inline with code under test (#58)

Author: scouten

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
         uses: taiki-e/install-action@cargo-llvm-cov
 
       - name: Generate code coverage
-        run: cargo llvm-cov --lib --all-features --lcov --ignore-filename-regex tests --output-path lcov.info
+        run: cargo llvm-cov --lib --all-features --lcov --output-path lcov.info
 
       - name: Filter out tests
         uses: scouten/uncover-tests@v1

src/box_type.rs

@@ -63,3 +63,24 @@ pub const DESCRIPTION_BOX_TYPE: BoxType = BoxType(*b"jumd");
 
 /// Box type for JUMBF super box (`b"jumb"`).
 pub const SUPER_BOX_TYPE: BoxType = BoxType(*b"jumb");
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::expect_used)]
+    #![allow(clippy::panic)]
+    #![allow(clippy::unwrap_used)]
+
+    use crate::BoxType;
+
+    #[test]
+    fn impl_debug() {
+        let x = BoxType([1, 2, 3, 4]);
+        assert_eq!(format!("{x:#?}"), "[0x01, 0x02, 0x03, 0x04]");
+
+        let x = BoxType(*b"abcd");
+        assert_eq!(format!("{x:#?}"), "b\"abcd\"");
+
+        let x = BoxType([b'a', b'b', b'c', 0x7f]);
+        assert_eq!(format!("{x:#?}"), "[0x61, 0x62, 0x63, 0x7f]");
+    }
+}

src/builder/data_box_builder.rs

@@ -73,3 +73,74 @@ impl<'a> ToBox for DataBoxBuilder<'a> {
         to_stream.write_all(&self.data)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::expect_used)]
+    #![allow(clippy::panic)]
+    #![allow(clippy::unwrap_used)]
+
+    use std::io::Cursor;
+
+    use hex_literal::hex;
+
+    use crate::{
+        box_type::DESCRIPTION_BOX_TYPE,
+        builder::{
+            to_box::{jumbf_size, write_jumbf},
+            DataBoxBuilder, ToBox,
+        },
+    };
+
+    #[test]
+    fn simple_box_borrowed() {
+        let expected_jumbf = hex!(
+            "00000026" // box size
+            "6a756d64" // box type = 'jumd'
+            "00000000000000000000000000000000" // UUID
+            "03" // toggles
+            "746573742e64657363626f7800" // label
+        );
+
+        let boxx = DataBoxBuilder::from_borrowed(DESCRIPTION_BOX_TYPE, &expected_jumbf[8..]);
+
+        assert_eq!(boxx.box_type(), DESCRIPTION_BOX_TYPE);
+        assert_eq!(boxx.payload_size().unwrap(), 30);
+
+        let mut payload = Cursor::new(Vec::<u8>::new());
+        boxx.write_payload(&mut payload).unwrap();
+        assert_eq!(*payload.into_inner(), expected_jumbf[8..]);
+
+        assert_eq!(jumbf_size(&boxx).unwrap(), 38);
+
+        let mut jumbf = Cursor::new(Vec::<u8>::new());
+        write_jumbf(&boxx, &mut jumbf).unwrap();
+        assert_eq!(*jumbf.into_inner(), expected_jumbf);
+    }
+
+    #[test]
+    fn simple_box_owned() {
+        let expected_jumbf = hex!(
+            "00000026" // box size
+            "6a756d64" // box type = 'jumd'
+            "00000000000000000000000000000000" // UUID
+            "03" // toggles
+            "746573742e64657363626f7800" // label
+        );
+
+        let boxx = DataBoxBuilder::from_owned(DESCRIPTION_BOX_TYPE, expected_jumbf[8..].to_owned());
+
+        assert_eq!(boxx.box_type(), DESCRIPTION_BOX_TYPE);
+        assert_eq!(boxx.payload_size().unwrap(), 30);
+
+        let mut payload = Cursor::new(Vec::<u8>::new());
+        boxx.write_payload(&mut payload).unwrap();
+        assert_eq!(*payload.into_inner(), expected_jumbf[8..]);
+
+        assert_eq!(jumbf_size(&boxx).unwrap(), 38);
+
+        let mut jumbf = Cursor::new(Vec::<u8>::new());
+        write_jumbf(&boxx, &mut jumbf).unwrap();
+        assert_eq!(*jumbf.into_inner(), expected_jumbf);
+    }
+}

src/builder/placeholder_data_box.rs

@@ -120,3 +120,147 @@ impl ToBox for PlaceholderDataBox {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::expect_used)]
+    #![allow(clippy::panic)]
+    #![allow(clippy::unwrap_used)]
+
+    use std::io::{Cursor, Write};
+
+    use hex_literal::hex;
+
+    use crate::{
+        builder::{
+            to_box::{jumbf_size, write_jumbf},
+            PlaceholderDataBox, ToBox,
+        },
+        BoxType,
+    };
+
+    const RANDOM_BOX_TYPE: BoxType = BoxType(*b"abcd");
+
+    #[test]
+    fn simple_case() {
+        let expected_jumbf = hex!(
+            "00000018" // box size
+            "61626364" // box type = 'abcd'
+            "00000000000000000000000000000000" // placeholder
+        );
+
+        let pbox = PlaceholderDataBox::new(RANDOM_BOX_TYPE, 16);
+
+        assert_eq!(pbox.box_type(), RANDOM_BOX_TYPE);
+        assert_eq!(pbox.payload_size().unwrap(), 16);
+        assert_eq!(jumbf_size(&pbox).unwrap(), 24);
+
+        let mut jumbf = Cursor::new(Vec::<u8>::new());
+        write_jumbf(&pbox, &mut jumbf).unwrap();
+        assert_eq!(*jumbf.get_ref(), expected_jumbf);
+
+        let expected_jumbf = hex!(
+            "00000018" // box size
+            "61626364" // box type = 'abcd'
+            "31323334353637383930000000000000" // replacement payload
+        );
+
+        pbox.replace_payload(&mut jumbf, &expected_jumbf[8..18])
+            .unwrap();
+        assert_eq!(*jumbf.get_ref(), expected_jumbf);
+    }
+
+    #[test]
+    fn error_write_payload_only() {
+        // PlaceholderDataBox reports an error if its .write_payload() method
+        // is called by itself.
+
+        let pbox = PlaceholderDataBox::new(RANDOM_BOX_TYPE, 16);
+
+        let mut payload = Cursor::new(Vec::<u8>::new());
+        let err = pbox.write_payload(&mut payload).unwrap_err();
+        assert_eq!(
+            "Custom { kind: Other, error: \"placeholder stream should have some data already\" }",
+            format!("{err:?}")
+        );
+    }
+
+    #[test]
+    fn error_payload_too_large() {
+        let expected_jumbf = hex!(
+            "00000018" // box size
+            "61626364" // box type = 'abcd'
+            "00000000000000000000000000000000" // placeholder
+        );
+
+        let pbox = PlaceholderDataBox::new(RANDOM_BOX_TYPE, 16);
+
+        let mut jumbf = Cursor::new(Vec::<u8>::new());
+        write_jumbf(&pbox, &mut jumbf).unwrap();
+        assert_eq!(*jumbf.get_ref(), expected_jumbf);
+
+        let payload_too_large = [1u8; 17];
+        let err = pbox
+            .replace_payload(&mut jumbf, &payload_too_large)
+            .unwrap_err();
+
+        assert_eq!(
+            "Custom { kind: Other, error: \"replace_payload: payload (17 bytes) is larger than reserved capacity (16 bytes)\" }",
+            format!("{err:?}")
+        );
+
+        // No part of the original JUMBF as written should have been changed.
+        assert_eq!(*jumbf.get_ref(), expected_jumbf);
+    }
+
+    #[test]
+    fn error_write_jumbf_not_called() {
+        let pbox = PlaceholderDataBox::new(RANDOM_BOX_TYPE, 16);
+
+        let mut jumbf = Cursor::new(Vec::<u8>::new());
+        let payload = [1u8; 16];
+        let err = pbox.replace_payload(&mut jumbf, &payload).unwrap_err();
+
+        assert_eq!(
+            "Custom { kind: Other, error: \"replace_payload: no offset recorded; call write_jumbf() first\" }",
+            format!("{err:?}")
+        );
+
+        // No part of the original JUMBF as written should have been changed.
+        assert_eq!(*jumbf.get_ref(), []);
+    }
+
+    #[test]
+    fn offset() {
+        let expected_jumbf = hex!(
+            "41424344" // arbitrary prefix = 'ABCD'
+            "00000018" // box size
+            "61626364" // box type = 'abcd'
+            "00000000000000000000000000000000" // placeholder
+        );
+
+        let pbox = PlaceholderDataBox::new(RANDOM_BOX_TYPE, 16);
+
+        assert_eq!(pbox.box_type(), RANDOM_BOX_TYPE);
+        assert_eq!(pbox.payload_size().unwrap(), 16);
+        assert_eq!(jumbf_size(&pbox).unwrap(), 24);
+
+        let mut jumbf = Cursor::new(Vec::<u8>::new());
+        jumbf.write_all(b"ABCD").unwrap();
+
+        write_jumbf(&pbox, &mut jumbf).unwrap();
+        assert_eq!(*jumbf.get_ref(), expected_jumbf);
+
+        assert_eq!(pbox.offset(), Some(12));
+    }
+
+    #[test]
+    fn offset_before_write() {
+        let pbox = PlaceholderDataBox::new(RANDOM_BOX_TYPE, 16);
+
+        assert_eq!(pbox.box_type(), RANDOM_BOX_TYPE);
+        assert_eq!(pbox.payload_size().unwrap(), 16);
+        assert_eq!(jumbf_size(&pbox).unwrap(), 24);
+        assert_eq!(pbox.offset(), None);
+    }
+}