Improve test coverage to 80%+ for all formats

Add comprehensive tests for previously low-coverage format classes:

- AsfTag (49% → 100%): Render tests, setter tests, MusicBrainz IDs,
  ReplayGain, edge cases, result type equality
- AsfFile (63% → 97%): File I/O tests, dispose tests, result types
- WavPackFile (64% → 88%): Custom sample rate parsing, multi-channel
  metadata, EnsureApeTag/RemoveApeTag, Render, SaveToFile error paths
- OggVorbisFile (76% → 85%): Render with originalData, field tests
- MusepackFile (79% → 87%): Dispose tests, result type equality

Overall coverage: 90.2% line, 77.5% branch

Author: decriptor

tests/TagLibSharp2.Tests/Asf/AsfFileTests.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License. See LICENSE file in the project root for full license information.
 
 using TagLibSharp2.Asf;
+using TagLibSharp2.Tests.Core;
 
 namespace TagLibSharp2.Tests.Asf;
 
@@ -192,4 +193,270 @@ public void Parse_UnicodeArtist_Preserved ()
 		Assert.IsTrue (result.IsSuccess);
 		Assert.AreEqual ("Café Français", result.Value.Tag.Artist);
 	}
+
+	// ═══════════════════════════════════════════════════════════════
+	// File I/O Tests
+	// ═══════════════════════════════════════════════════════════════
+
+	[TestMethod]
+	public void ReadFromFile_ValidFile_ReturnsSuccess ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma (title: "File Test");
+		var mockFs = new MockFileSystem ();
+		mockFs.AddFile ("/test.wma", data);
+
+		var result = AsfFile.ReadFromFile ("/test.wma", mockFs);
+
+		Assert.IsTrue (result.IsSuccess, result.Error);
+		Assert.AreEqual ("File Test", result.Value.Title);
+	}
+
+	[TestMethod]
+	public void ReadFromFile_SetsSourcePath ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma ();
+		var mockFs = new MockFileSystem ();
+		mockFs.AddFile ("/music/song.wma", data);
+
+		var result = AsfFile.ReadFromFile ("/music/song.wma", mockFs);
+
+		Assert.IsTrue (result.IsSuccess);
+		Assert.AreEqual ("/music/song.wma", result.Value.SourcePath);
+	}
+
+	[TestMethod]
+	public void ReadFromFile_FileNotFound_ReturnsFailure ()
+	{
+		var mockFs = new MockFileSystem ();
+
+		var result = AsfFile.ReadFromFile ("/nonexistent.wma", mockFs);
+
+		Assert.IsFalse (result.IsSuccess);
+		Assert.IsNotNull (result.Error);
+	}
+
+	[TestMethod]
+	public async Task ReadFromFileAsync_ValidFile_ReturnsSuccess ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma (title: "Async Test");
+		var mockFs = new MockFileSystem ();
+		mockFs.AddFile ("/test.wma", data);
+
+		var result = await AsfFile.ReadFromFileAsync ("/test.wma", mockFs);
+
+		Assert.IsTrue (result.IsSuccess, result.Error);
+		Assert.AreEqual ("Async Test", result.Value.Title);
+	}
+
+	[TestMethod]
+	public async Task ReadFromFileAsync_SetsSourcePath ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma ();
+		var mockFs = new MockFileSystem ();
+		mockFs.AddFile ("/music/async.wma", data);
+
+		var result = await AsfFile.ReadFromFileAsync ("/music/async.wma", mockFs);
+
+		Assert.IsTrue (result.IsSuccess);
+		Assert.AreEqual ("/music/async.wma", result.Value.SourcePath);
+	}
+
+	[TestMethod]
+	public async Task ReadFromFileAsync_FileNotFound_ReturnsFailure ()
+	{
+		var mockFs = new MockFileSystem ();
+
+		var result = await AsfFile.ReadFromFileAsync ("/nonexistent.wma", mockFs);
+
+		Assert.IsFalse (result.IsSuccess);
+		Assert.IsNotNull (result.Error);
+	}
+
+	// ═══════════════════════════════════════════════════════════════
+	// Convenience Property Setter Tests
+	// ═══════════════════════════════════════════════════════════════
+
+	[TestMethod]
+	public void Title_Set_UpdatesTag ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma ();
+		var result = AsfFile.Read (data);
+		Assert.IsTrue (result.IsSuccess);
+
+		result.Value.Title = "New Title";
+
+		Assert.AreEqual ("New Title", result.Value.Title);
+		Assert.AreEqual ("New Title", result.Value.Tag.Title);
+	}
+
+	[TestMethod]
+	public void Artist_Set_UpdatesTag ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma ();
+		var result = AsfFile.Read (data);
+		Assert.IsTrue (result.IsSuccess);
+
+		result.Value.Artist = "New Artist";
+
+		Assert.AreEqual ("New Artist", result.Value.Artist);
+		Assert.AreEqual ("New Artist", result.Value.Tag.Artist);
+	}
+
+	[TestMethod]
+	public void Album_Get_DelegatesToTag ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWmaWithExtended (album: "Test Album");
+		var result = AsfFile.Read (data);
+
+		Assert.IsTrue (result.IsSuccess);
+		Assert.AreEqual ("Test Album", result.Value.Album);
+	}
+
+	[TestMethod]
+	public void Album_Set_UpdatesTag ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma ();
+		var result = AsfFile.Read (data);
+		Assert.IsTrue (result.IsSuccess);
+
+		result.Value.Album = "New Album";
+
+		Assert.AreEqual ("New Album", result.Value.Album);
+		Assert.AreEqual ("New Album", result.Value.Tag.Album);
+	}
+
+	// ═══════════════════════════════════════════════════════════════
+	// Dispose Tests
+	// ═══════════════════════════════════════════════════════════════
+
+	[TestMethod]
+	public void Dispose_ClearsSourcePath ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma ();
+		var mockFs = new MockFileSystem ();
+		mockFs.AddFile ("/test.wma", data);
+
+		var result = AsfFile.ReadFromFile ("/test.wma", mockFs);
+		Assert.IsTrue (result.IsSuccess);
+		Assert.IsNotNull (result.Value.SourcePath);
+
+		result.Value.Dispose ();
+
+		Assert.IsNull (result.Value.SourcePath);
+	}
+
+	[TestMethod]
+	public void Dispose_CalledTwice_DoesNotThrow ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma ();
+		var result = AsfFile.Read (data);
+		Assert.IsTrue (result.IsSuccess);
+
+		result.Value.Dispose ();
+		result.Value.Dispose (); // Should not throw
+	}
+
+	// ═══════════════════════════════════════════════════════════════
+	// Result Type Tests
+	// ═══════════════════════════════════════════════════════════════
+
+	[TestMethod]
+	public void AsfFileReadResult_Success_IsSuccessTrue ()
+	{
+		var data = AsfTestBuilder.CreateMinimalWma ();
+		var result = AsfFile.Read (data);
+
+		Assert.IsTrue (result.IsSuccess);
+		Assert.IsNull (result.Error);
+	}
+
+	[TestMethod]
+	public void AsfFileReadResult_Failure_IsSuccessFalse ()
+	{
+		var result = AsfFile.Read ([]);
+
+		Assert.IsFalse (result.IsSuccess);
+		Assert.IsNotNull (result.Error);
+	}
+
+	[TestMethod]
+	public void AsfFileReadResult_Equals_SameError_ReturnsTrue ()
+	{
+		var result1 = AsfFile.Read ([]);
+		var result2 = AsfFile.Read ([]);
+
+		Assert.IsTrue (result1.Equals (result2));
+		Assert.IsTrue (result1 == result2);
+	}
+
+	[TestMethod]
+	public void AsfFileReadResult_Equals_DifferentError_ReturnsFalse ()
+	{
+		// Empty array produces "Data too short for ASF header"
+		var result1 = AsfFile.Read ([]);
+
+		// 30+ bytes with invalid GUID produces "Invalid ASF header: not an ASF file"
+		var invalidGuidData = new byte[30];
+		var result2 = AsfFile.Read (invalidGuidData);
+
+		// Different error messages should not be equal
+		Assert.AreNotEqual (result1.Error, result2.Error);
+		Assert.IsFalse (result1.Equals (result2));
+		Assert.IsTrue (result1 != result2);
+	}
+
+	[TestMethod]
+	public void AsfFileReadResult_Equals_Object_ReturnsCorrectly ()
+	{
+		var result1 = AsfFile.Read ([]);
+		var result2 = AsfFile.Read ([]);
+		object boxed = result2;
+
+		Assert.IsTrue (result1.Equals (boxed));
+		Assert.IsFalse (result1.Equals ("not a result"));
+		Assert.IsFalse (result1.Equals (null));
+	}
+
+	[TestMethod]
+	public void AsfFileReadResult_GetHashCode_SameError_SameHash ()
+	{
+		var result1 = AsfFile.Read ([]);
+		var result2 = AsfFile.Read ([]);
+
+		Assert.AreEqual (result1.GetHashCode (), result2.GetHashCode ());
+	}
+
+	// ═══════════════════════════════════════════════════════════════
+	// Edge Case Tests
+	// ═══════════════════════════════════════════════════════════════
+
+	[TestMethod]
+	public void Read_ChildObjectSizeTooLarge_ReturnsPartialParse ()
+	{
+		// Create file where child object claims to be larger than remaining data
+		var data = AsfTestBuilder.CreateMinimalWma ();
+		// Truncate to create inconsistent state - still parses what it can
+		var truncated = data[..^50];
+
+		var result = AsfFile.Read (truncated);
+
+		// Should still succeed with what it could parse
+		Assert.IsTrue (result.IsSuccess || result.Error!.Contains ("size"));
+	}
+
+	[TestMethod]
+	public void Read_HeaderSizeExceedsData_ReturnsFailure ()
+	{
+		// Create header claiming larger size than available
+		var data = new byte[50];
+		var headerGuid = AsfGuids.HeaderObject.Render ().ToArray ();
+		Array.Copy (headerGuid, data, 16);
+		// Write header size as very large number
+		BitConverter.TryWriteBytes (data.AsSpan (16), 99999UL);
+
+		var result = AsfFile.Read (data);
+
+		Assert.IsFalse (result.IsSuccess);
+		Assert.Contains ("size", result.Error!.ToLowerInvariant ());
+	}
 }