diff --git a/src/ape/tag/ape_tag.rs b/src/ape/tag/ape_tag.rs index 23bc0a2a..81fd9ac2 100644 --- a/src/ape/tag/ape_tag.rs +++ b/src/ape/tag/ape_tag.rs @@ -266,7 +266,7 @@ mod tests { use crate::{ItemValue, Tag, TagType}; use crate::ape::tag::read_ape_header; - use std::io::{Cursor, Read}; + use std::io::Cursor; #[test] fn parse_ape() { @@ -316,12 +316,7 @@ mod tests { expected_tag.insert(track_number_item); expected_tag.insert(genre_item); - let mut tag = Vec::new(); - std::fs::File::open("tests/tags/assets/test.apev2") - .unwrap() - .read_to_end(&mut tag) - .unwrap(); - + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.apev2"); let mut reader = Cursor::new(tag); let header = read_ape_header(&mut reader, false).unwrap(); @@ -335,13 +330,29 @@ mod tests { } #[test] - fn ape_to_tag() { - let mut tag_bytes = Vec::new(); - std::fs::File::open("tests/tags/assets/test.apev2") - .unwrap() - .read_to_end(&mut tag_bytes) - .unwrap(); + fn ape_re_read() { + let tag_bytes = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.apev2"); + let mut reader = Cursor::new(tag_bytes); + let header = read_ape_header(&mut reader, false).unwrap(); + let parsed_tag = crate::ape::tag::read::read_ape_tag(&mut reader, header).unwrap(); + + let mut writer = Vec::new(); + parsed_tag.dump_to(&mut writer).unwrap(); + + // Remove the APE preamble + let mut temp_reader = Cursor::new(&writer[8..]); + + let temp_header = read_ape_header(&mut temp_reader, false).unwrap(); + let temp_parsed_tag = + crate::ape::tag::read::read_ape_tag(&mut temp_reader, temp_header).unwrap(); + + assert_eq!(parsed_tag, temp_parsed_tag); + } + + #[test] + fn ape_to_tag() { + let tag_bytes = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.apev2"); let mut reader = Cursor::new(tag_bytes); let header = read_ape_header(&mut reader, false).unwrap(); diff --git a/src/id3/v1/tag.rs b/src/id3/v1/tag.rs index 3023bf72..82af37e6 100644 --- a/src/id3/v1/tag.rs +++ b/src/id3/v1/tag.rs @@ -282,8 +282,6 @@ mod tests { use crate::id3::v1::Id3v1Tag; use crate::{Tag, TagType}; - use std::io::Read; - #[test] fn parse_id3v1() { let expected_tag = Id3v1Tag { @@ -296,26 +294,29 @@ mod tests { genre: Some(32), }; - let mut tag = [0; 128]; - std::fs::File::open("tests/tags/assets/test.id3v1") - .unwrap() - .read_exact(&mut tag) - .unwrap(); - - let parsed_tag = crate::id3::v1::read::parse_id3v1(tag); + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.id3v1"); + let parsed_tag = crate::id3::v1::read::parse_id3v1(tag.try_into().unwrap()); assert_eq!(expected_tag, parsed_tag); } #[test] - fn id3v1_to_tag() { - let mut tag_bytes = [0; 128]; - std::fs::File::open("tests/tags/assets/test.id3v1") - .unwrap() - .read_exact(&mut tag_bytes) - .unwrap(); + fn id3v2_re_read() { + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.id3v1"); + let parsed_tag = crate::id3::v1::read::parse_id3v1(tag.try_into().unwrap()); - let id3v1 = crate::id3::v1::read::parse_id3v1(tag_bytes); + let mut writer = Vec::new(); + parsed_tag.dump_to(&mut writer).unwrap(); + + let temp_parsed_tag = crate::id3::v1::read::parse_id3v1(writer.try_into().unwrap()); + + assert_eq!(parsed_tag, temp_parsed_tag); + } + + #[test] + fn id3v1_to_tag() { + let tag_bytes = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.id3v1"); + let id3v1 = crate::id3::v1::read::parse_id3v1(tag_bytes.try_into().unwrap()); let tag: Tag = id3v1.into(); diff --git a/src/id3/v2/tag.rs b/src/id3/v2/tag.rs index a423df78..3aaeea25 100644 --- a/src/id3/v2/tag.rs +++ b/src/id3/v2/tag.rs @@ -445,12 +445,10 @@ impl<'a> Into> for &'a Id3v2Tag { #[cfg(test)] mod tests { + use crate::id3::v2::read_id3v2_header; use crate::id3::v2::{Frame, FrameFlags, FrameValue, Id3v2Tag, LanguageFrame, TextEncoding}; use crate::{Tag, TagType}; - use crate::id3::v2::read_id3v2_header; - use std::io::Read; - #[test] fn parse_id3v2() { let mut expected_tag = Id3v2Tag::default(); @@ -544,12 +542,7 @@ mod tests { .unwrap(), ); - let mut tag = Vec::new(); - std::fs::File::open("tests/tags/assets/test.id3v2") - .unwrap() - .read_to_end(&mut tag) - .unwrap(); - + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.id3v2"); let mut reader = std::io::Cursor::new(&tag[..]); let header = read_id3v2_header(&mut reader).unwrap(); @@ -558,13 +551,28 @@ mod tests { assert_eq!(expected_tag, parsed_tag); } + #[test] + fn id3v2_re_read() { + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.id3v2"); + let mut reader = std::io::Cursor::new(&tag[..]); + + let header = read_id3v2_header(&mut reader).unwrap(); + let parsed_tag = crate::id3::v2::read::parse_id3v2(&mut reader, header).unwrap(); + + let mut writer = Vec::new(); + parsed_tag.dump_to(&mut writer).unwrap(); + + let temp_reader = &mut &*writer; + + let temp_header = read_id3v2_header(temp_reader).unwrap(); + let temp_parsed_tag = crate::id3::v2::read::parse_id3v2(temp_reader, temp_header).unwrap(); + + assert_eq!(parsed_tag, temp_parsed_tag); + } + #[test] fn id3v2_to_tag() { - let mut tag_bytes = Vec::new(); - std::fs::File::open("tests/tags/assets/test.id3v2") - .unwrap() - .read_to_end(&mut tag_bytes) - .unwrap(); + let tag_bytes = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.id3v2"); let mut reader = std::io::Cursor::new(&tag_bytes[..]); diff --git a/src/iff/aiff/tag.rs b/src/iff/aiff/tag.rs index 61bbbeb2..ee7a77aa 100644 --- a/src/iff/aiff/tag.rs +++ b/src/iff/aiff/tag.rs @@ -235,7 +235,7 @@ where T: AsRef, AI: IntoIterator, { - pub(super) fn new( + pub(crate) fn new( name: Option<&'a str>, author: Option<&'a str>, copyright: Option<&'a str>, @@ -411,7 +411,7 @@ mod tests { use crate::iff::{AiffTextChunks, Comment}; use crate::{ItemKey, ItemValue, Tag, TagItem, TagType}; - use std::io::{Cursor, Read}; + use std::io::Cursor; #[test] fn parse_aiff_text() { @@ -437,11 +437,7 @@ mod tests { ]), }; - let mut tag = Vec::new(); - std::fs::File::open("tests/tags/assets/test.aiff_text") - .unwrap() - .read_to_end(&mut tag) - .unwrap(); + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.aiff_text"); let parsed_tag = super::super::read::read_from(&mut Cursor::new(tag), false) .unwrap() @@ -452,13 +448,29 @@ mod tests { } #[test] - fn aiff_text_to_tag() { - let mut tag_bytes = Vec::new(); - std::fs::File::open("tests/tags/assets/test.aiff_text") + fn aiff_text_re_read() { + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.aiff_text"); + let parsed_tag = super::super::read::read_from(&mut Cursor::new(tag), false) .unwrap() - .read_to_end(&mut tag_bytes) + .text_chunks .unwrap(); + // Create a fake AIFF signature + let mut writer = vec![b'F', b'O', b'R', b'M', 0, 0, 0, 0, b'A', b'I', b'F', b'F']; + parsed_tag.dump_to(&mut writer).unwrap(); + + let temp_parsed_tag = super::super::read::read_from(&mut Cursor::new(writer), false) + .unwrap() + .text_chunks + .unwrap(); + + assert_eq!(parsed_tag, temp_parsed_tag); + } + + #[test] + fn aiff_text_to_tag() { + let tag_bytes = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.aiff_text"); + let aiff_text = super::super::read::read_from(&mut Cursor::new(tag_bytes), false) .unwrap() .text_chunks diff --git a/src/iff/wav/tag/mod.rs b/src/iff/wav/tag/mod.rs index 4419c5ec..c6a68d23 100644 --- a/src/iff/wav/tag/mod.rs +++ b/src/iff/wav/tag/mod.rs @@ -235,7 +235,7 @@ mod tests { use crate::iff::RiffInfoList; use crate::{Tag, TagType}; - use std::io::Read; + use std::io::Cursor; #[test] fn parse_riff_info() { @@ -248,27 +248,50 @@ mod tests { expected_tag.insert(String::from("IPRD"), String::from("Baz album")); expected_tag.insert(String::from("IPRT"), String::from("1")); - let mut tag = Vec::new(); - std::fs::File::open("tests/tags/assets/test.riff") - .unwrap() - .read_to_end(&mut tag) - .unwrap(); - - let mut reader = std::io::Cursor::new(&tag[..]); + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.riff"); let mut parsed_tag = RiffInfoList::default(); - super::read::parse_riff_info(&mut reader, (tag.len() - 1) as u64, &mut parsed_tag).unwrap(); + super::read::parse_riff_info( + &mut Cursor::new(&tag[..]), + (tag.len() - 1) as u64, + &mut parsed_tag, + ) + .unwrap(); assert_eq!(expected_tag, parsed_tag); } + #[test] + fn riff_info_re_read() { + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.riff"); + let mut parsed_tag = RiffInfoList::default(); + + super::read::parse_riff_info( + &mut Cursor::new(&tag[..]), + (tag.len() - 1) as u64, + &mut parsed_tag, + ) + .unwrap(); + + let mut writer = Vec::new(); + parsed_tag.dump_to(&mut writer).unwrap(); + + let mut temp_parsed_tag = RiffInfoList::default(); + + // Remove the LIST....INFO from the tag + super::read::parse_riff_info( + &mut Cursor::new(&writer[12..]), + (tag.len() - 13) as u64, + &mut temp_parsed_tag, + ) + .unwrap(); + + assert_eq!(parsed_tag, temp_parsed_tag); + } + #[test] fn riff_info_to_tag() { - let mut tag_bytes = Vec::new(); - std::fs::File::open("tests/tags/assets/test.riff") - .unwrap() - .read_to_end(&mut tag_bytes) - .unwrap(); + let tag_bytes = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.riff"); let mut reader = std::io::Cursor::new(&tag_bytes[..]); let mut riff_info = RiffInfoList::default(); diff --git a/src/mp4/ilst/mod.rs b/src/mp4/ilst/mod.rs index ecfa306e..b6736d10 100644 --- a/src/mp4/ilst/mod.rs +++ b/src/mp4/ilst/mod.rs @@ -418,8 +418,6 @@ mod tests { use crate::mp4::{Atom, AtomData, AtomIdent, Ilst}; use crate::{ItemKey, Tag, TagType}; - use std::io::Read; - #[test] fn parse_ilst() { let mut expected_tag = Ilst::default(); @@ -474,24 +472,31 @@ mod tests { AtomData::UTF8(String::from("Foo title")), )); - let mut tag = Vec::new(); - std::fs::File::open("tests/tags/assets/test.ilst") - .unwrap() - .read_to_end(&mut tag) - .unwrap(); + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.ilst"); let parsed_tag = super::read::parse_ilst(&mut &tag[..], tag.len() as u64).unwrap(); assert_eq!(expected_tag, parsed_tag); } + #[test] + fn ilst_re_read() { + let tag = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.ilst"); + let parsed_tag = super::read::parse_ilst(&mut &tag[..], tag.len() as u64).unwrap(); + + let mut writer = Vec::new(); + parsed_tag.dump_to(&mut writer).unwrap(); + + // Remove the ilst identifier and size + let temp_parsed_tag = + super::read::parse_ilst(&mut &writer[8..], (writer.len() - 8) as u64).unwrap(); + + assert_eq!(parsed_tag, temp_parsed_tag); + } + #[test] fn ilst_to_tag() { - let mut tag_bytes = Vec::new(); - std::fs::File::open("tests/tags/assets/test.ilst") - .unwrap() - .read_to_end(&mut tag_bytes) - .unwrap(); + let tag_bytes = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.ilst"); let ilst = super::read::parse_ilst(&mut &tag_bytes[..], tag_bytes.len() as u64).unwrap(); diff --git a/src/ogg/tag.rs b/src/ogg/tag.rs index 2adb1508..543d8bf2 100644 --- a/src/ogg/tag.rs +++ b/src/ogg/tag.rs @@ -307,6 +307,14 @@ mod tests { use std::io::Read; + fn read_tag(tag: &[u8]) -> VorbisComments { + let mut reader = std::io::Cursor::new(tag); + let mut parsed_tag = VorbisComments::default(); + + crate::ogg::read::read_comments(&mut reader, &mut parsed_tag).unwrap(); + parsed_tag + } + #[test] fn parse_vorbis_comments() { let mut expected_tag = VorbisComments::default(); @@ -321,20 +329,28 @@ mod tests { expected_tag.insert_item(String::from("TITLE"), String::from("Foo title"), false); expected_tag.insert_item(String::from("TRACKNUMBER"), String::from("1"), false); - let mut tag = Vec::new(); - std::fs::File::open("tests/tags/assets/test.vorbis") - .unwrap() - .read_to_end(&mut tag) - .unwrap(); - - let mut reader = std::io::Cursor::new(&tag[..]); - let mut parsed_tag = VorbisComments::default(); - - crate::ogg::read::read_comments(&mut reader, &mut parsed_tag).unwrap(); + let file_cont = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.vorbis"); + let parsed_tag = read_tag(&*file_cont); assert_eq!(expected_tag, parsed_tag); } + #[test] + fn vorbis_comments_re_read() { + let file_cont = crate::tag_utils::test_utils::read_path("tests/tags/assets/test.vorbis"); + let mut parsed_tag = read_tag(&*file_cont); + + // Create a zero-size vendor for comparison + parsed_tag.vendor = String::new(); + + let mut writer = vec![0, 0, 0, 0]; + parsed_tag.dump_to(&mut writer).unwrap(); + + let temp_parsed_tag = read_tag(&*writer); + + assert_eq!(parsed_tag, temp_parsed_tag); + } + #[test] fn vorbis_comments_to_tag() { let mut tag_bytes = Vec::new(); diff --git a/src/tag_utils.rs b/src/tag_utils.rs index 0a0f69dd..f91e6e5c 100644 --- a/src/tag_utils.rs +++ b/src/tag_utils.rs @@ -110,6 +110,8 @@ pub(crate) use tag_methods; // Used for tag conversion tests pub(crate) mod test_utils { use crate::{ItemKey, Tag, TagType}; + use std::fs::File; + use std::io::Read; pub(crate) fn create_tag(tag_type: TagType) -> Tag { let mut tag = Tag::new(tag_type); @@ -138,4 +140,16 @@ pub(crate) mod test_utils { assert_eq!(tag.get_string(&ItemKey::Genre), Some("Classical")); } } + + pub(crate) fn read_path(path: &str) -> Vec { + read_file(&mut File::open(path).unwrap()) + } + + pub(crate) fn read_file(file: &mut File) -> Vec { + let mut tag = Vec::new(); + + file.read_to_end(&mut tag).unwrap(); + + tag + } }