test: Cover remaining CombinedTag and FlacTag members

The primary TDD cycle only exercised fields needed for the Issue #6 fix
(Title/Genre on CombinedTag; Title/Album/Pictures on FlacTag). Codecov's
patch target is ~93%, and the untouched fields were dragging the patch
coverage to 75%. These are characterization tests that lock in the
expected behavior of the remaining members.

CombinedTagTests (+7):
- All string fields follow first-non-empty selection
- Track follows first-non-null (uint?) pattern
- TagType aggregates flags across members via bitwise OR
- Pictures unions+dedups across tags (mirrors FlacTag behavior)
- Setters on the base facade are no-ops (format subclasses override)
- Render returns empty; Clear is a no-op

FlacTagTests (+4):
- All text fields (Artist/Year/Comment/Genre/Track) delegate to
  VorbisComment and auto-create it on first write
- TagType advertises Xiph | FlacMetadata
- Render and Clear are view-level no-ops
- Pictures setter accepts null without throwing

Author: decriptor

tests/TagLibSharp2.Tests/Core/CombinedTagTests.cs

@@ -4,6 +4,7 @@
 using TagLibSharp2.Core;
 using TagLibSharp2.Id3;
 using TagLibSharp2.Id3.Id3v2;
+using TagLibSharp2.Xiph;
 
 namespace TagLibSharp2.Tests.Core;
 
@@ -68,4 +69,126 @@ public void Title_SkipsNullTagsInPriorityList ()
 
 		Assert.AreEqual ("From Secondary", combined.Title);
 	}
+
+	/// <summary>
+	/// All string fields follow the same first-non-empty selection across the
+	/// priority list. This test locks in the uniform behavior rather than
+	/// relying on only Title/Genre from earlier tests.
+	/// </summary>
+	[TestMethod]
+	public void AllStringFields_ReturnFirstNonEmptyValueAcrossTags ()
+	{
+		var primary = new Id3v2Tag { Artist = "Primary Artist" };
+		var secondary = new Id3v1Tag {
+			Album = "Secondary Album",
+			Year = "2001",
+			Comment = "Secondary Comment",
+			Genre = "Rock", // must be a valid ID3v1 genre (https://id3.org/ID3v1)
+		};
+
+		var combined = new CombinedTag (primary, secondary);
+
+		Assert.AreEqual ("Primary Artist", combined.Artist, "Artist from primary");
+		Assert.AreEqual ("Secondary Album", combined.Album, "Album falls back to secondary");
+		Assert.AreEqual ("2001", combined.Year, "Year falls back to secondary");
+		Assert.AreEqual ("Secondary Comment", combined.Comment, "Comment falls back to secondary");
+		Assert.AreEqual ("Rock", combined.Genre, "Genre falls back to secondary");
+	}
+
+	/// <summary>
+	/// Track (uint?) follows the same first-non-null pattern as string fields.
+	/// </summary>
+	[TestMethod]
+	public void Track_ReturnsFirstNonNullValueAcrossTags ()
+	{
+		var primary = new Id3v2Tag ();
+		var secondary = new Id3v1Tag { Track = 7 };
+
+		var combined = new CombinedTag (primary, secondary);
+
+		Assert.AreEqual ((uint)7, combined.Track);
+	}
+
+	/// <summary>
+	/// <see cref="CombinedTag.TagType"/> aggregates the tag type flags of every
+	/// non-null member. This lets callers check "does this file have Xiph data?"
+	/// via a single bitwise query.
+	/// </summary>
+	[TestMethod]
+	public void TagType_AggregatesFlagsAcrossMembers ()
+	{
+		var combined = new CombinedTag (new Id3v2Tag (), new Id3v1Tag ());
+
+		Assert.AreEqual (TagTypes.Id3v2 | TagTypes.Id3v1, combined.TagType);
+	}
+
+	/// <summary>
+	/// <see cref="CombinedTag.Pictures"/> unions pictures across member tags and
+	/// deduplicates on (PictureType, MimeType, PictureData). The dedup behavior
+	/// mirrors FlacTag's and is the library convention (see also TagLib C++,
+	/// Jaudiotagger).
+	/// </summary>
+	[TestMethod]
+	public void Pictures_UnionsAcrossTagsWithDedup ()
+	{
+		var sharedBytes = new byte[] { 0x01, 0x02 };
+		var primary = new Id3v2Tag ();
+		primary.Pictures = [new FlacPicture ("image/jpeg", PictureType.FrontCover, "",
+			new BinaryData (sharedBytes), 0, 0, 0, 0)];
+		var secondary = new Id3v2Tag ();
+		secondary.Pictures = [
+			new FlacPicture ("image/jpeg", PictureType.FrontCover, "",
+				new BinaryData (sharedBytes), 0, 0, 0, 0),
+			new FlacPicture ("image/jpeg", PictureType.BackCover, "",
+				new BinaryData (new byte[] { 0x03 }), 0, 0, 0, 0),
+		];
+
+		var combined = new CombinedTag (primary, secondary);
+
+		Assert.AreEqual (2, combined.Pictures.Length,
+			"duplicate front cover across tags dedupes; distinct back cover remains");
+	}
+
+	/// <summary>
+	/// The base <see cref="CombinedTag"/> exposes writes as no-ops so that it
+	/// cannot accidentally mutate underlying tags without a subclass making an
+	/// explicit decision. Format-specific subclasses override individual
+	/// setters when write-through is the correct behavior.
+	/// </summary>
+	[TestMethod]
+	public void Setters_AreNoOpsOnBaseFacade ()
+	{
+		var primary = new Id3v2Tag { Title = "Original" };
+		var combined = new CombinedTag (primary);
+
+		combined.Title = "Changed";
+		combined.Track = 42;
+		combined.Pictures = [];
+
+		Assert.AreEqual ("Original", primary.Title, "Base CombinedTag.Title setter does not mutate members");
+		Assert.IsNull (primary.Track, "Base CombinedTag.Track setter does not mutate members");
+	}
+
+	[TestMethod]
+	public void Render_ReturnsEmptyBinaryData ()
+	{
+		var combined = new CombinedTag (new Id3v2Tag { Title = "x" });
+
+		var rendered = combined.Render ();
+
+		Assert.IsTrue (rendered.IsEmpty,
+			"CombinedTag is a view; it does not own bytes and Render returns empty");
+	}
+
+	[TestMethod]
+	public void Clear_IsNoOp ()
+	{
+		var primary = new Id3v2Tag { Title = "Keep Me" };
+		var combined = new CombinedTag (primary);
+
+		combined.Clear ();
+
+		Assert.AreEqual ("Keep Me", primary.Title,
+			"Base CombinedTag.Clear does not mutate members");
+	}
 }

tests/TagLibSharp2.Tests/Xiph/FlacTagTests.cs

@@ -214,6 +214,80 @@ public void MediaFile_ReadFromData_Flac_TagPicturesMatchFilePictures ()
 			"MediaFileResult.Tag.Pictures must match File.Pictures (Issue #6)");
 	}
 
+	/// <summary>
+	/// All text fields read through <see cref="FlacFile.Tag"/> reflect the
+	/// VorbisComment's values, and writes create a VorbisComment if none exists.
+	/// Extends <see cref="Tag_TextFields_ReadAndWriteThroughVorbisComment"/> to
+	/// every abstract string/uint field defined on <see cref="Tag"/>.
+	/// </summary>
+	[TestMethod]
+	public void Tag_AllTextFields_DelegateToVorbisComment ()
+	{
+		var file = FlacFile.Read (TestBuilders.Flac.CreateMinimal ()).File!;
+		Assert.IsNull (file.VorbisComment, "precondition: no VorbisComment yet");
+
+		// Writes auto-create the VorbisComment, then all subsequent reads match.
+		file.Tag!.Artist = "A";
+		file.Tag.Year = "2026";
+		file.Tag.Comment = "C";
+		file.Tag.Genre = "Rock";
+		file.Tag.Track = 3;
+
+		Assert.IsNotNull (file.VorbisComment, "VorbisComment created on first write");
+		Assert.AreEqual ("A", file.Tag.Artist);
+		Assert.AreEqual ("2026", file.Tag.Year);
+		Assert.AreEqual ("C", file.Tag.Comment);
+		Assert.AreEqual ("Rock", file.Tag.Genre);
+		Assert.AreEqual ((uint)3, file.Tag.Track);
+	}
+
+	/// <summary>
+	/// <see cref="FlacTag.TagType"/> advertises both Xiph (the comment block)
+	/// and FlacMetadata (the native PICTURE/CueSheet blocks it also fronts).
+	/// </summary>
+	[TestMethod]
+	public void Tag_TagType_AdvertisesXiphAndFlacMetadata ()
+	{
+		var file = FlacFile.Read (TestBuilders.Flac.CreateMinimal ()).File!;
+
+		Assert.AreEqual (TagTypes.Xiph | TagTypes.FlacMetadata, file.Tag!.TagType);
+	}
+
+	/// <summary>
+	/// <see cref="FlacTag"/> is a view over the file — it is not itself a
+	/// serializable block — so <c>Render</c> returns empty and <c>Clear</c>
+	/// is a no-op. Callers that need to persist changes do so through
+	/// <see cref="FlacFile.Render"/>.
+	/// </summary>
+	[TestMethod]
+	public void Tag_RenderAndClear_AreViewLevelNoOps ()
+	{
+		var data = TestBuilders.Flac.CreateWithVorbisComment ("Keep Me", "Keep Artist");
+		var file = FlacFile.Read (data).File!;
+
+		Assert.IsTrue (file.Tag!.Render ().IsEmpty, "Render on the view returns empty");
+
+		file.Tag.Clear ();
+
+		Assert.AreEqual ("Keep Me", file.VorbisComment!.Title,
+			"Clear on the view does not wipe the underlying VorbisComment");
+	}
+
+	/// <summary>
+	/// Setting Tag.Pictures to null clears pictures rather than throwing.
+	/// </summary>
+	[TestMethod]
+	public void Tag_SetPictures_NullValueClearsWithoutThrowing ()
+	{
+		var data = TestBuilders.Flac.CreateWithPicture (PictureType.FrontCover);
+		var file = FlacFile.Read (data).File!;
+		Assert.AreEqual (1, file.Pictures.Count, "precondition: one picture");
+
+		file.Tag!.Pictures = null!;
+
+		Assert.AreEqual (0, file.Pictures.Count);
+	}
+
 	static byte[] BuildFlacWithPictureInBothLocations ()
 	{
 		var seed = TestBuilders.Flac.CreateWithVorbisComment ("seed", "seed");