src/EditorFeatures/Test/CodeGeneration/ExpressionGenerationTests.cs - main - githubmirror/roslyn

src/EditorFeatures/Test/CodeGeneration/ExpressionGenerationTests.cs
461 строка13 KB
Cyrus Najmabadi
Update tests
20 сен 2025, 09:37
20 сен 2025, 09:37de54cf4
// 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 sealed class ExpressionGenerationTests : AbstractCodeGenerationTests
{
    [Fact]
    public void TestFalseExpression()
        => Test(
            f => f.FalseLiteralExpression(),
            cs: "false",
            csSimple: "false",
            vb: "False",
            vbSimple: "False");

    [Fact]
    public void TestTrueExpression()
        => Test(
            f => f.TrueLiteralExpression(),
            cs: "true",
            csSimple: "true",
            vb: "True",
            vbSimple: "True");

    [Fact]
    public void TestNullExpression()
        => Test(
            f => f.NullLiteralExpression(),
            cs: "null",
            csSimple: "null",
            vb: "Nothing",
            vbSimple: "Nothing");

    [Fact]
    public void TestThisExpression()
        => Test(
            f => f.ThisExpression(),
            cs: "this",
            csSimple: "this",
            vb: "Me",
            vbSimple: "Me");

    [Fact]
    public void TestBaseExpression()
        => Test(
            f => f.BaseExpression(),
            cs: "base",
            csSimple: "base",
            vb: "MyBase",
            vbSimple: "MyBase");

    [Fact]
    public void TestInt32LiteralExpression0()
        => Test(
            f => f.LiteralExpression(0),
            cs: "0",
            csSimple: "0",
            vb: "0",
            vbSimple: "0");

    [Fact]
    public void TestInt32LiteralExpression1()
        => Test(
            f => f.LiteralExpression(1),
            cs: "1",
            csSimple: "1",
            vb: "1",
            vbSimple: "1");

    [Fact]
    public void TestInt64LiteralExpression0()
        => Test(
            f => f.LiteralExpression(0L),
            cs: "0L",
            csSimple: "0L",
            vb: "0L",
            vbSimple: "0L");

    [Fact]
    public void TestInt64LiteralExpression1()
        => Test(
            f => f.LiteralExpression(1L),
            cs: "1L",
            csSimple: "1L",
            vb: "1L",
            vbSimple: "1L");

    [Fact]
    public void TestSingleLiteralExpression0()
        => Test(
            f => f.LiteralExpression(0.0f),
            cs: "0F",
            csSimple: "0F",
            vb: "0F",
            vbSimple: "0F");

    [Fact]
    public void TestSingleLiteralExpression1()
        => Test(
            f => f.LiteralExpression(0.5F),
            cs: "0.5F",
            csSimple: "0.5F",
            vb: "0.5F",
            vbSimple: "0.5F");

    [Fact]
    public void TestDoubleLiteralExpression0()
        => Test(
            f => f.LiteralExpression(0.0d),
            cs: "0D",
            csSimple: "0D",
            vb: "0R",
            vbSimple: "0R");

    [Fact]
    public void TestDoubleLiteralExpression1()
        => Test(
            f => f.LiteralExpression(0.5D),
            cs: "0.5D",
            csSimple: "0.5D",
            vb: "0.5R",
            vbSimple: "0.5R");

    [Fact]
    public void TestAddExpression1()
        => Test(
            f => f.AddExpression(
                f.LiteralExpression(1),
                f.LiteralExpression(2)),
            cs: "(1) + (2)",
            csSimple: "1 + 2",
            vb: "(1) + (2)",
            vbSimple: "1 + 2");

    [Fact]
    public void TestAddExpression2()
        => Test(
            f => f.AddExpression(
                f.LiteralExpression(1),
                f.AddExpression(
                    f.LiteralExpression(2),
                    f.LiteralExpression(3))),
            cs: "(1) + ((2) + (3))",
            csSimple: "1 + 2 + 3",
            vb: "(1) + ((2) + (3))",
            vbSimple: "1 + (2 + 3)");

    [Fact]
    public void TestAddExpression3()
        => Test(
            f => f.AddExpression(
                f.AddExpression(
                    f.LiteralExpression(1),
                    f.LiteralExpression(2)),
                f.LiteralExpression(3)),
            cs: "((1) + (2)) + (3)",
            csSimple: "1 + 2 + 3",
            vb: "((1) + (2)) + (3)",
            vbSimple: "1 + 2 + 3");

    [Fact]
    public void TestMultiplyExpression1()
        => Test(
            f => f.MultiplyExpression(
                f.LiteralExpression(1),
                f.LiteralExpression(2)),
            cs: "(1) * (2)",
            csSimple: "1 * 2",
            vb: "(1) * (2)",
            vbSimple: "1 * 2");

    [Fact]
    public void TestMultiplyExpression2()
        => Test(
            f => f.MultiplyExpression(
                f.LiteralExpression(1),
                f.MultiplyExpression(
                    f.LiteralExpression(2),
                    f.LiteralExpression(3))),
            cs: "(1) * ((2) * (3))",
            csSimple: "1 * 2 * 3",
            vb: "(1) * ((2) * (3))",
            vbSimple: "1 * (2 * 3)");

    [Fact]
    public void TestMultiplyExpression3()
        => Test(
            f => f.MultiplyExpression(
                f.MultiplyExpression(
                    f.LiteralExpression(1),
                    f.LiteralExpression(2)),
                f.LiteralExpression(3)),
            cs: "((1) * (2)) * (3)",
            csSimple: "1 * 2 * 3",
            vb: "((1) * (2)) * (3)",
            vbSimple: "1 * 2 * 3");

    [Fact]
    public void TestBinaryAndExpression1()
        => Test(
            f => f.BitwiseAndExpression(
                f.LiteralExpression(1),
                f.LiteralExpression(2)),
            cs: "(1) & (2)",
            csSimple: "1 & 2",
            vb: "(1) And (2)",
            vbSimple: "1 And 2");

    [Fact]
    public void TestBinaryOrExpression1()
        => Test(
            f => f.BitwiseOrExpression(
                f.LiteralExpression(1),
                f.LiteralExpression(2)),
            cs: "(1) | (2)",
            csSimple: "1 | 2",
            vb: "(1) Or (2)",
            vbSimple: "1 Or 2");

    [Fact]
    public void TestLogicalAndExpression1()
        => Test(
            f => f.LogicalAndExpression(
                f.LiteralExpression(1),
                f.LiteralExpression(2)),
            cs: "(1) && (2)",
            csSimple: "1 && 2",
            vb: "(1) AndAlso (2)",
            vbSimple: "1 AndAlso 2");

    [Fact]
    public void TestLogicalOrExpression1()
        => Test(
            f => f.LogicalOrExpression(
                f.LiteralExpression(1),
                f.LiteralExpression(2)),
            cs: "(1) || (2)",
            csSimple: "1 || 2",
            vb: "(1) OrElse (2)",
            vbSimple: "1 OrElse 2");

    [Fact]
    public void TestMemberAccess1()
        => Test(
            f => f.MemberAccessExpression(
                f.IdentifierName("E"),
                f.IdentifierName("M")),
            cs: "E.M",
            csSimple: "E.M",
            vb: "E.M",
            vbSimple: "E.M");

    [Fact]
    public void TestConditionalExpression1()
        => Test(
            f => f.ConditionalExpression(
                f.IdentifierName("E"),
                f.IdentifierName("T"),
                f.IdentifierName("F")),
            cs: "E ? T : F",
            csSimple: "E ? T : F",
            vb: "If(E, T, F)",
            vbSimple: "If(E, T, F)");

    [Fact]
    public void TestConditionalAccessExpression1()
        => Test(
            f => f.ConditionalAccessExpression(
                f.IdentifierName("E"),
                f.MemberBindingExpression(
                    f.IdentifierName("T"))),
            cs: "E?.T",
            csSimple: "E?.T",
            vb: "E?.T",
            vbSimple: "E?.T");

    [Fact]
    public void TestConditionalAccessExpression2()
        => Test(
            f => f.ConditionalAccessExpression(
                f.IdentifierName("E"),
                f.ElementBindingExpression(
                    f.Argument(f.IdentifierName("T")))),
            cs: "E?[T]",
            csSimple: "E?[T]",
            vb: "E?(T)",
            vbSimple: "E?(T)");

    [Fact]
    public void TestInvocation1()
        => Test(
            f => f.InvocationExpression(
                f.IdentifierName("E")),
            cs: "E()",
            csSimple: "E()",
            vb: "E()",
            vbSimple: "E()");

    [Fact]
    public void TestInvocation2()
        => Test(
            f => f.InvocationExpression(
                f.IdentifierName("E"),
                f.Argument(f.IdentifierName("a"))),
            cs: "E(a)",
            csSimple: "E(a)",
            vb: "E(a)",
            vbSimple: "E(a)");

    [Fact]
    public void TestInvocation3()
        => Test(
            f => f.InvocationExpression(
                f.IdentifierName("E"),
                f.Argument("n", RefKind.None, f.IdentifierName("a"))),
            cs: "E(n: a)",
            csSimple: "E(n: a)",
            vb: "E(n:=a)",
            vbSimple: "E(n:=a)");

    [Fact]
    public void TestInvocation4()
        => Test(
            f => f.InvocationExpression(
                f.IdentifierName("E"),
                f.Argument(null, RefKind.Out, f.IdentifierName("a")),
                f.Argument(null, RefKind.Ref, f.IdentifierName("b"))),
            cs: "E(out a, ref b)",
            csSimple: "E(out a, ref b)",
            vb: "E(a, b)",
            vbSimple: "E(a, b)");

    [Fact]
    public void TestInvocation5()
        => Test(
            f => f.InvocationExpression(
                f.IdentifierName("E"),
                f.Argument("n1", RefKind.Out, f.IdentifierName("a")),
                f.Argument("n2", RefKind.Ref, f.IdentifierName("b"))),
            cs: "E(n1: out a, n2: ref b)",
            csSimple: "E(n1: out a, n2: ref b)",
            vb: "E(n1:=a, n2:=b)",
            vbSimple: "E(n1:=a, n2:=b)");

    [Fact]
    public void TestElementAccess1()
        => Test(
            f => f.ElementAccessExpression(
                f.IdentifierName("E")),
            cs: "E[]",
            csSimple: "E[]",
            vb: "E()",
            vbSimple: "E()");

    [Fact]
    public void TestElementAccess2()
        => Test(
            f => f.ElementAccessExpression(
                f.IdentifierName("E"),
                f.Argument(f.IdentifierName("a"))),
            cs: "E[a]",
            csSimple: "E[a]",
            vb: "E(a)",
            vbSimple: "E(a)");

    [Fact]
    public void TestElementAccess3()
        => Test(
            f => f.ElementAccessExpression(
                f.IdentifierName("E"),
                f.Argument("n", RefKind.None, f.IdentifierName("a"))),
            cs: "E[n: a]",
            csSimple: "E[n: a]",
            vb: "E(n:=a)",
            vbSimple: "E(n:=a)");

    [Fact]
    public void TestElementAccess4()
        => Test(
            f => f.ElementAccessExpression(
                f.IdentifierName("E"),
                f.Argument(null, RefKind.Out, f.IdentifierName("a")),
                f.Argument(null, RefKind.Ref, f.IdentifierName("b"))),
            cs: "E[out a, ref b]",
            csSimple: "E[out a, ref b]",
            vb: "E(a, b)",
            vbSimple: "E(a, b)");

    [Fact]
    public void TestElementAccess5()
        => Test(
            f => f.ElementAccessExpression(
                f.IdentifierName("E"),
                f.Argument("n1", RefKind.Out, f.IdentifierName("a")),
                f.Argument("n2", RefKind.Ref, f.IdentifierName("b"))),
            cs: "E[n1: out a, n2: ref b]",
            csSimple: "E[n1: out a, n2: ref b]",
            vb: "E(n1:=a, n2:=b)",
            vbSimple: "E(n1:=a, n2:=b)");

    [Fact]
    public void TestIsExpression()
        => Test(
            f => f.IsTypeExpression(
                f.IdentifierName("a"),
                CreateClass("SomeType")),
            cs: "a is SomeType",
            csSimple: "a is SomeType",
            vb: "TypeOf a Is SomeType",
            vbSimple: "TypeOf a Is SomeType");

    [Fact]
    public void TestAsExpression()
        => Test(
            f => f.TryCastExpression(
                f.IdentifierName("a"),
                CreateClass("SomeType")),
            cs: "a as SomeType",
            csSimple: "a as SomeType",
            vb: "TryCast(a, SomeType)",
            vbSimple: "TryCast(a, SomeType)");

    [Fact]
    public void TestNotExpression()
        => Test(
            f => f.LogicalNotExpression(
                f.IdentifierName("a")),
            cs: "!a",
            csSimple: "!a",
            vb: "Not a",
            vbSimple: "Not a");

    [Fact]
    public void TestCastExpression()
        => Test(
            f => f.CastExpression(
                CreateClass("SomeType"),
                f.IdentifierName("a")),
            cs: "(SomeType)a",
            csSimple: "(SomeType)a",
            vb: "DirectCast(a, SomeType)",
            vbSimple: "DirectCast(a, SomeType)");

    [Fact]
    public void TestNegateExpression()
        => Test(
            f => f.NegateExpression(
                f.IdentifierName("a")),
            cs: "-a",
            csSimple: "-a",
            vb: "-a",
            vbSimple: "-a");
}