// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
#nullable disable
 
using Microsoft.CodeAnalysis.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.UnitTests.CodeGeneration;
 
[Trait(Traits.Feature, Traits.Features.CodeGeneration)]
public class NameGenerationTests : AbstractCodeGenerationTests
{
    [Fact]
    public void TestIdentifierName()
    {
        Test(
            f => f.IdentifierName("a"),
            cs: "a",
            csSimple: "a",
            vb: "a",
            vbSimple: "a");
    }
 
    [Fact]
    public void TestIdentifierNameCSharpKeyword()
    {
        Test(
            f => f.IdentifierName("int"),
            cs: "@int",
            csSimple: "@int",
            vb: "int",
            vbSimple: "int");
    }
 
    [Fact]
    public void TestIdentifierNameVisualBasicKeyword()
    {
        Test(
            f => f.IdentifierName("Integer"),
            cs: "Integer",
            csSimple: "Integer",
            vb: "[Integer]",
            vbSimple: "[Integer]");
    }
 
    [Fact]
    public void TestGenericName1()
    {
        Test(
            f => f.GenericName("Outer", CreateClass("Inner1")),
            cs: "Outer<Inner1>",
            csSimple: null,
            vb: "Outer(Of Inner1)",
            vbSimple: null);
    }
 
    [Fact]
    public void TestGenericName2()
    {
        Test(
            f => f.GenericName("Outer", CreateClass("Inner1"), CreateClass("Inner2")),
            cs: "Outer<Inner1, Inner2>",
            csSimple: null,
            vb: "Outer(Of Inner1, Inner2)",
            vbSimple: null);
    }
 
    [Fact]
    public void TestGenericNameCSharpKeyword()
    {
        Test(
            f => f.GenericName("int", CreateClass("string"), CreateClass("bool")),
            cs: "@int<@string, @bool>",
            csSimple: null,
            vb: "int(Of [string], bool)",
            vbSimple: null);
    }
 
    [Fact]
    public void TestGenericNameVisualBasicKeyword()
    {
        Test(
            f => f.GenericName("Integer", CreateClass("String"), CreateClass("Boolean")),
            cs: "Integer<String, Boolean>",
            csSimple: null,
            vb: "[Integer](Of [String], [Boolean])",
            vbSimple: null);
    }
 
    [Fact]
    public void TestQualifiedName1()
    {
        Test(
            f => f.QualifiedName(f.IdentifierName("Outer"), f.IdentifierName("Inner1")),
            cs: "Outer.Inner1",
            csSimple: "Outer.Inner1",
            vb: "Outer.Inner1",
            vbSimple: "Outer.Inner1");
    }
 
    [Fact]
    public void TestQualifiedNameCSharpKeywords1()
    {
        Test(
            f => f.QualifiedName(f.IdentifierName("int"), f.IdentifierName("string")),
            cs: "@int.@string",
            csSimple: "@int.@string",
            vb: "int.[string]",
            vbSimple: "int.string");
    }
 
    [Fact]
    public void TestQualifiedNameVBKeywords1()
    {
        Test(
            f => f.QualifiedName(f.IdentifierName("Integer"), f.IdentifierName("String")),
            cs: "Integer.String",
            csSimple: "Integer.String",
            vb: "[Integer].[String]",
            vbSimple: "Integer.String");
    }
 
    [Fact]
    public void TestQualifiedGenericName1()
    {
        Test(
            f => f.QualifiedName(
                f.IdentifierName("One"),
                f.GenericName("Outer",
                    CreateClass("Inner1"),
                    CreateClass("Inner2"))),
            cs: "One.Outer<Inner1, Inner2>",
            csSimple: "One.Outer<Inner1, Inner2>",
            vb: "One.Outer(Of Inner1, Inner2)",
            vbSimple: "One.Outer(Of Inner1, Inner2)");
    }
 
    [Fact]
    public void TestQualifiedGenericName2()
    {
        Test(
            f => f.QualifiedName(
                f.GenericName("Outer",
                    CreateClass("Inner1"),
                    CreateClass("Inner2")),
                f.IdentifierName("One")),
            cs: "Outer<Inner1, Inner2>.One",
            csSimple: "Outer<Inner1, Inner2>.One",
            vb: "Outer(Of Inner1, Inner2).One",
            vbSimple: "Outer(Of Inner1, Inner2).One");
    }
}