coplaydev--unity-mcp/TestProjects/UnityMCPTests/Assets/Tests/EditMode/Tools/ManageScriptDelimiterTests.cs

using System;
using System.Reflection;
using NUnit.Framework;
using UnityEngine;
using MCPForUnity.Editor.Tools;

namespace MCPForUnityTests.Editor.Tools
{
    /// <summary>
    /// Tests for ManageScript delimiter-checking and token-finding logic,
    /// specifically covering C# string variants that the old lexer missed:
    /// verbatim strings, interpolated strings, raw string literals.
    /// </summary>
    public class ManageScriptDelimiterTests
    {
        // ── CheckBalancedDelimiters ──────────────────────────────────────

        [Test]
        public void CheckBalancedDelimiters_VerbatimString_WithBackslashes()
        {
            // @"C:\Users\file" — backslashes are NOT escape chars in verbatim strings
            string code = "class C { string s = @\"C:\\Users\\file\"; }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Verbatim string with backslashes should not break delimiter balance");
        }

        [Test]
        public void CheckBalancedDelimiters_VerbatimString_DoubledQuotes()
        {
            // @"He said ""hello""" — doubled quotes are the escape in verbatim strings
            string code = "class C { string s = @\"He said \"\"hello\"\"\"; }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Verbatim string with doubled quotes should not break delimiter balance");
        }

        [Test]
        public void CheckBalancedDelimiters_InterpolatedString_WithBraces()
        {
            // $"Value: {x}" — the { } are interpolation holes, not real braces
            string code = "class C { void M() { int x = 1; string s = $\"Value: {x}\"; } }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Interpolated string braces should not be counted as delimiters");
        }

        [Test]
        public void CheckBalancedDelimiters_InterpolatedVerbatim_Combined()
        {
            // $@"Path: {dir}\file" — interpolated + verbatim combined
            string code = "class C { void M() { string dir = \"d\"; string s = $@\"Path: {dir}\\file\"; } }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Interpolated verbatim string should not break delimiter balance");
        }

        [Test]
        public void CheckBalancedDelimiters_NestedInterpolation()
        {
            // $"Outer {$"Inner {x}"}" — nested interpolated strings
            string code = "class C { void M() { int x = 1; string s = $\"Outer {$\"Inner {x}\"}\"; } }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Nested interpolated strings should not break delimiter balance");
        }

        [Test]
        public void CheckBalancedDelimiters_RawStringLiteral()
        {
            // C# 11 raw string literal: """{ }"""
            string code = "class C { string s = \"\"\"\n{ }\n\"\"\"; }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Raw string literal braces should not be counted as delimiters");
        }

        [Test]
        public void CheckBalancedDelimiters_MultilineVerbatimString()
        {
            // Verbatim string spanning multiple lines with braces
            string code = "class C { string s = @\"line1\n{ }\"; }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Multiline verbatim string with braces should not break balance");
        }

        [Test]
        public void CheckBalancedDelimiters_InterpolatedEscapedBraces()
        {
            // $"literal {{braces}}" — escaped braces in interpolated string
            string code = "class C { string s = $\"literal {{braces}}\"; }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Escaped braces in interpolated strings should not break balance");
        }

        [Test]
        public void CheckBalancedDelimiters_InterpolatedRawString()
        {
            // $"""...{expr}...""" — interpolated raw string literal (C# 11)
            string code = "class C { void M() { int x = 1; string s = $\"\"\"\n    Hello {x}\n    \"\"\"; } }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Interpolated raw string should not break delimiter balance");
        }

        [Test]
        public void CheckBalancedDelimiters_MultiDollarRawString()
        {
            // $$"""...{{expr}}...""" — multi-dollar interpolated raw string
            string code = "class C { void M() { int x = 1; string s = $$\"\"\"\n    {literal} {{x}}\n    \"\"\"; } }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Multi-dollar raw string should not break delimiter balance");
        }

        [Test]
        public void CheckBalancedDelimiters_BracesInComments_Ignored()
        {
            string code = "class C {\n// {\n/* { */\nvoid M() { }\n}";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Braces in comments should be ignored");
        }

        [Test]
        public void CheckBalancedDelimiters_BracesInRegularStrings_Ignored()
        {
            string code = "class C { string s = \"{ }\"; }";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Braces in regular strings should be ignored");
        }

        [Test]
        public void CheckBalancedDelimiters_ActuallyUnbalanced_ReturnsFalse()
        {
            string code = "class C { void M() { }";
            Assert.IsFalse(CallCheckBalancedDelimiters(code, out _, out _),
                "Actually unbalanced code should return false");
        }

        [Test]
        public void CheckBalancedDelimiters_ExtraClosingBrace_ReturnsFalse()
        {
            string code = "class C { } }";
            Assert.IsFalse(CallCheckBalancedDelimiters(code, out _, out _),
                "Extra closing brace should return false");
        }

        [Test]
        public void CheckBalancedDelimiters_RealWorldUnityScript()
        {
            string code = @"using UnityEngine;

public class PlayerHUD : MonoBehaviour
{
    private int score;
    private string playerName;

    void Start()
    {
        score = 0;
        playerName = ""Player"";
    }

    void OnGUI()
    {
        string label = $""Score: {score}"";
        string path = @""C:\Games\SaveData"";
        string msg = $@""Player {playerName} at path {path}"";
        Debug.Log($""HUD initialized for {playerName} with score {score}"");
        Debug.Log(""Literal {{braces}}"");
    }
}";
            Assert.IsTrue(CallCheckBalancedDelimiters(code, out _, out _),
                "Real-world Unity script with interpolated/verbatim strings should pass");
        }

        // ── IndexOfClassToken ────────────────────────────────────────────

        [Test]
        public void IndexOfClassToken_FindsClass_NormalCode()
        {
            string code = "public class Foo { }";
            int idx = CallIndexOfClassToken(code, "Foo");
            Assert.GreaterOrEqual(idx, 0, "Should find class Foo in normal code");
        }

        [Test]
        public void IndexOfClassToken_SkipsClassInComment()
        {
            string code = "// class Foo\npublic class Real { }";
            int idx = CallIndexOfClassToken(code, "Foo");
            Assert.AreEqual(-1, idx, "Should not find 'class Foo' inside a comment");
        }

        [Test]
        public void IndexOfClassToken_SkipsClassInString()
        {
            string code = "class Real { string s = \"class Foo { }\"; }";
            int idx = CallIndexOfClassToken(code, "Foo");
            Assert.AreEqual(-1, idx, "Should not find 'class Foo' inside a string literal");
        }

        [Test]
        public void IndexOfClassToken_FindsSecondClass_WhenFirstInComment()
        {
            string code = "// class Fake\npublic class Real { }";
            int idx = CallIndexOfClassToken(code, "Real");
            Assert.GreaterOrEqual(idx, 0, "Should find class Real even when a commented class precedes it");
        }

        // ── Reflection helpers ───────────────────────────────────────────

        private static bool CallCheckBalancedDelimiters(string text, out int line, out char expected)
        {
            line = 0;
            expected = '\0';

            var method = typeof(ManageScript).GetMethod("CheckBalancedDelimiters",
                BindingFlags.NonPublic | BindingFlags.Static);
            Assert.IsNotNull(method, "CheckBalancedDelimiters method should exist");

            var parameters = new object[] { text, 0, '\0' };
            var result = (bool)method.Invoke(null, parameters);
            line = (int)parameters[1];
            expected = (char)parameters[2];
            return result;
        }

        private static int CallIndexOfClassToken(string source, string className)
        {
            var method = typeof(ManageScript).GetMethod("IndexOfClassToken",
                BindingFlags.NonPublic | BindingFlags.Static);
            Assert.IsNotNull(method, "IndexOfClassToken method should exist");

            return (int)method.Invoke(null, new object[] { source, className });
        }
    }
}