audiometa-python 0.6.0__py3-none-any.whl

audiometa/test/tests/unit/metadata_managers/header_info/test_riff.py

@@ -0,0 +1,343 @@
+"""Unit tests for RIFF metadata manager header information methods."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+from audiometa.manager._rating_supporting.riff._RiffManager import _RiffManager as RiffManager
+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
+
+
+@pytest.mark.unit
+class TestRiffHeaderMethods:
+    """Test cases for RIFF metadata manager header information methods."""
+
+    def test_riff_manager_header_info(self, sample_wav_file: Path):
+        """Test RiffManager header info method."""
+        audio_file = _AudioFile(sample_wav_file)
+        manager = RiffManager(audio_file)
+
+        header_info = manager.get_header_info()
+
+        # Should have RIFF specific structure
+        assert "present" in header_info
+        assert "chunk_info" in header_info
+
+        # Should be valid structure
+        assert isinstance(header_info["present"], bool)
+        assert isinstance(header_info["chunk_info"], dict)
+
+        # Chunk info should have expected keys
+        chunk_info = header_info["chunk_info"]
+        if header_info["present"]:
+            assert "riff_chunk_size" in chunk_info
+            assert "info_chunk_size" in chunk_info
+            assert "audio_format" in chunk_info
+            assert "subchunk_size" in chunk_info
+
+    def test_riff_manager_raw_metadata_info(self, sample_wav_file: Path):
+        """Test RiffManager raw metadata info method."""
+        audio_file = _AudioFile(sample_wav_file)
+        manager = RiffManager(audio_file)
+
+        raw_info = manager.get_raw_metadata_info()
+
+        # Should have RIFF specific structure
+        assert "raw_data" in raw_info
+        assert "parsed_fields" in raw_info
+        assert "frames" in raw_info
+        assert "comments" in raw_info
+        assert "chunk_structure" in raw_info
+
+        # Should be valid structure
+        assert raw_info["raw_data"] is None or isinstance(raw_info["raw_data"], bytes)
+        assert isinstance(raw_info["parsed_fields"], dict)
+        assert isinstance(raw_info["frames"], dict)
+        assert isinstance(raw_info["comments"], dict)
+        assert isinstance(raw_info["chunk_structure"], dict)
+
+    def test_riff_manager_bext_chunk_extraction_with_description(self):
+        """Test RIFF manager bext chunk extraction with Description field."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_description(test_file, "Test Description")
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+            assert external_bext.get("Description") == "Test Description"
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+            assert bext_data["Description"] == "Test Description"
+            # Verify our extraction matches external tool
+            assert bext_data["Description"] == external_bext.get("Description")
+
+    def test_riff_manager_bext_chunk_extraction_with_originator(self):
+        """Test RIFF manager bext chunk extraction with Originator field."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_originator(test_file, "Test Originator")
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+            assert external_bext.get("Originator") == "Test Originator"
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+            assert bext_data["Originator"] == "Test Originator"
+            # Verify our extraction matches external tool
+            assert bext_data["Originator"] == external_bext.get("Originator")
+
+    def test_riff_manager_bext_chunk_extraction_with_originator_reference(self):
+        """Test RIFF manager bext chunk extraction with OriginatorReference field."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_originator_reference(test_file, "REF-12345")
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+            assert external_bext.get("OriginatorReference") == "REF-12345"
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+            assert bext_data["OriginatorReference"] == "REF-12345"
+            assert bext_data["OriginatorReference"] == external_bext.get("OriginatorReference")
+
+    def test_riff_manager_bext_chunk_extraction_with_origination_date(self):
+        """Test RIFF manager bext chunk extraction with OriginationDate field."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_origination_date(test_file, "2024-01-15")
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+            assert external_bext.get("OriginationDate") == "2024-01-15"
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+            assert bext_data["OriginationDate"] == "2024-01-15"
+            assert bext_data["OriginationDate"] == external_bext.get("OriginationDate")
+
+    def test_riff_manager_bext_chunk_extraction_with_origination_time(self):
+        """Test RIFF manager bext chunk extraction with OriginationTime field."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_origination_time(test_file, "14:30:00")
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+            assert external_bext.get("OriginationTime") == "14:30:00"
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+            assert bext_data["OriginationTime"] == "14:30:00"
+            assert bext_data["OriginationTime"] == external_bext.get("OriginationTime")
+
+    def test_riff_manager_bext_chunk_extraction_with_time_reference(self):
+        """Test RIFF manager bext chunk extraction with TimeReference field."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_time_reference(test_file, 44100)
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+            assert external_bext.get("TimeReference") == 44100
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+            assert bext_data["TimeReference"] == 44100
+            assert bext_data["TimeReference"] == external_bext.get("TimeReference")
+
+    def test_riff_manager_bext_chunk_extraction_with_coding_history(self):
+        """Test RIFF manager bext chunk extraction with CodingHistory field."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_coding_history(test_file, "A=PCM,F=44100,W=16,M=mono,T=PCM")
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+            assert external_bext.get("CodingHistory") == "A=PCM,F=44100,W=16,M=mono,T=PCM"
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+            assert bext_data["CodingHistory"] == "A=PCM,F=44100,W=16,M=mono,T=PCM"
+            assert bext_data["CodingHistory"] == external_bext.get("CodingHistory")
+
+    def test_riff_manager_bext_chunk_extraction_with_multiple_fields(self):
+        """Test RIFF manager bext chunk extraction with multiple fields."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            RIFFMetadataSetter.set_bext_metadata(
+                test_file,
+                {
+                    "Description": "Test Description",
+                    "Originator": "Test Originator",
+                    "OriginatorReference": "REF-12345",
+                    "OriginationDate": "2024-01-15",
+                    "OriginationTime": "14:30:00",
+                    "TimeReference": 44100,
+                    "CodingHistory": "A=PCM,F=44100,W=16,M=mono,T=PCM",
+                },
+            )
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+
+            # Verify each field matches external tool
+            assert bext_data["Description"] == "Test Description"
+            assert bext_data["Description"] == external_bext.get("Description")
+            assert bext_data["Originator"] == "Test Originator"
+            assert bext_data["Originator"] == external_bext.get("Originator")
+            assert bext_data["OriginatorReference"] == "REF-12345"
+            assert bext_data["OriginatorReference"] == external_bext.get("OriginatorReference")
+            assert bext_data["OriginationDate"] == "2024-01-15"
+            assert bext_data["OriginationDate"] == external_bext.get("OriginationDate")
+            assert bext_data["OriginationTime"] == "14:30:00"
+            assert bext_data["OriginationTime"] == external_bext.get("OriginationTime")
+            assert bext_data["TimeReference"] == 44100
+            assert bext_data["TimeReference"] == external_bext.get("TimeReference")
+            assert bext_data["CodingHistory"] == "A=PCM,F=44100,W=16,M=mono,T=PCM"
+            assert bext_data["CodingHistory"] == external_bext.get("CodingHistory")
+
+    def test_riff_manager_bext_chunk_extraction_without_bext_chunk(self, sample_wav_file: Path):
+        """Test that regular WAV files without bext chunk return empty chunk_structure."""
+        audio_file = _AudioFile(sample_wav_file)
+        manager = RiffManager(audio_file)
+        raw_info = manager.get_raw_metadata_info()
+
+        assert "chunk_structure" in raw_info
+        # Regular WAV files without bext chunk should not have bext in chunk_structure
+        assert "bext" not in raw_info["chunk_structure"]
+
+    def test_riff_manager_bext_chunk_extraction_without_info_metadata(self):
+        """Test that bext chunk is extracted even when no user-defined RIFF INFO metadata is present.
+
+        This tests the code path at lines 899-901 in _RiffManager.py that ensures bext chunk
+        extraction happens even when raw_clean_metadata is empty (no INFO metadata).
+        """
+        with temp_file_with_metadata({}, "wav") as test_file:
+            # Add bext metadata but no user-defined INFO metadata
+            RIFFMetadataSetter.set_bext_description(test_file, "Test Description")
+            RIFFMetadataSetter.set_bext_originator(test_file, "Test Originator")
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+            assert external_bext.get("Description") == "Test Description"
+            assert external_bext.get("Originator") == "Test Originator"
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            # Should still have bext chunk in chunk_structure regardless of INFO metadata
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+            assert bext_data["Description"] == "Test Description"
+            assert bext_data["Originator"] == "Test Originator"
+            # Verify our extraction matches external tool
+            assert bext_data["Description"] == external_bext.get("Description")
+            assert bext_data["Originator"] == external_bext.get("Originator")
+
+    def test_riff_manager_bext_chunk_extraction_with_loudness_metadata(self):
+        """Test RIFF manager bext chunk extraction with BWF v2 loudness metadata fields."""
+        with temp_file_with_metadata({}, "wav") as test_file:
+            # Set bext metadata including loudness fields (requires BWF v2)
+            RIFFMetadataSetter.set_bext_metadata(
+                test_file,
+                {
+                    "Description": "Test Description",
+                    "LoudnessValue": -23.0,
+                    "LoudnessRange": 7.0,
+                    "MaxTruePeakLevel": -1.5,
+                    "MaxMomentaryLoudness": -22.0,
+                    "MaxShortTermLoudness": -22.5,
+                },
+            )
+
+            # Verify using external tool
+            external_bext = RIFFMetadataGetter.get_bext_metadata(test_file)
+            assert external_bext.get("Description") == "Test Description"
+            assert external_bext.get("LoudnessValue") == pytest.approx(-23.0, abs=0.1)
+            assert external_bext.get("LoudnessRange") == pytest.approx(7.0, abs=0.1)
+            assert external_bext.get("MaxTruePeakLevel") == pytest.approx(-1.5, abs=0.1)
+            assert external_bext.get("MaxMomentaryLoudness") == pytest.approx(-22.0, abs=0.1)
+            assert external_bext.get("MaxShortTermLoudness") == pytest.approx(-22.5, abs=0.1)
+
+            # Verify using our extraction
+            audio_file = _AudioFile(test_file)
+            manager = RiffManager(audio_file)
+            raw_info = manager.get_raw_metadata_info()
+
+            assert "chunk_structure" in raw_info
+            assert "bext" in raw_info["chunk_structure"]
+            bext_data = raw_info["chunk_structure"]["bext"]
+
+            # Verify version is 2 (BWF v2)
+            assert bext_data.get("Version") == 2
+
+            # Verify loudness fields match external tool
+            assert bext_data["Description"] == "Test Description"
+            assert bext_data.get("LoudnessValue") == pytest.approx(-23.0, abs=0.1)
+            assert bext_data.get("LoudnessRange") == pytest.approx(7.0, abs=0.1)
+            assert bext_data.get("MaxTruePeakLevel") == pytest.approx(-1.5, abs=0.1)
+            assert bext_data.get("MaxMomentaryLoudness") == pytest.approx(-22.0, abs=0.1)
+            assert bext_data.get("MaxShortTermLoudness") == pytest.approx(-22.5, abs=0.1)
+
+            # Verify our extraction matches external tool
+            assert bext_data.get("LoudnessValue") == pytest.approx(external_bext.get("LoudnessValue", 0), abs=0.1)
+            assert bext_data.get("LoudnessRange") == pytest.approx(external_bext.get("LoudnessRange", 0), abs=0.1)
+            assert bext_data.get("MaxTruePeakLevel") == pytest.approx(external_bext.get("MaxTruePeakLevel", 0), abs=0.1)
+            assert bext_data.get("MaxMomentaryLoudness") == pytest.approx(
+                external_bext.get("MaxMomentaryLoudness", 0), abs=0.1
+            )
+            assert bext_data.get("MaxShortTermLoudness") == pytest.approx(
+                external_bext.get("MaxShortTermLoudness", 0), abs=0.1
+            )

audiometa/test/tests/unit/metadata_managers/header_info/test_vorbis.py

@@ -0,0 +1,53 @@
+"""Unit tests for Vorbis metadata manager header information methods."""
+
+from pathlib import Path
+
+import pytest
+
+from audiometa._audio_file import _AudioFile
+from audiometa.manager._rating_supporting.vorbis._VorbisManager import _VorbisManager as VorbisManager
+
+
+@pytest.mark.unit
+class TestVorbisHeaderMethods:
+    """Test cases for Vorbis metadata manager header information methods."""
+
+    def test_vorbis_manager_header_info(self, sample_flac_file: Path):
+        """Test VorbisManager header info method."""
+        audio_file = _AudioFile(sample_flac_file)
+        manager = VorbisManager(audio_file)
+
+        header_info = manager.get_header_info()
+
+        # Should have Vorbis specific structure
+        assert "present" in header_info
+        assert "vendor_string" in header_info
+        assert "comment_count" in header_info
+        assert "block_size" in header_info
+
+        # Should be valid structure
+        assert isinstance(header_info["present"], bool)
+        assert header_info["vendor_string"] is None or isinstance(header_info["vendor_string"], str)
+        assert isinstance(header_info["comment_count"], int)
+        assert isinstance(header_info["block_size"], int)
+
+    def test_vorbis_manager_raw_metadata_info(self, sample_flac_file: Path):
+        """Test VorbisManager raw metadata info method."""
+        audio_file = _AudioFile(sample_flac_file)
+        manager = VorbisManager(audio_file)
+
+        raw_info = manager.get_raw_metadata_info()
+
+        # Should have Vorbis specific structure
+        assert "raw_data" in raw_info
+        assert "parsed_fields" in raw_info
+        assert "frames" in raw_info
+        assert "comments" in raw_info
+        assert "chunk_structure" in raw_info
+
+        # Should be valid structure
+        assert raw_info["raw_data"] is None or isinstance(raw_info["raw_data"], bytes)
+        assert isinstance(raw_info["parsed_fields"], dict)
+        assert isinstance(raw_info["frames"], dict)
+        assert isinstance(raw_info["comments"], dict)
+        assert isinstance(raw_info["chunk_structure"], dict)

audiometa/test/tests/unit/metadata_managers/metadata_field/multiple_values/reading/test_smart_parsing.py

@@ -0,0 +1,186 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from audiometa.manager._MetadataManager import _MetadataManager as MetadataManager
+
+
+@pytest.mark.unit
+class TestSmartParsing:
+    @pytest.mark.parametrize(
+        ("values", "expected_should_parse"),
+        [
+            ([], False),
+            ([""], False),
+            ([" "], False),
+            (["Artist One;Artist Two"], True),
+            (["Artist One", "Artist Two"], False),
+            (["Artist One//Artist Two"], True),
+        ],
+    )
+    def test_should_apply_smart_parsing(self, values, expected_should_parse):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        result = manager._should_apply_smart_parsing(values)
+        assert result == expected_should_parse
+
+    def test_should_apply_smart_parsing_with_null_separators(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        result = manager._should_apply_smart_parsing(["Artist\x00One"])
+        assert result is True
+
+        result = manager._should_apply_smart_parsing(["Artist One", "Artist\x00Two"])
+        assert result is True
+
+    @pytest.mark.parametrize(
+        ("values", "expected_parsed"),
+        [
+            (["Artist One;Artist Two"], ["Artist One", "Artist Two"]),
+            (["Artist One//Artist Two"], ["Artist One", "Artist Two"]),
+            (["Artist One,Artist Two"], ["Artist One", "Artist Two"]),
+            (["Artist One\\Artist Two"], ["Artist One", "Artist Two"]),
+            (["Artist One/Artist Two"], ["Artist One", "Artist Two"]),
+            (["Artist One;Artist;Three"], ["Artist One", "Artist", "Three"]),
+            (["Artist One;Artist Two;Artist Three"], ["Artist One", "Artist Two", "Artist Three"]),
+            (["  Artist One  "], ["Artist One"]),
+            ([""], []),
+            (["  "], []),
+            (["Artist One"], ["Artist One"]),
+        ],
+    )
+    def test_apply_smart_parsing(self, values, expected_parsed):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        result = manager._apply_smart_parsing(values)
+        assert result == expected_parsed
+
+    def test_apply_smart_parsing_with_null_separators(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        result = manager._apply_smart_parsing(["Artist\x00One\x00Two"])
+        assert result == ["Artist", "One", "Two"]
+
+    def test_apply_smart_parsing_mixed_null_and_regular_separators(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        # Null separators take priority - split on null first
+        result = manager._apply_smart_parsing(["Artist\x00One;Two"])
+        assert result == ["Artist", "One;Two"]
+
+    def test_apply_smart_parsing_multiple_entries_no_separators(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        # Multiple entries without separators - only first non-empty entry is parsed
+        # This is because _apply_smart_parsing is designed for single-entry legacy data
+        result = manager._apply_smart_parsing(["Artist One", "Artist Two"])
+        assert result == ["Artist One"]
+
+    def test_apply_smart_parsing_separator_priority_semicolon_over_comma(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        result = manager._apply_smart_parsing(["Artist One;Artist Two,Artist Three"])
+        assert result == ["Artist One", "Artist Two,Artist Three"]
+
+    def test_apply_smart_parsing_separator_priority_double_slash_over_slash(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        result = manager._apply_smart_parsing(["Artist One//Artist Two/Artist Three"])
+        assert result == ["Artist One", "Artist Two/Artist Three"]
+
+    def test_unicode_characters(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        # Unicode characters in parsed values
+        values = ["Artist Café"]
+        result = manager._apply_smart_parsing(values)
+        assert "Artist Café" in result
+
+    def test_empty_values_after_separation(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        result = manager._apply_smart_parsing(["Artist One;;Artist Two;"])
+        assert result == ["Artist One", "Artist Two"]
+
+    def test_whitespace_around_separators(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        result = manager._apply_smart_parsing(["Artist One ; Artist Two ; Artist Three"])
+        assert result == ["Artist One", "Artist Two", "Artist Three"]
+
+    def test_numeric_entries_in_parsed_value(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        values = ["Artist 1;Artist 2;123"]
+        result = manager._apply_smart_parsing(values)
+        assert "Artist 1" in result
+        assert "Artist 2" in result
+        assert "123" in result
+
+    def test_case_sensitivity_in_parsed_value(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        values = ["Artist One;ARTIST TWO;artist three;ArTiSt FoUr"]
+        result = manager._apply_smart_parsing(values)
+        assert "Artist One" in result
+        assert "ARTIST TWO" in result
+        assert "artist three" in result
+        assert "ArTiSt FoUr" in result
+
+    def test_duplicate_entries_in_parsed_value(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        values = ["Artist One;Artist Two;Artist One;Artist Three;Artist Two"]
+        result = manager._apply_smart_parsing(values)
+        assert result.count("Artist One") == 2
+        assert result.count("Artist Two") == 2
+        assert result.count("Artist Three") == 1
+
+    def test_order_preservation_in_parsed_value(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        values = ["First Artist;Second Artist;Third Artist;Fourth Artist"]
+        result = manager._apply_smart_parsing(values)
+        assert result[0] == "First Artist"
+        assert result[1] == "Second Artist"
+        assert result[2] == "Third Artist"
+        assert result[3] == "Fourth Artist"
+
+    def test_very_long_single_entry(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        long_artist = "A" * 10000
+        result = manager._apply_smart_parsing([long_artist])
+        assert result == [long_artist]
+        assert len(result[0]) == 10000
+
+    def test_mixed_empty_values_with_separators(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        result = manager._apply_smart_parsing(["Artist One;;;Artist Two;Artist;"])
+        assert result == ["Artist One", "Artist Two", "Artist"]
+
+    def test_multiple_spaces_within_values_preserved(self):
+        audio_file = MagicMock()
+        manager = MetadataManager(audio_file, {}, {})
+
+        values = ["Artist  One"]
+        result = manager._apply_smart_parsing(values)
+        assert "Artist  One" in result