audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/integration/multiple_values/reading/metadata_format/test_id3v2_4.py

@@ -0,0 +1,216 @@
+import pytest
+
+from audiometa import get_unified_metadata_field
+from audiometa.test.helpers.id3v2 import ID3v2HeaderVerifier, ID3v2MetadataGetter, ID3v2MetadataSetter
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestId3v24Mixed:
+    def test_null_separated_artists(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_artists(test_file, ["Artist One", "Artist Two", "Artist Three"], version="2.4")
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file, version="2.4")
+            # raw_output replaces NUL bytes with slashes for display purposes
+            assert raw_metadata["TPE1"] == ["Artist One\x00Artist Two\x00Artist Three"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_null_separated_artists_iso_8859_1(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Use a single NUL in the Python string; encoding=0 will encode it as a single 0x00
+            ID3v2MetadataSetter.write_tpe1_with_encoding(
+                test_file, "Artist One\x00Artist Two\x00Artist Three", encoding=0
+            )
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TPE1"] == ["Artist One\x00Artist Two\x00Artist Three"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_null_separated_artists_utf16_with_bom(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # Using a Python string with '\x00' — when encoded as UTF-16 it will become two zero bytes
+            ID3v2MetadataSetter.write_tpe1_with_encoding(
+                test_file, "Artist One\x00Artist Two\x00Artist Three", encoding=1
+            )
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TPE1"] == ["Artist One\x00Artist Two\x00Artist Three"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_null_separated_artists_utf16be(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # ID3v2.4 with encoding=2 (UTF-16BE without BOM) — separator becomes two NUL bytes after encoding.
+            ID3v2MetadataSetter.write_tpe1_with_encoding(
+                test_file, "Artist One\x00Artist Two\x00Artist Three", encoding=2
+            )
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TPE1"] == ["Artist One\x00Artist Two\x00Artist Three"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_null_separated_artists_utf8(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            # ID3v2.4 with encoding=3 (UTF-8) — separator is a single NUL byte.
+            ID3v2MetadataSetter.write_tpe1_with_encoding(
+                test_file, "Artist One\x00Artist Two\x00Artist Three", encoding=3
+            )
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TPE1"] == ["Artist One\x00Artist Two\x00Artist Three"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_semicolon_separated_artists(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_artists(test_file, "Artist One;Artist Two;Artist Three", version="2.4")
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TPE1"] == ["Artist One;Artist Two;Artist Three"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_multiple_artists_in_multiple_entries_semicolon_separator(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_artists(
+                test_file, ["Artist One;Artist Two", "Artist Three"], in_separate_frames=True, version="2.4"
+            )
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TPE1"] == ["Artist One;Artist Two", "Artist Three"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 2
+            assert artists == ["Artist One;Artist Two", "Artist Three"]
+
+    def test_null_separated_artists_in_multiple_entries(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_artists(
+                test_file, ["Artist One\0Artist Two", "Artist Three"], in_separate_frames=True, version="2.4"
+            )
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TPE1"] == ["Artist One\0Artist Two", "Artist Three"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert artists == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_null_separated_artists_in_multiple_entries_and_semicolon_separated(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_artists(
+                test_file, ["Artist 1\0Artist 2", "Artist 3;Artist 4"], in_separate_frames=True, version="2.4"
+            )
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TPE1"] == ["Artist 1\0Artist 2", "Artist 3;Artist 4"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert artists == ["Artist 1", "Artist 2", "Artist 3;Artist 4"]
+
+    def test_mixed_separators_semicolon_and_null(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_artists(test_file, ["Artist 1\0Artist 2;Artist 3"], version="2.4")
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TPE1"] == ["Artist 1\0Artist 2;Artist 3"]
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.ID3V2
+            )
+            assert isinstance(artists, list)
+            assert len(artists) == 2
+            assert artists == ["Artist 1", "Artist 2;Artist 3"]
+
+    def test_multiple_title_entries_then_first_one(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "id3v2.4") as test_file:
+            ID3v2MetadataSetter.set_titles(
+                test_file, ["Title One", "Title Two", "Title Three"], in_separate_frames=True, version="2.4"
+            )
+
+            assert ID3v2HeaderVerifier.get_id3v2_version(test_file) == (2, 4, 0)
+
+            raw_metadata = ID3v2MetadataGetter.get_raw_metadata(test_file)
+            assert raw_metadata["TIT2"] == ["Title One", "Title Two", "Title Three"]
+
+            title = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.TITLE, metadata_format=MetadataFormat.ID3V2
+            )
+
+            assert isinstance(title, str)
+            assert title == "Title One"

audiometa/test/tests/integration/multiple_values/reading/metadata_format/test_riff.py

@@ -0,0 +1,84 @@
+import pytest
+
+from audiometa import get_unified_metadata_field
+from audiometa.test.helpers.riff.riff_metadata_getter import RIFFMetadataGetter
+from audiometa.test.helpers.riff.riff_metadata_setter import RIFFMetadataSetter
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestRiff:
+    def test_semicolon_separated_artists(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            RIFFMetadataSetter.set_artists(test_file, ["Artist One;Artist Two;Artist Three"], in_separate_frames=False)
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            assert "TAG:artist=Artist One;Artist Two;Artist Three" in raw_metadata
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.RIFF
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist One" in artists
+            assert "Artist Two" in artists
+            assert "Artist Three" in artists
+
+    def test_multiple_artists_in_multiple_entries(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            RIFFMetadataSetter.set_artists(test_file, ["One", "Two", "Three"], in_separate_frames=True)
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            # ffprobe only shows the last field when multiple fields with the same tag exist
+            assert "TAG:artist=Three" in raw_metadata
+
+            # Get RIFF metadata specifically to read the artists
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.RIFF
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "One" in artists
+            assert "Two" in artists
+            assert "Three" in artists
+
+    def test_mixed_separators_and_multiple_entries(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            RIFFMetadataSetter.set_artists(
+                test_file, ["Artist 1;Artist 2", "Artist 3", "Artist 4"], in_separate_frames=True
+            )
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            # ffprobe only shows the last field when multiple fields with the same tag exist
+            assert "TAG:artist=Artist 4" in raw_metadata
+
+            # Get RIFF metadata specifically to read the artists
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.RIFF
+            )
+            assert isinstance(artists, list)
+
+            # We created 3 separate RIFF frames, so we should get 3 entries
+            # (separator parsing happens at a higher level, not in RIFF format itself)
+            assert len(artists) == 3
+            assert "Artist 1;Artist 2" in artists
+            assert "Artist 3" in artists
+            assert "Artist 4" in artists
+
+    def test_multiple_title_entries_then_first_one(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "wav") as test_file:
+            RIFFMetadataSetter.set_multiple_titles(
+                test_file, ["Title One", "Title Two", "Title Three"], in_separate_frames=True
+            )
+
+            raw_metadata = RIFFMetadataGetter.get_raw_metadata(test_file)
+            # ffprobe only shows the last field when multiple fields with the same tag exist
+            assert "TAG:title=Title Three" in raw_metadata
+
+            title = get_unified_metadata_field(test_file, UnifiedMetadataKey.TITLE, metadata_format=MetadataFormat.RIFF)
+            assert isinstance(title, str)
+            assert title == "Title One"

audiometa/test/tests/integration/multiple_values/reading/metadata_format/test_vorbis.py

@@ -0,0 +1,169 @@
+import pytest
+
+from audiometa import get_unified_metadata_field
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.helpers.vorbis.vorbis_metadata_getter import VorbisMetadataGetter
+from audiometa.test.helpers.vorbis.vorbis_metadata_setter import VorbisMetadataSetter
+from audiometa.utils.metadata_format import MetadataFormat
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestVorbis:
+    def test_null_value_separated_artists(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(
+                test_file, ["Artist One", "Artist Two", "Artist Three"], in_single_entry=True
+            )
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata_without_truncating_null_bytes_but_lower_case_keys(
+                test_file
+            )
+            # The key is lower case because that is how mutagen stores it but it is upper case in the file
+            assert "artist=Artist One\x00Artist Two\x00Artist Three" in raw_metadata
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist One" in artists
+            assert "Artist Two" in artists
+            assert "Artist Three" in artists
+
+    def test_null_separated_artists_with_additional_entries(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist A", "Artist B"], in_single_entry=True)
+            VorbisMetadataSetter.set_artists(
+                test_file, ["Artist C", "Artist D"], removing_existing=False, in_single_entry=True
+            )
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata_without_truncating_null_bytes_but_lower_case_keys(
+                test_file
+            )
+            # The key is lower case because that is how mutagen stores it but it is upper case in the file
+            assert "artist=Artist A\x00Artist B" in raw_metadata
+            assert "artist=Artist C\x00Artist D" in raw_metadata
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+            assert isinstance(artists, list)
+            assert len(artists) == 4
+            assert "Artist A" in artists
+            assert "Artist B" in artists
+            assert "Artist C" in artists
+            assert "Artist D" in artists
+
+    def test_null_separated_artists_in_multiple_entries_with_semicolon(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist One\x00Artist Two", "Artist Three;Artist Four"])
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata_without_truncating_null_bytes_but_lower_case_keys(
+                test_file
+            )
+            assert "artist=Artist One\x00Artist Two" in raw_metadata
+            assert "artist=Artist Three;Artist Four" in raw_metadata
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist One" in artists
+            assert "Artist Two" in artists
+            assert "Artist Three;Artist Four" in artists
+
+    def test_semicolon_separated_artists(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist One;Artist Two;Artist Three"])
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "ARTIST=Artist One;Artist Two;Artist Three" in raw_metadata
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist One" in artists
+            assert "Artist Two" in artists
+            assert "Artist Three" in artists
+
+    def test_artists_in_multiple_entries(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["One", "Two", "Three"])
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "ARTIST=One" in raw_metadata
+            assert "ARTIST=Two" in raw_metadata
+            assert "ARTIST=Three" in raw_metadata
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "One" in artists
+            assert "Two" in artists
+            assert "Three" in artists
+
+    def test_artists_in_multiple_entries_with_different_key_casings(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist A", "Artist B"])
+            VorbisMetadataSetter.set_artists(
+                test_file, ["Artist C", "Artist D"], removing_existing=False, key_lower_case=True
+            )
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "artist=Artist A" in raw_metadata
+            assert "artist=Artist B" in raw_metadata
+            assert "artist=Artist C" in raw_metadata
+            assert "artist=Artist D" in raw_metadata
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+
+            assert isinstance(artists, list)
+            assert len(artists) == 4
+            assert "Artist A" in artists
+            assert "Artist B" in artists
+            assert "Artist C" in artists
+            assert "Artist D" in artists
+
+    def test_mixed_single_and_multiple_entries(self):
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            VorbisMetadataSetter.set_artists(test_file, ["Artist 1;Artist 2", "Artist 3", "Artist 4"])
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+
+            assert "ARTIST=Artist 1;Artist" in raw_metadata
+            assert "ARTIST=Artist 3" in raw_metadata
+            assert "ARTIST=Artist 4" in raw_metadata
+
+            artists = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.ARTISTS, metadata_format=MetadataFormat.VORBIS
+            )
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist 1;Artist 2" in artists
+            assert "Artist 3" in artists
+            assert "Artist 4" in artists
+
+    def test_multiple_title_entries_returns_first_value(self):
+        with temp_file_with_metadata({}, "flac") as test_file:
+            VorbisMetadataSetter.add_title(test_file, "Title One")
+            VorbisMetadataSetter.add_title(test_file, "Title Two")
+            VorbisMetadataSetter.add_title(test_file, "Title Three")
+
+            raw_metadata = VorbisMetadataGetter.get_raw_metadata(test_file)
+            assert "TITLE=Title One" in raw_metadata
+            assert "TITLE=Title Two" in raw_metadata
+            assert "TITLE=Title Three" in raw_metadata
+
+            title = get_unified_metadata_field(
+                test_file, UnifiedMetadataKey.TITLE, metadata_format=MetadataFormat.VORBIS
+            )
+            assert title == "Title One"

audiometa/test/tests/integration/multiple_values/reading/test_performance_large_data.py

@@ -0,0 +1,209 @@
+import time
+
+import pytest
+
+from audiometa import get_unified_metadata
+from audiometa.test.helpers.temp_file_with_metadata import temp_file_with_metadata
+from audiometa.test.helpers.vorbis import VorbisMetadataSetter
+from audiometa.utils.unified_metadata_key import UnifiedMetadataKey
+
+
+@pytest.mark.integration
+class TestPerformanceLargeData:
+    def test_performance_with_many_entries(self):
+        # Create temporary file with basic metadata
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Set many artists using temp_file_with_metadata
+            artists_list = [f"Artist {i + 1}" for i in range(20)]
+            VorbisMetadataSetter.set_artists(test_file, artists_list)
+
+            for _ in range(5):
+                unified_metadata = get_unified_metadata(test_file)
+                artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+
+                assert isinstance(artists, list)
+                assert len(artists) == 20
+
+    def test_performance_with_large_separated_values(self):
+        # Create temporary file with basic metadata
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Set many artists using temp_file_with_metadata
+            artists_list = [f"Artist {i + 1}" for i in range(50)]
+            VorbisMetadataSetter.set_artists(test_file, artists_list)
+
+            start_time = time.time()
+            unified_metadata = get_unified_metadata(test_file)
+            end_time = time.time()
+
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 50
+
+            # Performance should be reasonable (less than 1 second for 50 artists)
+            assert (end_time - start_time) < 1.0
+
+    def test_performance_with_mixed_separators_large(self):
+        # Create temporary file with basic metadata
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Test performance with complex separator scenarios
+            complex_artists = [
+                "Artist 1",
+                "Artist 2",
+                "Artist 3",
+                "Artist 4",
+                "Artist 5",
+                "Artist 6",
+                "Artist 7",
+                "Artist 8",
+                "Artist 9",
+                "Artist 10",
+                "Artist 11",
+                "Artist 12",
+                "Artist 13",
+                "Artist 14",
+                "Artist 15",
+                "Artist 16",
+                "Artist 17",
+                "Artist 18",
+                "Artist 19",
+                "Artist 20",
+                "Artist 21",
+                "Artist 22",
+                "Artist 23",
+                "Artist 24",
+                "Artist 25",
+                "Artist 26",
+                "Artist 27",
+                "Artist 28",
+                "Artist 29",
+                "Artist 30",
+            ]
+
+            try:
+                VorbisMetadataSetter.set_artists(test_file, complex_artists)
+            except RuntimeError:
+                pytest.skip("metaflac not available or failed to set complex separated artists")
+
+            start_time = time.time()
+            unified_metadata = get_unified_metadata(test_file)
+            end_time = time.time()
+
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+
+            assert isinstance(artists, list)
+            # Should have many artists after complex separation
+            assert len(artists) >= 30
+
+            # Performance should be reasonable
+            assert (end_time - start_time) < 2.0
+
+    def test_memory_usage_with_large_values(self):
+        # Create temporary file with basic metadata
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Test with very long individual values
+            long_artist = "A" * 50000  # 50,000 character artist name
+
+            try:
+                VorbisMetadataSetter.set_artist(test_file, long_artist)
+            except RuntimeError:
+                pytest.skip("metaflac not available or failed to set very long artist")
+
+            unified_metadata = get_unified_metadata(test_file)
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 1
+            assert artists[0] == long_artist
+
+    def test_performance_repeated_reads(self):
+        # Create temporary file with basic metadata
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Set up test data
+            try:
+                artists_list = [f"Artist {i + 1}" for i in range(10)]
+                VorbisMetadataSetter.set_artists(test_file, artists_list)
+            except RuntimeError:
+                pytest.skip("metaflac not available or failed to set test artists")
+
+            # Test repeated reads
+            start_time = time.time()
+            for _ in range(100):
+                unified_metadata = get_unified_metadata(test_file)
+                artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+                assert isinstance(artists, list)
+                assert len(artists) == 10
+            end_time = time.time()
+
+            # 100 reads should complete in reasonable time
+            assert (end_time - start_time) < 5.0
+
+    def test_performance_with_all_multi_value_fields(self):
+        # Create temporary file with basic metadata
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Test performance when multiple multi-value fields are populated
+            try:
+                # Set multiple artists
+                artists_list = [f"Artist {i + 1}" for i in range(10)]
+                VorbisMetadataSetter.set_artists(test_file, artists_list)
+
+                # Set multiple genres
+                genres_list = [f"Genre {i + 1}" for i in range(5)]
+                VorbisMetadataSetter.set_genres(test_file, genres_list)
+
+                # Set multiple composers
+                composers_list = [f"Composer {i + 1}" for i in range(8)]
+                VorbisMetadataSetter.set_composers(test_file, composers_list)
+
+            except RuntimeError:
+                pytest.skip("metaflac not available or failed to set multiple multi-value fields")
+
+            start_time = time.time()
+            unified_metadata = get_unified_metadata(test_file)
+            end_time = time.time()
+
+            # Check all multi-value fields
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+            assert isinstance(artists, list)
+            assert len(artists) == 10
+
+            genres = unified_metadata.get(UnifiedMetadataKey.GENRES_NAMES)
+            assert isinstance(genres, list)
+            assert len(genres) == 5
+
+            composers = unified_metadata.get(UnifiedMetadataKey.COMPOSERS)
+            assert isinstance(composers, list)
+            assert len(composers) == 8
+
+            # Performance should be reasonable
+            assert (end_time - start_time) < 2.0
+
+    def test_performance_with_whitespace_heavy_data(self):
+        # Create temporary file with basic metadata
+        with temp_file_with_metadata({"title": "Test Song"}, "flac") as test_file:
+            # Test performance with data that has lots of whitespace processing
+            whitespace_heavy_artists = ["   Artist One   ", "   Artist Two   ", "   Artist Three   "]
+
+            try:
+                VorbisMetadataSetter.set_artists(test_file, whitespace_heavy_artists)
+            except RuntimeError:
+                pytest.skip("metaflac not available or failed to set whitespace-heavy artists")
+
+            start_time = time.time()
+            unified_metadata = get_unified_metadata(test_file)
+            end_time = time.time()
+
+            artists = unified_metadata.get(UnifiedMetadataKey.ARTISTS)
+
+            assert isinstance(artists, list)
+            assert len(artists) == 3
+            assert "Artist One" in artists
+            assert "Artist Two" in artists
+            assert "Artist Three" in artists
+
+            # Check that whitespace was properly stripped
+            for artist in artists:
+                assert artist == artist.strip()
+
+            # Performance should be reasonable
+            assert (end_time - start_time) < 1.0