Implement PartialEq<&[u8; 4]> for FourCC and simplify tests.

Implementing PartialEq<&[u8; 4]> for FourCC allows us to simplify the
comparisons being made in tests. It also makes non-test comparisons more
concise. We don't appear to have any non test comparisons at this stage,
but consumers of the API can benefit, as we may in future.

Author: SingingTree

mp4parse/src/boxes.rs

@@ -94,6 +94,12 @@ impl fmt::Display for FourCC {
     }
 }
 
+impl PartialEq<&[u8; 4]> for FourCC {
+    fn eq(&self, other: &&[u8; 4]) -> bool {
+        self.value.eq(*other)
+    }
+}
+
 box_database!(
     FileTypeBox                       0x6674_7970, // "ftyp"
     MediaDataBox                      0x6d64_6174, // "mdat"

mp4parse/src/tests.rs

@@ -17,7 +17,7 @@ use std::io::Read as _;
 extern crate test_assembler;
 use self::test_assembler::*;
 
-use boxes::{BoxType, FourCC};
+use boxes::BoxType;
 
 enum BoxSize {
     Short(u32),
@@ -181,11 +181,11 @@ fn read_ftyp() {
     assert_eq!(stream.head.name, BoxType::FileTypeBox);
     assert_eq!(stream.head.size, 24);
     let parsed = super::read_ftyp(&mut stream).unwrap();
-    assert_eq!(parsed.major_brand, FourCC::from(*b"mp42")); // mp42
+    assert_eq!(parsed.major_brand, b"mp42"); // mp42
     assert_eq!(parsed.minor_version, 0);
     assert_eq!(parsed.compatible_brands.len(), 2);
-    assert_eq!(parsed.compatible_brands[0], FourCC::from(*b"isom")); // isom
-    assert_eq!(parsed.compatible_brands[1], FourCC::from(*b"mp42")); // mp42
+    assert_eq!(parsed.compatible_brands[0], b"isom"); // isom
+    assert_eq!(parsed.compatible_brands[1], b"mp42"); // mp42
 }
 
 #[test]
@@ -223,11 +223,11 @@ fn read_ftyp_case() {
     assert_eq!(stream.head.name, BoxType::FileTypeBox);
     assert_eq!(stream.head.size, 24);
     let parsed = super::read_ftyp(&mut stream).unwrap();
-    assert_eq!(parsed.major_brand, FourCC::from(*b"MP42"));
+    assert_eq!(parsed.major_brand, b"MP42");
     assert_eq!(parsed.minor_version, 0);
     assert_eq!(parsed.compatible_brands.len(), 2);
-    assert_eq!(parsed.compatible_brands[0], FourCC::from(*b"ISOM")); // ISOM
-    assert_eq!(parsed.compatible_brands[1], FourCC::from(*b"MP42")); // MP42
+    assert_eq!(parsed.compatible_brands[0], b"ISOM"); // ISOM
+    assert_eq!(parsed.compatible_brands[1], b"MP42"); // MP42
 }
 
 #[test]
@@ -474,7 +474,7 @@ fn read_hdlr() {
     assert_eq!(stream.head.name, BoxType::HandlerBox);
     assert_eq!(stream.head.size, 45);
     let parsed = super::read_hdlr(&mut stream).unwrap();
-    assert_eq!(parsed.handler_type, FourCC::from(*b"vide"));
+    assert_eq!(parsed.handler_type, b"vide");
 }
 
 #[test]
@@ -487,7 +487,7 @@ fn read_hdlr_short_name() {
     assert_eq!(stream.head.name, BoxType::HandlerBox);
     assert_eq!(stream.head.size, 33);
     let parsed = super::read_hdlr(&mut stream).unwrap();
-    assert_eq!(parsed.handler_type, FourCC::from(*b"vide"));
+    assert_eq!(parsed.handler_type, b"vide");
 }
 
 #[test]
@@ -500,7 +500,7 @@ fn read_hdlr_zero_length_name() {
     assert_eq!(stream.head.name, BoxType::HandlerBox);
     assert_eq!(stream.head.size, 32);
     let parsed = super::read_hdlr(&mut stream).unwrap();
-    assert_eq!(parsed.handler_type, FourCC::from(*b"vide"));
+    assert_eq!(parsed.handler_type, b"vide");
 }
 
 fn flac_streaminfo() -> Vec<u8> {

mp4parse/tests/public.rs

@@ -309,9 +309,9 @@ fn public_audio_tenc() {
         assert_eq!(a.codec_type, mp4::CodecType::EncryptedAudio);
         match a.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
             Some(ref p) => {
-                assert_eq!(p.original_format.value, *b"mp4a");
+                assert_eq!(p.original_format, b"mp4a");
                 if let Some(ref schm) = p.scheme_type {
-                    assert_eq!(schm.scheme_type.value, *b"cenc");
+                    assert_eq!(schm.scheme_type, b"cenc");
                 } else {
                     panic!("Expected scheme type info");
                 }
@@ -368,9 +368,9 @@ fn public_video_cenc() {
         assert_eq!(v.codec_type, mp4::CodecType::EncryptedVideo);
         match v.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
             Some(ref p) => {
-                assert_eq!(p.original_format.value, *b"avc1");
+                assert_eq!(p.original_format, b"avc1");
                 if let Some(ref schm) = p.scheme_type {
-                    assert_eq!(schm.scheme_type.value, *b"cenc");
+                    assert_eq!(schm.scheme_type, b"cenc");
                 } else {
                     panic!("Expected scheme type info");
                 }
@@ -441,9 +441,9 @@ fn public_audio_cbcs() {
                 mp4::SampleEntry::Audio(ref a) => {
                     if let Some(p) = a.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
                         found_encrypted_sample_description = true;
-                        assert_eq!(p.original_format.value, *b"mp4a");
+                        assert_eq!(p.original_format, b"mp4a");
                         if let Some(ref schm) = p.scheme_type {
-                            assert_eq!(schm.scheme_type.value, *b"cbcs");
+                            assert_eq!(schm.scheme_type, b"cbcs");
                         } else {
                             panic!("Expected scheme type info");
                         }
@@ -526,9 +526,9 @@ fn public_video_cbcs() {
                     assert_eq!(v.height, 300);
                     if let Some(p) = v.protection_info.iter().find(|sinf| sinf.tenc.is_some()) {
                         found_encrypted_sample_description = true;
-                        assert_eq!(p.original_format.value, *b"avc1");
+                        assert_eq!(p.original_format, b"avc1");
                         if let Some(ref schm) = p.scheme_type {
-                            assert_eq!(schm.scheme_type.value, *b"cbcs");
+                            assert_eq!(schm.scheme_type, b"cbcs");
                         } else {
                             panic!("Expected scheme type info");
                         }