Add comprehensive base64 roundtripping tests for all protocol types

Add Theory-based tests for ImageContentBlock, AudioContentBlock, and
BlobResourceContents covering:
- Various lengths (empty, 1-4 bytes, 256 bytes, 1024 bytes)
- Full base64 alphabet including '+' and '/' characters
- With/without padding (0, 1, 2 padding chars)
- All construction paths: FromBytes(), Data/Blob setter, JSON deserialization
- Escaped and unescaped JSON deserialization
- Lazy encoding verification (FromBytes defers until Data/Blob accessed)
- Cache invalidation when Data/Blob setter is used after FromBytes

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

Author: Copilot

tests/ModelContextProtocol.Tests/Protocol/ContentBlockTests.cs

@@ -1,4 +1,5 @@
 using ModelContextProtocol.Protocol;
+using System.Text;
 using System.Text.Json;
 
 namespace ModelContextProtocol.Tests.Protocol;
@@ -323,4 +324,242 @@ public void AudioContentBlock_Deserialization_HandlesEscapedForwardSlashInBase64
         Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(audio.Data.ToArray()));
         Assert.Equal(originalBytes, audio.DecodedData.ToArray());
     }
+
+    /// <summary>
+    /// Provides test data for base64 roundtrip tests. Each entry is a byte array that exercises
+    /// different base64 encoding characteristics:
+    /// - Various lengths producing 0, 1, or 2 padding characters
+    /// - Bytes that produce all 64 base64 alphabet characters including '+' and '/'
+    /// </summary>
+    public static TheoryData<byte[]> Base64TestData()
+    {
+        var data = new TheoryData<byte[]>
+        {
+            Array.Empty<byte>(),       // empty: ""
+            new byte[] { 0x00 },       // 1 byte, 2 padding chars: "AA=="
+            new byte[] { 0x00, 0x01 }, // 2 bytes, 1 padding char: "AAE="
+            new byte[] { 0x00, 0x01, 0x02 }, // 3 bytes, no padding: "AAEC"
+            new byte[] { 0xFF, 0xD8, 0xFF, 0xE0 }, // produces '/' in base64: "/9j/4A=="
+            new byte[] { 0xFB, 0xEF, 0xBE }, // produces '+' in base64: "+++"
+        };
+
+        // All 256 byte values to exercise the full base64 alphabet
+        byte[] allBytes = new byte[256];
+        for (int i = 0; i < 256; i++)
+        {
+            allBytes[i] = (byte)i;
+        }
+        data.Add(allBytes);
+
+        // Larger payload (1024 bytes)
+        byte[] largePayload = new byte[1024];
+        new Random(42).NextBytes(largePayload);
+        data.Add(largePayload);
+
+        return data;
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void ImageContentBlock_FromBytes_RoundtripsCorrectly(byte[] originalBytes)
+    {
+        string expectedBase64 = Convert.ToBase64String(originalBytes);
+
+        var image = ImageContentBlock.FromBytes(originalBytes, "image/png");
+
+        Assert.Equal("image/png", image.MimeType);
+        Assert.Equal(originalBytes, image.DecodedData.ToArray());
+        Assert.Equal(expectedBase64, Encoding.UTF8.GetString(image.Data.ToArray()));
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void ImageContentBlock_DataSetter_RoundtripsCorrectly(byte[] originalBytes)
+    {
+        string base64 = Convert.ToBase64String(originalBytes);
+        byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
+
+        var image = new ImageContentBlock { Data = base64Utf8, MimeType = "image/png" };
+
+        Assert.Equal(base64Utf8, image.Data.ToArray());
+        Assert.Equal(originalBytes, image.DecodedData.ToArray());
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void ImageContentBlock_JsonRoundtrip_PreservesData(byte[] originalBytes)
+    {
+        string base64 = Convert.ToBase64String(originalBytes);
+        byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
+
+        var original = new ImageContentBlock { Data = base64Utf8, MimeType = "image/png" };
+        string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = Assert.IsType<ImageContentBlock>(
+            JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
+
+        Assert.Equal(base64Utf8, deserialized.Data.ToArray());
+        Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void ImageContentBlock_FromBytes_JsonRoundtrip_PreservesData(byte[] originalBytes)
+    {
+        string expectedBase64 = Convert.ToBase64String(originalBytes);
+
+        var original = ImageContentBlock.FromBytes(originalBytes, "image/jpeg");
+        string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = Assert.IsType<ImageContentBlock>(
+            JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
+
+        Assert.Equal(expectedBase64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
+        Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void ImageContentBlock_EscapedJsonRoundtrip_PreservesData(byte[] originalBytes)
+    {
+        string base64 = Convert.ToBase64String(originalBytes);
+
+        // Simulate JSON encoder that escapes '/' as '\/'
+        string json = $$"""{"type":"image","data":"{{base64.Replace("/", "\\/")}}","mimeType":"image/png"}""";
+
+        var deserialized = Assert.IsType<ImageContentBlock>(
+            JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
+
+        Assert.Equal(base64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
+        Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
+    }
+
+    [Fact]
+    public void ImageContentBlock_DataSetterInvalidatesCachedDecodedData()
+    {
+        byte[] bytes1 = [1, 2, 3];
+        var image = ImageContentBlock.FromBytes(bytes1, "image/png");
+
+        // Access DecodedData to populate cache
+        Assert.Equal(bytes1, image.DecodedData.ToArray());
+
+        // Set new Data to invalidate cache
+        byte[] newBytes = [4, 5, 6];
+        string newBase64 = Convert.ToBase64String(newBytes);
+        image.Data = Encoding.UTF8.GetBytes(newBase64);
+
+        Assert.Equal(newBytes, image.DecodedData.ToArray());
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void AudioContentBlock_FromBytes_RoundtripsCorrectly(byte[] originalBytes)
+    {
+        string expectedBase64 = Convert.ToBase64String(originalBytes);
+
+        var audio = AudioContentBlock.FromBytes(originalBytes, "audio/wav");
+
+        Assert.Equal("audio/wav", audio.MimeType);
+        Assert.Equal(originalBytes, audio.DecodedData.ToArray());
+        Assert.Equal(expectedBase64, Encoding.UTF8.GetString(audio.Data.ToArray()));
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void AudioContentBlock_DataSetter_RoundtripsCorrectly(byte[] originalBytes)
+    {
+        string base64 = Convert.ToBase64String(originalBytes);
+        byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
+
+        var audio = new AudioContentBlock { Data = base64Utf8, MimeType = "audio/wav" };
+
+        Assert.Equal(base64Utf8, audio.Data.ToArray());
+        Assert.Equal(originalBytes, audio.DecodedData.ToArray());
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void AudioContentBlock_JsonRoundtrip_PreservesData(byte[] originalBytes)
+    {
+        string base64 = Convert.ToBase64String(originalBytes);
+        byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
+
+        var original = new AudioContentBlock { Data = base64Utf8, MimeType = "audio/wav" };
+        string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = Assert.IsType<AudioContentBlock>(
+            JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
+
+        Assert.Equal(base64Utf8, deserialized.Data.ToArray());
+        Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void AudioContentBlock_FromBytes_JsonRoundtrip_PreservesData(byte[] originalBytes)
+    {
+        string expectedBase64 = Convert.ToBase64String(originalBytes);
+
+        var original = AudioContentBlock.FromBytes(originalBytes, "audio/mp3");
+        string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
+        var deserialized = Assert.IsType<AudioContentBlock>(
+            JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
+
+        Assert.Equal(expectedBase64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
+        Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void AudioContentBlock_EscapedJsonRoundtrip_PreservesData(byte[] originalBytes)
+    {
+        string base64 = Convert.ToBase64String(originalBytes);
+
+        string json = $$"""{"type":"audio","data":"{{base64.Replace("/", "\\/")}}","mimeType":"audio/wav"}""";
+
+        var deserialized = Assert.IsType<AudioContentBlock>(
+            JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
+
+        Assert.Equal(base64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
+        Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
+    }
+
+    [Fact]
+    public void AudioContentBlock_DataSetterInvalidatesCachedDecodedData()
+    {
+        byte[] bytes1 = [1, 2, 3];
+        var audio = AudioContentBlock.FromBytes(bytes1, "audio/wav");
+
+        Assert.Equal(bytes1, audio.DecodedData.ToArray());
+
+        byte[] newBytes = [4, 5, 6];
+        string newBase64 = Convert.ToBase64String(newBytes);
+        audio.Data = Encoding.UTF8.GetBytes(newBase64);
+
+        Assert.Equal(newBytes, audio.DecodedData.ToArray());
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void ImageContentBlock_FromBytes_LazilyEncodesData(byte[] originalBytes)
+    {
+        // FromBytes should only decode when Data is accessed
+        var image = ImageContentBlock.FromBytes(originalBytes, "image/png");
+
+        // First, access DecodedData without touching Data
+        Assert.Equal(originalBytes, image.DecodedData.ToArray());
+
+        // Now access Data and verify it lazily encoded correctly
+        string expectedBase64 = Convert.ToBase64String(originalBytes);
+        Assert.Equal(expectedBase64, Encoding.UTF8.GetString(image.Data.ToArray()));
+    }
+
+    [Theory]
+    [MemberData(nameof(Base64TestData))]
+    public void AudioContentBlock_FromBytes_LazilyEncodesData(byte[] originalBytes)
+    {
+        var audio = AudioContentBlock.FromBytes(originalBytes, "audio/wav");
+
+        Assert.Equal(originalBytes, audio.DecodedData.ToArray());
+
+        string expectedBase64 = Convert.ToBase64String(originalBytes);
+        Assert.Equal(expectedBase64, Encoding.UTF8.GetString(audio.Data.ToArray()));
+    }
 }