// 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 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");
        }
    }
}