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

src/EditorFeatures/Test/CodeGeneration/ExpressionPrecedenceGenerationTests.cs
365 строк12 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 ExpressionPrecedenceGenerationTests : AbstractCodeGenerationTests
{
    [Fact]
    public void TestAddMultiplyPrecedence1()
        => Test(
            f => f.MultiplyExpression(
                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 TestAddMultiplyPrecedence2()
        => Test(
            f => f.AddExpression(
                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 TestAddMultiplyPrecedence3()
        => Test(
            f => f.MultiplyExpression(
                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 TestAddMultiplyPrecedence4()
        => Test(
            f => f.AddExpression(
                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 TestBitwiseAndOrPrecedence1()
        => Test(
            f => f.BitwiseAndExpression(
                f.BitwiseOrExpression(
                    f.LiteralExpression(1),
                    f.LiteralExpression(2)),
                f.LiteralExpression(3)),
            cs: "((1) | (2)) & (3)",
            csSimple: "(1 | 2) & 3",
            vb: "((1) Or (2)) And (3)",
            vbSimple: "(1 Or 2) And 3");

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

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

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

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

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

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

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

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

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

    [Fact]
    public void TestConditionalExpression2()
        => Test(
            f => f.AddExpression(
                    f.ConditionalExpression(
                        f.IdentifierName("E1"),
                        f.IdentifierName("T1"),
                        f.IdentifierName("F1")),
                    f.ConditionalExpression(
                        f.IdentifierName("E2"),
                        f.IdentifierName("T2"),
                        f.IdentifierName("F2"))),
            cs: "(E1 ? T1 : F1) + (E2 ? T2 : F2)",
            csSimple: "(E1 ? T1 : F1) + (E2 ? T2 : F2)",
            vb: null,
            vbSimple: null);

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

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

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

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

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

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

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

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

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

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

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

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