Add inline snapshot support

src/DiffEngine.Tests/CsStringLiteralTests.cs

@@ -0,0 +1,144 @@
+public class CsStringLiteralTests
+{
+    static readonly string[] renderRoundTripCases =
+    [
+        "abc",
+        "a\nb",
+        "\nabc",
+        "abc\n",
+        "\nabc\n",
+        "a\n\n\nb",
+        "\"",
+        "\"\"",
+        "\"\"\"",
+        "\"\"\"\"\"\"",
+        "\"\"\"starts with quotes",
+        "ends with quote\"",
+        "$ {value} {{x}}",
+        "a\n   \nb",
+        "trailing space  \nnext",
+        "emoji 🎈 and unicode ☂",
+        "line1\n    indented\nline3"
+    ];
+
+    [Test]
+    public async Task RenderSimple()
+    {
+        var rendered = CsStringLiteral.RenderRaw("abc", "    ", "\n");
+        await Assert.That(rendered).IsEqualTo("\"\"\"\n    abc\n    \"\"\"");
+    }
+
+    [Test]
+    public async Task RenderMultiLine()
+    {
+        var rendered = CsStringLiteral.RenderRaw("a\nb", "    ", "\n");
+        await Assert.That(rendered).IsEqualTo("\"\"\"\n    a\n    b\n    \"\"\"");
+    }
+
+    [Test]
+    public async Task RenderEmpty()
+    {
+        var rendered = CsStringLiteral.RenderRaw("", "    ", "\n");
+        await Assert.That(rendered).IsEqualTo("\"\"\"\n    \"\"\"");
+    }
+
+    [Test]
+    public async Task RenderBlankLineHasNoTrailingWhitespace()
+    {
+        var rendered = CsStringLiteral.RenderRaw("a\n\nb", "    ", "\n");
+        await Assert.That(rendered).IsEqualTo("\"\"\"\n    a\n\n    b\n    \"\"\"");
+    }
+
+    [Test]
+    public async Task RenderQuoteRunEscalatesDelimiter()
+    {
+        var rendered = CsStringLiteral.RenderRaw("has \"\"\" inside", "", "\n");
+        await Assert.That(rendered).IsEqualTo("\"\"\"\"\nhas \"\"\" inside\n\"\"\"\"");
+    }
+
+    [Test]
+    public async Task RenderCrlf()
+    {
+        var rendered = CsStringLiteral.RenderRaw("a\nb", "\t", "\r\n");
+        await Assert.That(rendered).IsEqualTo("\"\"\"\r\n\ta\r\n\tb\r\n\t\"\"\"");
+    }
+
+    [Test]
+    public async Task RenderRoundTrips()
+    {
+        foreach (var content in renderRoundTripCases)
+        {
+            foreach (var eol in new[] { "\n", "\r\n" })
+            {
+                foreach (var indent in new[] { "", "    ", "\t\t" })
+                {
+                    var rendered = CsStringLiteral.RenderRaw(content, indent, eol);
+                    var parsed = CsStringLiteral.TryParse(rendered, out var value);
+                    await Assert.That(parsed).IsTrue();
+                    await Assert.That(value).IsEqualTo(content);
+                }
+            }
+        }
+    }
+
+    [Test]
+    [Arguments("\"a\"", "a")]
+    [Arguments("\"\"", "")]
+    [Arguments("\"a\\nb\"", "a\nb")]
+    [Arguments("\"tab\\there\"", "tab\there")]
+    [Arguments("\"quote\\\"q\"", "quote\"q")]
+    [Arguments("\"back\\\\slash\"", "back\\slash")]
+    [Arguments("\"\\u0041\"", "A")]
+    [Arguments("\"\\x41\"", "A")]
+    [Arguments("\"\\U0001F600\"", "😀")]
+    [Arguments("@\"a\"\"b\"", "a\"b")]
+    [Arguments("\"\"\"a\"b\"\"\"", "a\"b")]
+    [Arguments("\"\"\"\"has \"\"\" inside\"\"\"\"", "has \"\"\" inside")]
+    public async Task Parse(string expression, string expected)
+    {
+        var parsed = CsStringLiteral.TryParse(expression, out var value);
+        await Assert.That(parsed).IsTrue();
+        await Assert.That(value).IsEqualTo(expected);
+    }
+
+    [Test]
+    public async Task ParseMultiLineVerbatim()
+    {
+        var parsed = CsStringLiteral.TryParse("@\"a\r\nb\"", out var value);
+        await Assert.That(parsed).IsTrue();
+        await Assert.That(value).IsEqualTo("a\nb");
+    }
+
+    [Test]
+    public async Task ParseMultiLineRawStripsIndent()
+    {
+        var expression = "\"\"\"\n      a\n\n      b\n      \"\"\"";
+        var parsed = CsStringLiteral.TryParse(expression, out var value);
+        await Assert.That(parsed).IsTrue();
+        await Assert.That(value).IsEqualTo("a\n\nb");
+    }
+
+    [Test]
+    [Arguments("$\"interpolated\"")]
+    [Arguments("$$\"\"\"raw interpolated\"\"\"")]
+    [Arguments("nameof(x)")]
+    [Arguments("\"a\" + \"b\"")]
+    [Arguments("\"unterminated")]
+    [Arguments("identifier")]
+    [Arguments("")]
+    [Arguments("@$\"combined\"")]
+    public async Task ParseRejects(string expression)
+    {
+        var parsed = CsStringLiteral.TryParse(expression, out _);
+        await Assert.That(parsed).IsFalse();
+    }
+
+    [Test]
+    public async Task ParseRejectsMalformedRawIndent()
+    {
+        // Content line is less indented than the closing delimiter
+        var expression = "\"\"\"\n  a\n      \"\"\"";
+        var parsed = CsStringLiteral.TryParse(expression, out _);
+        await Assert.That(parsed).IsFalse();
+    }
+}

src/DiffEngine.Tests/InlineApplierTests.cs

@@ -0,0 +1,227 @@
+public class InlineApplierTests
+{
+    static string WriteTemp(byte[] bytes)
+    {
+        var path = Path.Combine(Path.GetTempPath(), $"InlineApplierTests_{Guid.NewGuid():N}.cs");
+        File.WriteAllBytes(path, bytes);
+        return path;
+    }
+
+    static byte[] Utf8(string text, bool bom)
+    {
+        var encoding = new UTF8Encoding(bom);
+        var content = encoding.GetBytes(text);
+        if (!bom)
+        {
+            return content;
+        }
+
+        var preamble = encoding.GetPreamble();
+        var result = new byte[preamble.Length + content.Length];
+        Buffer.BlockCopy(preamble, 0, result, 0, preamble.Length);
+        Buffer.BlockCopy(content, 0, result, preamble.Length, content.Length);
+        return result;
+    }
+
+    const string source = "class C\n{\n    void M() => VerifyInline(value, \"old\");\n}";
+
+    [Test]
+    public async Task Utf8BomPreserved()
+    {
+        var path = WriteTemp(Utf8(source, bom: true));
+        try
+        {
+            var result = InlineApplier.Apply(new(path, 3, "\"old\"", "new"));
+            await Assert.That(result.Status).IsEqualTo(InlineApplyStatus.Applied);
+            var bytes = File.ReadAllBytes(path);
+            await Assert.That(bytes[0]).IsEqualTo((byte)0xEF);
+            await Assert.That(bytes[1]).IsEqualTo((byte)0xBB);
+            await Assert.That(bytes[2]).IsEqualTo((byte)0xBF);
+            await Assert.That(File.ReadAllText(path)).Contains("new");
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Test]
+    public async Task NoBomStaysNoBom()
+    {
+        var path = WriteTemp(Utf8(source, bom: false));
+        try
+        {
+            var result = InlineApplier.Apply(new(path, 3, "\"old\"", "new"));
+            await Assert.That(result.Status).IsEqualTo(InlineApplyStatus.Applied);
+            var bytes = File.ReadAllBytes(path);
+            await Assert.That(bytes[0]).IsEqualTo((byte)'c');
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Test]
+    public async Task Utf16Preserved()
+    {
+        var encoding = new UnicodeEncoding(false, true);
+        var path = WriteTemp(encoding.GetPreamble().Concat(encoding.GetBytes(source)).ToArray());
+        try
+        {
+            var result = InlineApplier.Apply(new(path, 3, "\"old\"", "new"));
+            await Assert.That(result.Status).IsEqualTo(InlineApplyStatus.Applied);
+            var bytes = File.ReadAllBytes(path);
+            await Assert.That(bytes[0]).IsEqualTo((byte)0xFF);
+            await Assert.That(bytes[1]).IsEqualTo((byte)0xFE);
+            await Assert.That(File.ReadAllText(path, encoding)).Contains("new");
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Test]
+    public async Task CrlfPreserved()
+    {
+        var path = WriteTemp(Utf8(source.Replace("\n", "\r\n"), bom: false));
+        try
+        {
+            var result = InlineApplier.Apply(new(path, 3, "\"old\"", "a\nb"));
+            await Assert.That(result.Status).IsEqualTo(InlineApplyStatus.Applied);
+            var text = File.ReadAllText(path);
+            await Assert.That(text).DoesNotContain("a\nb");
+            await Assert.That(text).Contains("a\r\n");
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Test]
+    public async Task MissingFileFails()
+    {
+        var result = InlineApplier.Apply(new(Path.Combine(Path.GetTempPath(), "does-not-exist-inline.cs"), 1, null, "x"));
+        await Assert.That(result.Status).IsEqualTo(InlineApplyStatus.Failed);
+    }
+
+    [Test]
+    public async Task AlreadyAppliedDoesNotWrite()
+    {
+        var path = WriteTemp(Utf8(source, bom: false));
+        try
+        {
+            var before = File.GetLastWriteTimeUtc(path);
+            var result = InlineApplier.Apply(new(path, 3, "\"old\"", "old"));
+            await Assert.That(result.Status).IsEqualTo(InlineApplyStatus.AlreadyApplied);
+            await Assert.That(File.GetLastWriteTimeUtc(path)).IsEqualTo(before);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Test]
+    public async Task ParallelAppliesToSameFile()
+    {
+        var multi = "class C\n{\n    void A() => VerifyInline(a, \"oldA\");\n    void B() => VerifyInline(b, \"oldB\");\n}";
+        var path = WriteTemp(Utf8(multi, bom: false));
+        try
+        {
+            var taskA = InlineApplier.ApplyAsync(new(path, 3, "\"oldA\"", "newA"));
+            var taskB = InlineApplier.ApplyAsync(new(path, 4, "\"oldB\"", "newB"));
+            var results = await Task.WhenAll(taskA, taskB);
+            await Assert.That(results[0].Status).IsEqualTo(InlineApplyStatus.Applied);
+            await Assert.That(results[1].Status).IsEqualTo(InlineApplyStatus.Applied);
+            var text = File.ReadAllText(path);
+            await Assert.That(text).Contains("newA");
+            await Assert.That(text).Contains("newB");
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Test]
+    public async Task NotFoundWhenSourceChanged()
+    {
+        var path = WriteTemp(Utf8(source, bom: false));
+        try
+        {
+            var result = InlineApplier.Apply(new(path, 3, "\"gone-expression\"", "new"));
+            await Assert.That(result.Status).IsEqualTo(InlineApplyStatus.NotFound);
+            await Assert.That(result.Message!).Contains("Re-run the test");
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+}
+
+public class InlinePatchFileTests
+{
+    [Test]
+    public async Task RoundTrip()
+    {
+        var patch = new InlinePatch(@"C:\proj\Tests.cs", 42, "\"\"\"\nold\n\"\"\"", "line1\nline2");
+        var path = Path.Combine(Path.GetTempPath(), $"InlinePatchFileTests_{Guid.NewGuid():N}.inlinepatch");
+        try
+        {
+            InlinePatchFile.Write(path, patch);
+            var read = InlinePatchFile.TryRead(path, out var result);
+            await Assert.That(read).IsTrue();
+            await Assert.That(result!.SourceFile).IsEqualTo(patch.SourceFile);
+            await Assert.That(result.LineHint).IsEqualTo(42);
+            await Assert.That(result.OriginalExpression).IsEqualTo(patch.OriginalExpression);
+            await Assert.That(result.NewContent).IsEqualTo(patch.NewContent);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Test]
+    public async Task RoundTripNullExpression()
+    {
+        var patch = new InlinePatch("Tests.cs", 1, null, "content");
+        var path = Path.Combine(Path.GetTempPath(), $"InlinePatchFileTests_{Guid.NewGuid():N}.inlinepatch");
+        try
+        {
+            InlinePatchFile.Write(path, patch);
+            var read = InlinePatchFile.TryRead(path, out var result);
+            await Assert.That(read).IsTrue();
+            await Assert.That(result!.OriginalExpression).IsNull();
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
+    [Test]
+    public async Task MissingFileFails()
+    {
+        var read = InlinePatchFile.TryRead(Path.Combine(Path.GetTempPath(), "missing.inlinepatch"), out _);
+        await Assert.That(read).IsFalse();
+    }
+
+    [Test]
+    public async Task GarbageFails()
+    {
+        var read = InlinePatchFile.TryParse("not a patch", out _);
+        await Assert.That(read).IsFalse();
+    }
+
+    [Test]
+    public async Task WrongVersionFails()
+    {
+        var read = InlinePatchFile.TryParse("version: 2\nsourceFile: x\nlineHint: 1\noriginalExpression:\nnewContent: YQ==\n", out _);
+        await Assert.That(read).IsFalse();
+    }
+}