public async Task WithTripleBraces()

in src/EditorFeatures/CSharpTest/ValidateFormatString/ValidateFormatStringTests.cs [316:749]
401 lines of code
18 McCabe index (conditional complexity)

        public async Task WithTripleBraces()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format("" {{{2}} This {1[||]} is {2} {{ my {0} test }}"", ""teststring1"", ""teststring2"", ""teststring3"");
    }     
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task NamedParameters()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(arg0: ""test"", arg1: ""also"", format: ""This {0} {[||]1} works""); 
    }     
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task NamedParametersWithIFormatProvider()
        {
            await TestDiagnosticMissingAsync(@" using System.Globalization;
class Program
{
    static void Main(string[] args)
    {
        string.Format(arg0: ""test"", provider: new CultureInfo(""pt-BR"", useUserOverride: false), format: ""This {0[||]} works""); 
    }     
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task NamespaceAliasForStringClass()
        {
            await TestDiagnosticMissingAsync(@" using stringAlias = System.String;
class Program
{
    static void Main(string[] args)
    {
        stringAlias.Format(""This {0[||]} works"", ""test""); 
    }     
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task MethodCallAsAnArgumentToAnotherMethod()
        {
            await TestDiagnosticMissingAsync(@" using System.IO;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(string.Format(format: ""This {0[||]} works"", arg0:""test"")); 
    }
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task VerbatimMultipleLines()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(@""This {0} 
{1} {2[||]} works"", ""multiple"", ""line"", ""test"")); 
    }
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task Interpolated()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        var Name = ""Peter"";
        var Age = 30;
       
        string.Format($""{Name,[||] 20} is {Age:D3} ""); 
    }
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task Empty()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(""[||]""); 
    }
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task LeftParenOnly()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format([||]; 
    }
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task ParenthesesOnly()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format([||]); 
    }
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task EmptyString()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(""[||]""); 
    }
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task FormatOnly_NoStringDot()
        {
            await TestDiagnosticMissingAsync(@" using static System.String
class Program
{
    static void Main(string[] args)
    {
        Format(""[||]""); 
    }
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task NamedParameters_BlankName()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format( : ""value""[||])); 
    }     
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task DuplicateNamedArgs()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(format:""This [||] "", format:"" test ""); 
    }     
}");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task GenericIdentifier()
        {
            await TestDiagnosticMissingAsync(@"using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace Generics_CSharp
{
    public class String<T> 
    {
        public void Format<T>(string teststr)
        {
            Console.WriteLine(teststr);
        }
    }
    
    class Generics
    {
        static void Main(string[] args)
        {
            String<int> testList = new String<int>();
            testList.Format<int>(""Test[||]String"");
        }
    }
}
");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task ClassNamedString()
        {
            await TestDiagnosticMissingAsync(@"using System;

namespace System
{
    public class String
    {
        public static String Format(string format, object arg0) { return new String(); }
    }
}

class C
{
    static void Main(string[] args)
    {
        Console.WriteLine(String.Format(""test {[||]5} "", 1));
    }
}
");
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task WarningTurnedOff()
        {
            await TestDiagnosticMissingAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(""This {1[||]} works"", ""test""); 
    }   
}
", new TestParameters(options: CSharpOptionOffVBOptionOn()));
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task WarningTurnedOn()
        {
            await TestDiagnosticInfoAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(""This [|{1}|] is my test"", ""teststring1"");
    }     
}",
                options: CSharpOptionOnVBOptionOff(),
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task OnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(""This [|{1}|] is my test"", ""teststring1"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task TwoPlaceholdersWithOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(""This [|{2}|] is my test"", ""teststring1"", ""teststring2"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task ThreePlaceholdersWithOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(""This{0}{1}{2}[|{3}|] is my test"", ""teststring1"", ""teststring2"", ""teststring3"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task FourPlaceholdersWithOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format(""This{0}{1}{2}{3}[|{4}|] is my test"", ""teststring1"", ""teststring2"", 
            ""teststring3"", ""teststring4"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task iFormatProviderAndOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" using System.Globalization; 
class Program
{
    static void Main(string[] args)
    {
        string.Format(new CultureInfo(""pt-BR"", useUserOverride: false), ""This [|{1}|] is my test"", ""teststring1"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task iFormatProviderAndTwoPlaceholdersWithOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" using System.Globalization; 
class Program
{
    static void Main(string[] args)
    {
        string.Format(new CultureInfo(""pt-BR"", useUserOverride: false), ""This [|{2}|] is my test"", ""teststring1"", ""teststring2"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task IFormatProviderAndThreePlaceholdersWithOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" using System.Globalization; 
class Program
{
    static void Main(string[] args)
    {
        string.Format(new CultureInfo(""pt-BR"", useUserOverride: false), ""This{0}{1}{2}[|{3}|] is my test"", ""teststring1"", 
            ""teststring2"", ""teststring3"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task IFormatProviderAndFourPlaceholdersWithOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" using System.Globalization; 
class Program
{
    static void Main(string[] args)
    {
        string.Format(new CultureInfo(""pt-BR"", useUserOverride: false), ""This{0}{1}{2}{3}[|{4}|] is my test"", ""teststring1"", 
            ""teststring2"", ""teststring3"", ""teststring4"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task PlaceholderAtBeginningWithOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format( ""[|{1}|]is my test"", ""teststring1"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task PlaceholderAtEndWithOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format( ""is my test [|{2}|]"", ""teststring1"", ""teststring2"");
    }     
}",
                options: null,
                diagnosticId: IDEDiagnosticIds.ValidateFormatStringDiagnosticID,
                diagnosticSeverity: DiagnosticSeverity.Warning,
                diagnosticMessage: FeaturesResources.Format_string_contains_invalid_placeholder);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
        public async Task DoubleBracesAtBeginningWithOnePlaceholderOutOfBounds()
        {
            await TestDiagnosticInfoAsync(@" class Program
{
    static void Main(string[] args)
    {
        string.Format( ""}}is my test [|{2}|]"", ""teststring1"", ""teststring2"");
    }     
}",