Tests: Update Taglib tests for new type names

Serial-ATA · Serial-ATA · commit a54078c05ea8 · 2023-04-22T14:13:14.000-04:00
diff --git a/tests/taglib/test_aiff.rs b/tests/taglib/test_aiff.rs
@@ -10,7 +10,7 @@ use crate::{assert_delta, temp_file};
 fn test_aiff_properties() {
 	let file = lofty::read_from_path("tests/taglib/data/empty.aiff").unwrap();
 
-	assert_eq!(file.file_type(), FileType::AIFF);
+	assert_eq!(file.file_type(), FileType::Aiff);
 
 	let properties = file.properties();
 	assert_eq!(properties.duration().as_secs(), 0);
@@ -29,7 +29,7 @@ fn test_aiff_properties() {
 fn test_aifc_properties() {
 	let file = lofty::read_from_path("tests/taglib/data/alaw.aifc").unwrap();
 
-	assert_eq!(file.file_type(), FileType::AIFF);
+	assert_eq!(file.file_type(), FileType::Aiff);
 
 	let properties = file.properties();
 	assert_eq!(properties.duration().as_secs(), 0);
@@ -53,42 +53,42 @@ fn test_save_id3v2() {
 	{
 		let mut tfile = lofty::read_from(&mut file).unwrap();
 
-		assert_eq!(tfile.file_type(), FileType::AIFF);
+		assert_eq!(tfile.file_type(), FileType::Aiff);
 
-		assert!(tfile.tag(lofty::TagType::ID3v2).is_none());
+		assert!(tfile.tag(lofty::TagType::Id3v2).is_none());
 
-		let mut tag = lofty::Tag::new(lofty::TagType::ID3v2);
+		let mut tag = lofty::Tag::new(lofty::TagType::Id3v2);
 		tag.set_title("TitleXXX".to_string());
 		tfile.insert_tag(tag);
 		file.rewind().unwrap();
 		tfile.save_to(&mut file).unwrap();
-		assert!(tfile.contains_tag_type(lofty::TagType::ID3v2));
+		assert!(tfile.contains_tag_type(lofty::TagType::Id3v2));
 	}
 
 	file.rewind().unwrap();
 
 	{
 		let mut tfile = lofty::read_from(&mut file).unwrap();
 
-		assert_eq!(tfile.file_type(), FileType::AIFF);
+		assert_eq!(tfile.file_type(), FileType::Aiff);
 
-		let mut tag = tfile.tag(lofty::TagType::ID3v2).unwrap().to_owned();
+		let mut tag = tfile.tag(lofty::TagType::Id3v2).unwrap().to_owned();
 		assert_eq!(tag.title().as_deref(), Some("TitleXXX"));
 		tag.set_title("".to_string());
 		tfile.insert_tag(tag);
 		file.rewind().unwrap();
 		tfile.save_to(&mut file).unwrap();
-		assert!(!tfile.contains_tag_type(lofty::TagType::ID3v2));
+		assert!(!tfile.contains_tag_type(lofty::TagType::Id3v2));
 	}
 
 	file.rewind().unwrap();
 
 	{
 		let tfile = lofty::read_from(&mut file).unwrap();
 
-		assert_eq!(tfile.file_type(), FileType::AIFF);
+		assert_eq!(tfile.file_type(), FileType::Aiff);
 
-		assert!(!tfile.contains_tag_type(lofty::TagType::ID3v2));
+		assert!(!tfile.contains_tag_type(lofty::TagType::Id3v2));
 	}
 }
 
@@ -100,7 +100,7 @@ fn test_save_id3v2() {
 fn test_fuzzed_file1() {
 	assert_eq!(
 		get_filetype("tests/taglib/data/segfault.aif"),
-		FileType::AIFF
+		FileType::Aiff
 	);
 }
 
diff --git a/tests/taglib/test_ape.rs b/tests/taglib/test_ape.rs
@@ -80,13 +80,13 @@ fn test_properties_390() {
 fn test_fuzzed_file_1() {
 	assert_eq!(
 		get_filetype("tests/taglib/data/longloop.ape"),
-		FileType::APE
+		FileType::Ape
 	);
 }
 
 #[test]
 fn test_fuzzed_file_2() {
-	assert_eq!(get_filetype("tests/taglib/data/zerodiv.ape"), FileType::APE);
+	assert_eq!(get_filetype("tests/taglib/data/zerodiv.ape"), FileType::Ape);
 }
 
 #[test]
diff --git a/tests/taglib/test_fileref.rs b/tests/taglib/test_fileref.rs
@@ -103,12 +103,12 @@ fn test_speex() {
 
 #[test]
 fn test_flac() {
-	file_ref_save("no-tags.flac", FileType::FLAC);
+	file_ref_save("no-tags.flac", FileType::Flac);
 }
 
 #[test]
 fn test_mp3() {
-	file_ref_save("xing.mp3", FileType::MPEG);
+	file_ref_save("xing.mp3", FileType::Mpeg);
 }
 
 #[test]
@@ -120,35 +120,35 @@ fn test_true_audio() {
 
 #[test]
 fn test_mp4_1() {
-	file_ref_save("has-tags.m4a", FileType::MP4);
+	file_ref_save("has-tags.m4a", FileType::Mp4);
 }
 
 #[test]
 #[ignore] // TODO: The file has a malformed `free` atom. How does TagLib handle this? Currently we mess up entirely and just write a duplicate tag.
 fn test_mp4_2() {
-	file_ref_save("no-tags.m4a", FileType::MP4);
+	file_ref_save("no-tags.m4a", FileType::Mp4);
 }
 
 #[test]
 #[ignore] // TODO: We are able to write the first tag and even reread, but the second save causes a `SizeMismatch`.
 fn test_mp4_3() {
-	file_ref_save("no-tags.3g2", FileType::MP4);
+	file_ref_save("no-tags.3g2", FileType::Mp4);
 }
 
 #[test]
 fn test_mp4_4() {
-	file_ref_save("blank_video.m4v", FileType::MP4);
+	file_ref_save("blank_video.m4v", FileType::Mp4);
 }
 
 #[test]
 fn test_wav() {
-	file_ref_save("empty.wav", FileType::WAV);
+	file_ref_save("empty.wav", FileType::Wav);
 }
 
 #[test]
 #[ignore] // TODO: We don't yet support FLAC in oga
 fn test_oga_flac() {
-	file_ref_save("empty_flac.oga", FileType::FLAC);
+	file_ref_save("empty_flac.oga", FileType::Flac);
 }
 
 #[test]
@@ -158,17 +158,17 @@ fn test_oga_vorbis() {
 
 #[test]
 fn test_ape() {
-	file_ref_save("mac-399.ape", FileType::APE);
+	file_ref_save("mac-399.ape", FileType::Ape);
 }
 
 #[test]
 fn test_aiff_1() {
-	file_ref_save("empty.aiff", FileType::AIFF);
+	file_ref_save("empty.aiff", FileType::Aiff);
 }
 
 #[test]
 fn test_aiff_2() {
-	file_ref_save("alaw.aifc", FileType::AIFF);
+	file_ref_save("alaw.aifc", FileType::Aiff);
 }
 
 #[test]
@@ -222,7 +222,7 @@ fn test_default_file_extensions() {
 fn test_file_resolver() {
 	{
 		let file = lofty::read_from_path("tests/taglib/data/xing.mp3").unwrap();
-		assert_eq!(file.file_type(), FileType::MPEG);
+		assert_eq!(file.file_type(), FileType::Mpeg);
 	}
 
 	struct DummyResolver;
diff --git a/tests/taglib/test_id3v1.rs b/tests/taglib/test_id3v1.rs
@@ -3,15 +3,15 @@ use crate::temp_file;
 use std::io::Seek;
 
 use lofty::id3::v1::{ID3v1Tag, GENRES};
-use lofty::mpeg::MPEGFile;
+use lofty::mpeg::MpegFile;
 use lofty::{Accessor, AudioFile, ParseOptions};
 
 #[test]
 #[ignore] // TODO: We probably should be stripping whitespace
 fn test_strip_whitespace() {
 	let mut file = temp_file!("tests/taglib/data/xing.mp3");
 	{
-		let mut f = MPEGFile::read_from(&mut file, ParseOptions::new()).unwrap();
+		let mut f = MpegFile::read_from(&mut file, ParseOptions::new()).unwrap();
 		file.rewind().unwrap();
 
 		let mut tag = ID3v1Tag::default();
@@ -21,7 +21,7 @@ fn test_strip_whitespace() {
 	}
 	file.rewind().unwrap();
 	{
-		let f = MPEGFile::read_from(&mut file, ParseOptions::new()).unwrap();
+		let f = MpegFile::read_from(&mut file, ParseOptions::new()).unwrap();
 		assert_eq!(f.id3v1().unwrap().artist().as_deref(), Some("Artist"));
 	}
 }
diff --git a/tests/taglib/test_mp4.rs b/tests/taglib/test_mp4.rs
@@ -420,7 +420,7 @@ fn test_remove_metadata() {
 
 		assert!(f.ilst().is_some());
 		assert!(!f.ilst().unwrap().is_empty());
-		TagType::MP4ilst.remove_from(&mut file).unwrap();
+		TagType::Mp4Ilst.remove_from(&mut file).unwrap();
 	}
 	file.rewind().unwrap();
 	{
diff --git a/tests/taglib/test_mpeg.rs b/tests/taglib/test_mpeg.rs
diff --git a/tests/taglib/test_wav.rs b/tests/taglib/test_wav.rs

Original file line number	Diff line number	Diff line change
`@@ -80,13 +80,13 @@ fn test_properties_390() {`
`80`	`80`	`fn test_fuzzed_file_1() {`
`81`	`81`	`assert_eq!(`
`82`	`82`	`get_filetype("tests/taglib/data/longloop.ape"),`
`83`		`- FileType::APE`
	`83`	`+ FileType::Ape`
`84`	`84`	`);`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`#[test]`
`88`	`88`	`fn test_fuzzed_file_2() {`
`89`		`- assert_eq!(get_filetype("tests/taglib/data/zerodiv.ape"), FileType::APE);`
	`89`	`+ assert_eq!(get_filetype("tests/taglib/data/zerodiv.ape"), FileType::Ape);`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -103,12 +103,12 @@ fn test_speex() {`
`103`	`103`
`104`	`104`	`#[test]`
`105`	`105`	`fn test_flac() {`
`106`		`- file_ref_save("no-tags.flac", FileType::FLAC);`
	`106`	`+ file_ref_save("no-tags.flac", FileType::Flac);`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`#[test]`
`110`	`110`	`fn test_mp3() {`
`111`		`- file_ref_save("xing.mp3", FileType::MPEG);`
	`111`	`+ file_ref_save("xing.mp3", FileType::Mpeg);`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`#[test]`
`@@ -120,35 +120,35 @@ fn test_true_audio() {`
`120`	`120`
`121`	`121`	`#[test]`
`122`	`122`	`fn test_mp4_1() {`
`123`		`- file_ref_save("has-tags.m4a", FileType::MP4);`
	`123`	`+ file_ref_save("has-tags.m4a", FileType::Mp4);`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`#[test]`
`127`	`127`	#[ignore] // TODO: The file has a malformed `free` atom. How does TagLib handle this? Currently we mess up entirely and just write a duplicate tag.
`128`	`128`	`fn test_mp4_2() {`
`129`		`- file_ref_save("no-tags.m4a", FileType::MP4);`
	`129`	`+ file_ref_save("no-tags.m4a", FileType::Mp4);`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`#[test]`
`133`	`133`	#[ignore] // TODO: We are able to write the first tag and even reread, but the second save causes a `SizeMismatch`.
`134`	`134`	`fn test_mp4_3() {`
`135`		`- file_ref_save("no-tags.3g2", FileType::MP4);`
	`135`	`+ file_ref_save("no-tags.3g2", FileType::Mp4);`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`#[test]`
`139`	`139`	`fn test_mp4_4() {`
`140`		`- file_ref_save("blank_video.m4v", FileType::MP4);`
	`140`	`+ file_ref_save("blank_video.m4v", FileType::Mp4);`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`#[test]`
`144`	`144`	`fn test_wav() {`
`145`		`- file_ref_save("empty.wav", FileType::WAV);`
	`145`	`+ file_ref_save("empty.wav", FileType::Wav);`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`#[test]`
`149`	`149`	`#[ignore] // TODO: We don't yet support FLAC in oga`
`150`	`150`	`fn test_oga_flac() {`
`151`		`- file_ref_save("empty_flac.oga", FileType::FLAC);`
	`151`	`+ file_ref_save("empty_flac.oga", FileType::Flac);`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`#[test]`
`@@ -158,17 +158,17 @@ fn test_oga_vorbis() {`
`158`	`158`
`159`	`159`	`#[test]`
`160`	`160`	`fn test_ape() {`
`161`		`- file_ref_save("mac-399.ape", FileType::APE);`
	`161`	`+ file_ref_save("mac-399.ape", FileType::Ape);`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`#[test]`
`165`	`165`	`fn test_aiff_1() {`
`166`		`- file_ref_save("empty.aiff", FileType::AIFF);`
	`166`	`+ file_ref_save("empty.aiff", FileType::Aiff);`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`#[test]`
`170`	`170`	`fn test_aiff_2() {`
`171`		`- file_ref_save("alaw.aifc", FileType::AIFF);`
	`171`	`+ file_ref_save("alaw.aifc", FileType::Aiff);`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`#[test]`
`@@ -222,7 +222,7 @@ fn test_default_file_extensions() {`
`222`	`222`	`fn test_file_resolver() {`
`223`	`223`	`{`
`224`	`224`	`let file = lofty::read_from_path("tests/taglib/data/xing.mp3").unwrap();`
`225`		`- assert_eq!(file.file_type(), FileType::MPEG);`
	`225`	`+ assert_eq!(file.file_type(), FileType::Mpeg);`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`struct DummyResolver;`
Original file line number	Diff line number	Diff line change
`@@ -3,15 +3,15 @@ use crate::temp_file;`
`3`	`3`	`use std::io::Seek;`
`4`	`4`
`5`	`5`	`use lofty::id3::v1::{ID3v1Tag, GENRES};`
`6`		`-use lofty::mpeg::MPEGFile;`
	`6`	`+use lofty::mpeg::MpegFile;`
`7`	`7`	`use lofty::{Accessor, AudioFile, ParseOptions};`
`8`	`8`
`9`	`9`	`#[test]`
`10`	`10`	`#[ignore] // TODO: We probably should be stripping whitespace`
`11`	`11`	`fn test_strip_whitespace() {`
`12`	`12`	`let mut file = temp_file!("tests/taglib/data/xing.mp3");`
`13`	`13`	`{`
`14`		`- let mut f = MPEGFile::read_from(&mut file, ParseOptions::new()).unwrap();`
	`14`	`+ let mut f = MpegFile::read_from(&mut file, ParseOptions::new()).unwrap();`
`15`	`15`	`file.rewind().unwrap();`
`16`	`16`
`17`	`17`	`let mut tag = ID3v1Tag::default();`
`@@ -21,7 +21,7 @@ fn test_strip_whitespace() {`
`21`	`21`	`}`
`22`	`22`	`file.rewind().unwrap();`
`23`	`23`	`{`
`24`		`- let f = MPEGFile::read_from(&mut file, ParseOptions::new()).unwrap();`
	`24`	`+ let f = MpegFile::read_from(&mut file, ParseOptions::new()).unwrap();`
`25`	`25`	`assert_eq!(f.id3v1().unwrap().artist().as_deref(), Some("Artist"));`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -420,7 +420,7 @@ fn test_remove_metadata() {`
`420`	`420`
`421`	`421`	`assert!(f.ilst().is_some());`
`422`	`422`	`assert!(!f.ilst().unwrap().is_empty());`
`423`		`- TagType::MP4ilst.remove_from(&mut file).unwrap();`
	`423`	`+ TagType::Mp4Ilst.remove_from(&mut file).unwrap();`
`424`	`424`	`}`
`425`	`425`	`file.rewind().unwrap();`
`426`	`426`	`{`