Pch07/ffmpeg non io tests

crates/ffmpeg/Cargo.toml

@@ -23,10 +23,13 @@ arc-swap = { version = "1.7" }
 ffmpeg-sys-next = { version = "7.1.0" }
 scuffle-workspace-hack.workspace = true
 rand = "0.8"
+bon = "3.3.2"
 
 [dev-dependencies]
 insta = {version = "1.42", features = ["filters"]}
 tempfile = "3.15"
+tracing-test = "0.2"
+tracing-subscriber = "0.3"
 
 [features]
 channel = ["dep:bytes"]

crates/ffmpeg/src/codec.rs

@@ -128,3 +128,183 @@ impl From<DecoderCodec> for *const AVCodec {
         codec.0
     }
 }
+
+#[cfg(test)]
+#[cfg_attr(all(test, coverage_nightly), coverage(off))]
+mod tests {
+    use ffmpeg_sys_next::AVCodecID::{self, AV_CODEC_ID_AAC, AV_CODEC_ID_H264};
+    use ffmpeg_sys_next::{avcodec_find_decoder, avcodec_find_encoder, AVCodec};
+
+    use crate::codec::{DecoderCodec, EncoderCodec};
+
+    #[test]
+    fn test_decoder_codec_debug_null() {
+        let decoder_codec = DecoderCodec::empty();
+        let debug_output = format!("{:?}", decoder_codec);
+
+        insta::assert_snapshot!(debug_output, @r#"DecoderCodec { name: "null", id: AV_CODEC_ID_NONE }"#);
+    }
+
+    #[test]
+    fn test_decoder_codec_debug_non_null() {
+        let decoder_codec = DecoderCodec::new(AV_CODEC_ID_H264).expect("H264 codec should be available");
+        let debug_output = format!("{:?}", decoder_codec);
+
+        insta::assert_snapshot!(debug_output, @r#"DecoderCodec { name: "h264", id: AV_CODEC_ID_H264 }"#);
+    }
+
+    #[test]
+    fn test_decoder_codec_new_invalid_codec_id() {
+        let invalid_codec_id = AVCodecID::AV_CODEC_ID_NONE;
+        let result = DecoderCodec::new(invalid_codec_id);
+
+        assert!(
+            result.is_none(),
+            "Expected `DecoderCodec::new` to return None for an invalid codec ID"
+        );
+    }
+
+    #[test]
+    fn test_decoder_codec_by_name_valid() {
+        let result = DecoderCodec::by_name("h264");
+
+        assert!(
+            result.is_some(),
+            "Expected `DecoderCodec::by_name` to return Some for a valid codec name"
+        );
+
+        let codec = result.unwrap();
+        assert!(!codec.as_ptr().is_null(), "Expected a non-null codec pointer");
+    }
+
+    #[test]
+    fn test_decoder_codec_by_name_invalid() {
+        let invalid_codec_name = "nonexistent_codec";
+        let result = DecoderCodec::by_name(invalid_codec_name);
+
+        assert!(
+            result.is_none(),
+            "Expected `DecoderCodec::by_name` to return None for an invalid codec name"
+        );
+    }
+
+    #[test]
+    fn test_decoder_codec_from_ptr_valid() {
+        let codec_ptr = unsafe { avcodec_find_decoder(AVCodecID::AV_CODEC_ID_H264) };
+        assert!(!codec_ptr.is_null(), "Expected a valid codec pointer for H264");
+
+        let decoder_codec = DecoderCodec::from_ptr(codec_ptr);
+        assert_eq!(
+            decoder_codec.as_ptr(),
+            codec_ptr,
+            "Expected the codec pointer in DecoderCodec to match the original pointer"
+        );
+    }
+
+    #[test]
+    fn test_encoder_codec_debug_valid() {
+        let codec_ptr = unsafe { avcodec_find_encoder(AVCodecID::AV_CODEC_ID_MPEG4) };
+        assert!(!codec_ptr.is_null(), "Expected a valid codec pointer for MPEG4");
+
+        let encoder_codec = EncoderCodec(codec_ptr);
+        insta::assert_debug_snapshot!(encoder_codec, @r#"
+        EncoderCodec {
+            name: "mpeg4",
+            id: AV_CODEC_ID_MPEG4,
+        }
+        "#);
+    }
+
+    #[test]
+    fn test_encoder_codec_debug_null() {
+        let encoder_codec = EncoderCodec(std::ptr::null());
+        insta::assert_debug_snapshot!(encoder_codec, @r#"
+        EncoderCodec {
+            name: "null",
+            id: AV_CODEC_ID_NONE,
+        }
+        "#);
+    }
+
+    #[test]
+    fn test_encoder_codec_empty() {
+        let encoder_codec = EncoderCodec::empty();
+        assert!(
+            encoder_codec.as_ptr().is_null(),
+            "Expected the encoder codec pointer to be null"
+        );
+
+        insta::assert_debug_snapshot!(encoder_codec, @r#"
+        EncoderCodec {
+            name: "null",
+            id: AV_CODEC_ID_NONE,
+        }
+        "#);
+    }
+
+    #[test]
+    fn test_encoder_codec_new_invalid_codec() {
+        let invalid_codec_id = AVCodecID::AV_CODEC_ID_NONE;
+        let result = EncoderCodec::new(invalid_codec_id);
+
+        assert!(result.is_none(), "Expected None for an invalid codec ID");
+    }
+
+    #[test]
+    fn test_encoder_codec_by_name_valid() {
+        let result = EncoderCodec::by_name("mpeg4");
+        assert!(result.is_some(), "Expected a valid encoder codec for the name {}", "mpeg4");
+
+        let encoder_codec = result.unwrap();
+        assert!(!encoder_codec.as_ptr().is_null(), "Expected a non-null encoder codec pointer");
+    }
+
+    #[test]
+    fn test_encoder_codec_by_name_invalid() {
+        let invalid_encoder_name = "invalid_encoder_name";
+        let result = EncoderCodec::by_name(invalid_encoder_name);
+
+        assert!(
+            result.is_none(),
+            "Expected None for an invalid encoder name {}",
+            invalid_encoder_name
+        );
+    }
+
+    #[test]
+    fn test_encoder_codec_into_raw_ptr() {
+        let valid_codec_id = AV_CODEC_ID_AAC;
+        let encoder_codec = EncoderCodec::new(valid_codec_id).expect("Expected a valid encoder codec for AAC");
+        let raw_ptr: *const AVCodec = encoder_codec.into();
+
+        assert_eq!(
+            raw_ptr,
+            encoder_codec.as_ptr(),
+            "The raw pointer should match the encoder codec's internal pointer"
+        );
+    }
+
+    #[test]
+    fn test_decoder_codec_into_raw_ptr() {
+        let valid_codec_id = AV_CODEC_ID_AAC;
+        let decoder_codec = DecoderCodec::new(valid_codec_id).expect("Expected a valid decoder codec for AAC");
+        let raw_ptr: *const AVCodec = decoder_codec.into();
+
+        assert_eq!(
+            raw_ptr,
+            decoder_codec.as_ptr(),
+            "The raw pointer should match the decoder codec's internal pointer"
+        );
+    }
+
+    #[test]
+    fn test_codec_into_raw_ptr_empty() {
+        let empty_encoder_codec = EncoderCodec::empty();
+        let raw_ptr: *const AVCodec = empty_encoder_codec.into();
+        assert!(raw_ptr.is_null(), "The raw pointer should be null for an empty EncoderCodec");
+
+        let empty_decoder_codec = DecoderCodec::empty();
+        let raw_ptr: *const AVCodec = empty_decoder_codec.into();
+        assert!(raw_ptr.is_null(), "The raw pointer should be null for an empty DecoderCodec");
+    }
+}

crates/ffmpeg/src/consts.rs

@@ -51,3 +51,26 @@ impl<T> std::ops::DerefMut for Mut<'_, T> {
         &mut self.0
     }
 }
+
+#[cfg(test)]
+#[cfg_attr(all(test, coverage_nightly), coverage(off))]
+mod tests {
+    use crate::consts::Mut;
+
+    #[test]
+    fn test_mut_fmt_vec() {
+        let value = vec![1, 2, 3];
+        let mut_value = Mut::new(value);
+
+        assert_eq!(format!("{:?}", mut_value), "[1, 2, 3]");
+    }
+
+    #[test]
+    fn test_deref_for_mut_with_complex_type() {
+        let value = vec![1, 2, 3];
+        let mut_value = Mut::new(value);
+        let deref_value: &Vec<i32> = &mut_value;
+
+        assert_eq!(deref_value, &vec![1, 2, 3], "Dereferencing Mut should return the inner value");
+    }
+}