File: Debugging\ProximityExpressionsGetterTests.Statements.cs
Web Access
Project: src\src\EditorFeatures\CSharpTest\Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests.csproj (Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests)
// 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.CSharp.Debugging;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Debugging;
 
[Trait(Traits.Feature, Traits.Features.DebuggingProximityExpressions)]
public partial class ProximityExpressionsGetterTests
{
    [Fact]
    public void TestAtStartOfStatement_0()
    {
        //// Line 11
 
        ////         private static string ConvertToString(ExpressionSyntax expression)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 347, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_1()
    {
        //// Line 13
 
        ////             // TODO(cyrusn): Should we strip out comments?
        ////             return expression.GetFullText();
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 422, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_2()
    {
        //// Line 17
 
        ////         private static void CollectExpressionTerms(int position, ExpressionSyntax expression, List<string> terms)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 592, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_3()
    {
        //// Line 19
 
        ////             // Check here rather than at all the call sites...
        ////             if (expression == null)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 671, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "position", "terms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_4()
    {
        //// Line 20
 
        ////             if (expression == null)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 708, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_5()
    {
        //// Line 21
 
        ////             {
        ////                 return;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 727, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_6()
    {
        //// Line 26
 
        ////             // of this expression as a whole.
        ////             var expressionType = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 908, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expression", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_7()
    {
        //// Line 27
 
        ////             var expressionType = ExpressionType.Invalid;
        ////             CollectExpressionTerms(position, expression, terms, ref expressionType);
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 966, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectExpressionTerms", "ExpressionType", "ExpressionType.Invalid"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_8()
    {
        //// Line 29
 
        //// 
        ////             if ((expressionType & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 1054, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "expression", "terms", "expressionType", "CollectExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_9()
    {
        //// Line 30
 
        ////             if ((expressionType & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 1144, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_10()
    {
        //// Line 33
 
        ////                 // term table
        ////                 terms.Add(ConvertToString(expression));
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 1282, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["terms", "expressionType", "expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_11()
    {
        //// Line 38
 
        ////         private static void CollectExpressionTerms(int position, ExpressionSyntax expression, IList<string> terms, ref ExpressionType expressionType)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 1510, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_12()
    {
        //// Line 40
 
        ////             // Check here rather than at all the call sites...
        ////             if (expression == null)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 1589, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "position", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_13()
    {
        //// Line 41
 
        ////             if (expression == null)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 1626, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_14()
    {
        //// Line 42
 
        ////             {
        ////                 return;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 1645, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_15()
    {
        //// Line 45
 
        //// 
        ////             switch (expression.Kind)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 1683, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_16()
    {
        //// Line 52
 
        ////                     // want "this" showing up in the auto's window twice.
        ////                     expressionType = ExpressionType.ValidExpression;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 2105, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_17()
    {
        //// Line 53
 
        ////                     expressionType = ExpressionType.ValidExpression;
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 2175, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_18()
    {
        //// Line 57
 
        ////                     // Name nodes are always valid terms
        ////                     expressionType = ExpressionType.ValidTerm;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 2313, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm", "expression", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_19()
    {
        //// Line 58
 
        ////                     expressionType = ExpressionType.ValidTerm;
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 2377, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_20()
    {
        //// Line 69
 
        ////                     // on their own).
        ////                     expressionType = ExpressionType.ValidExpression;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 2985, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_21()
    {
        //// Line 70
 
        ////                     expressionType = ExpressionType.ValidExpression;
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 3055, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_22()
    {
        //// Line 76
 
        ////                     // extremely rare, so we allow for this since it's ok in the common case.
        ////                     CollectExpressionTerms(position, ((CastExpressionSyntax)expression).Expression, terms, ref expressionType);
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 3423, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "terms", "expressionType", "CollectExpressionTerms", "expression", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_23()
    {
        //// Line 77
 
        ////                     CollectExpressionTerms(position, ((CastExpressionSyntax)expression).Expression, terms, ref expressionType);
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 3552, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "position", "terms", "expressionType", "CollectExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_24()
    {
        //// Line 81
 
        ////                 case SyntaxKind.PointerMemberAccessExpression:
        ////                     CollectMemberAccessExpressionTerms(position, expression, terms, ref expressionType);
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 3704, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectMemberAccessExpressionTerms", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_25()
    {
        //// Line 82
 
        ////                     CollectMemberAccessExpressionTerms(position, expression, terms, ref expressionType);
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 3810, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectMemberAccessExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_26()
    {
        //// Line 85
 
        ////                 case SyntaxKind.ObjectCreationExpression:
        ////                     CollectObjectCreationExpressionTerms(position, expression, terms, ref expressionType);
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 3900, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectObjectCreationExpressionTerms", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_27()
    {
        //// Line 86
 
        ////                     CollectObjectCreationExpressionTerms(position, expression, terms, ref expressionType);
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4008, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectObjectCreationExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_28()
    {
        //// Line 89
 
        ////                 case SyntaxKind.ArrayCreationExpression:
        ////                     CollectArrayCreationExpressionTerms(position, expression, terms, ref expressionType);
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4097, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectArrayCreationExpressionTerms", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_29()
    {
        //// Line 90
 
        ////                     CollectArrayCreationExpressionTerms(position, expression, terms, ref expressionType);
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4204, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectArrayCreationExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_30()
    {
        //// Line 93
 
        ////                 case SyntaxKind.InvocationExpression:
        ////                     CollectInvocationExpressionTerms(position, expression, terms, ref expressionType);
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4290, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectInvocationExpressionTerms", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_31()
    {
        //// Line 94
 
        ////                     CollectInvocationExpressionTerms(position, expression, terms, ref expressionType);
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4394, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectInvocationExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_32()
    {
        //// Line 100
 
        ////             // This is a valid expression if it doesn't have obvious side effects (i.e. ++, --)
        ////             if (expression is PrefixUnaryExpressionSyntax)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4583, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax", "expression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_33()
    {
        //// Line 101
 
        ////             if (expression is PrefixUnaryExpressionSyntax)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4643, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_34()
    {
        //// Line 102
 
        ////             {
        ////                 CollectPrefixUnaryExpressionTerms(position, expression, terms, ref expressionType);
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4662, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPrefixUnaryExpressionTerms", "PrefixUnaryExpressionSyntax"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_35()
    {
        //// Line 103
 
        ////                 CollectPrefixUnaryExpressionTerms(position, expression, terms, ref expressionType);
        ////                 return;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4763, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPrefixUnaryExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_36()
    {
        //// Line 106
 
        //// 
        ////             if (expression is PostfixUnaryExpressionSyntax)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4801, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "PostfixUnaryExpressionSyntax", "PrefixUnaryExpressionSyntax"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_37()
    {
        //// Line 107
 
        ////             if (expression is PostfixUnaryExpressionSyntax)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4862, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "PostfixUnaryExpressionSyntax"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_38()
    {
        //// Line 108
 
        ////             {
        ////                 CollectPostfixUnaryExpressionTerms(position, expression, terms, ref expressionType);
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4881, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPostfixUnaryExpressionTerms", "PostfixUnaryExpressionSyntax"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_39()
    {
        //// Line 109
 
        ////                 CollectPostfixUnaryExpressionTerms(position, expression, terms, ref expressionType);
        ////                 return;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 4983, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPostfixUnaryExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_40()
    {
        //// Line 112
 
        //// 
        ////             if (expression is BinaryExpressionSyntax)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 5021, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "BinaryExpressionSyntax", "PostfixUnaryExpressionSyntax"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_41()
    {
        //// Line 113
 
        ////             if (expression is BinaryExpressionSyntax)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 5076, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "BinaryExpressionSyntax"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_42()
    {
        //// Line 114
 
        ////             {
        ////                 CollectBinaryExpressionTerms(position, expression, terms, ref expressionType);
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 5095, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectBinaryExpressionTerms", "BinaryExpressionSyntax"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_43()
    {
        //// Line 115
 
        ////                 CollectBinaryExpressionTerms(position, expression, terms, ref expressionType);
        ////                 return;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 5191, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectBinaryExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_44()
    {
        //// Line 118
 
        //// 
        ////             expressionType = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 5229, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "expression", "BinaryExpressionSyntax"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_45()
    {
        //// Line 122
 
        ////         private static void CollectMemberAccessExpressionTerms(int position, ExpressionSyntax expression, IList<string> terms, ref ExpressionType expressionType)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 5455, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_46()
    {
        //// Line 123
 
        ////         {
        ////             var flags = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 5470, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "flags", "position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_47()
    {
        //// Line 128
 
        ////             // So, we don't bother collecting anything from the RHS...
        ////             var memberAccess = (MemberAccessExpressionSyntax)expression;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 5765, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "(MemberAccessExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "memberAccess"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_48()
    {
        //// Line 129
 
        ////             var memberAccess = (MemberAccessExpressionSyntax)expression;
        ////             CollectExpressionTerms(position, memberAccess.Expression, terms, ref flags);
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 5839, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "memberAccess", "memberAccess.Expression", "terms", "flags", "CollectExpressionTerms", "expression", "(MemberAccessExpressionSyntax)expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_49()
    {
        //// Line 134
 
        ////             // add both 'a.b.c.d' and 'a.b.c', but not 'a.b' and 'a'.
        ////             if ((flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm &&
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 6170, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "position", "memberAccess", "memberAccess.Expression", "terms", "flags", "CollectExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_50()
    {
        //// Line 137
 
        ////                 !expression.IsParentKind(SyntaxKind.PointerMemberAccessExpression))
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 6418, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_51()
    {
        //// Line 138
 
        ////             {
        ////                 terms.Add(ConvertToString(memberAccess.Expression));
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 6437, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["flags", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_52()
    {
        //// Line 143
 
        ////             // expression, and its PARENT is not an invocation.
        ////             if ((flags & ExpressionType.ValidExpression) == ExpressionType.ValidExpression &&
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 6666, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression", "ExpressionType.ValidTerm", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_53()
    {
        //// Line 145
 
        ////                 !expression.IsParentKind(SyntaxKind.InvocationExpression))
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 6837, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_54()
    {
        //// Line 146
 
        ////             {
        ////                 expressionType = ExpressionType.ValidTerm;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 6856, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "expressionType", "ExpressionType.ValidTerm", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_55()
    {
        //// Line 149
 
        ////             else
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 6945, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_56()
    {
        //// Line 150
 
        ////             {
        ////                 expressionType = ExpressionType.ValidExpression;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 6964, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "expressionType", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_57()
    {
        //// Line 155
 
        ////         private static void CollectObjectCreationExpressionTerms(int position, ExpressionSyntax expression, IList<string> terms, ref ExpressionType expressionType)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 7215, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_58()
    {
        //// Line 159
 
        ////             // the sub arguments are valid terms.
        ////             expressionType = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 7451, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_59()
    {
        //// Line 161
 
        //// 
        ////             var objectionCreation = (ObjectCreationExpressionSyntax)expression;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 7507, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "(ObjectCreationExpressionSyntax)expression", "ExpressionType", "expressionType", "ExpressionType.Invalid", "objectionCreation"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_60()
    {
        //// Line 162
 
        ////             var objectionCreation = (ObjectCreationExpressionSyntax)expression;
        ////             if (objectionCreation.ArgumentListOpt != null)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 7588, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["objectionCreation", "objectionCreation.ArgumentListOpt", "expression", "(ObjectCreationExpressionSyntax)expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_61()
    {
        //// Line 163
 
        ////             if (objectionCreation.ArgumentListOpt != null)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 7648, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["objectionCreation", "objectionCreation.ArgumentListOpt"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_62()
    {
        //// Line 164
 
        ////             {
        ////                 var flags = ExpressionType.Invalid;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 7667, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "objectionCreation", "objectionCreation.ArgumentListOpt", "flags"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_63()
    {
        //// Line 165
 
        ////                 var flags = ExpressionType.Invalid;
        ////                 CollectArgumentTerms(position, objectionCreation.ArgumentList, terms, ref flags);
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 7720, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "objectionCreation", "objectionCreation.ArgumentListOpt", "terms", "flags", "CollectArgumentTerms", "ExpressionType", "ExpressionType.Invalid"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_64()
    {
        //// Line 169
 
        ////                 // that can be used somewhere higher in the stack.
        ////                 if ((flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 7975, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "objectionCreation", "objectionCreation.ArgumentListOpt", "terms", "flags", "CollectArgumentTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_65()
    {
        //// Line 170
 
        ////                 if ((flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////                 {
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8060, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_66()
    {
        //// Line 171
 
        ////                 {
        ////                     expressionType = ExpressionType.ValidExpression;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8083, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "expressionType", "ExpressionType.ValidExpression", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_67()
    {
        //// Line 177
 
        ////         private static void CollectArrayCreationExpressionTerms(int position, ExpressionSyntax expression, IList<string> terms, ref ExpressionType expressionType)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8352, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_68()
    {
        //// Line 178
 
        ////         {
        ////             var validTerm = true;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8367, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["validTerm", "position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_69()
    {
        //// Line 179
 
        ////             var validTerm = true;
        ////             var arrayCreation = (ArrayCreationExpressionSyntax)expression;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8402, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "(ArrayCreationExpressionSyntax)expression", "validTerm", "arrayCreation"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_70()
    {
        //// Line 181
 
        //// 
        ////             if (arrayCreation.InitializerOpt != null)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8480, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["arrayCreation", "arrayCreation.InitializerOpt", "expression", "(ArrayCreationExpressionSyntax)expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_71()
    {
        //// Line 182
 
        ////             if (arrayCreation.InitializerOpt != null)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8535, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["arrayCreation", "arrayCreation.InitializerOpt"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_72()
    {
        //// Line 183
 
        ////             {
        ////                 var flags = ExpressionType.Invalid;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8554, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "arrayCreation", "arrayCreation.InitializerOpt", "flags"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_73()
    {
        //// Line 184
 
        ////                 var flags = ExpressionType.Invalid;
        ////                 arrayCreation.Initializer.Expressions.Do(e => CollectExpressionTerms(position, e, terms, ref flags));
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8607, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["arrayCreation.InitializerOpt.Expressions", "flags", "ExpressionType", "ExpressionType.Invalid"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_74()
    {
        //// Line 186
 
        //// 
        ////                 validTerm &= (flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8731, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "validTerm", "arrayCreation.InitializerOpt.Expressions"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_75()
    {
        //// Line 189
 
        //// 
        ////             if (validTerm)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8838, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["flags", "validTerm", "arrayCreation", "arrayCreation.InitializerOpt", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_76()
    {
        //// Line 190
 
        ////             if (validTerm)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8866, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["validTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_77()
    {
        //// Line 191
 
        ////             {
        ////                 expressionType = ExpressionType.ValidExpression;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8885, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "validTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_78()
    {
        //// Line 194
 
        ////             else
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8980, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["validTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_79()
    {
        //// Line 195
 
        ////             {
        ////                 expressionType = ExpressionType.Invalid;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 8999, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "validTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_80()
    {
        //// Line 200
 
        ////         private static void CollectInvocationExpressionTerms(int position, ExpressionSyntax expression, IList<string> terms, ref ExpressionType expressionType)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 9238, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_81()
    {
        //// Line 203
 
        ////             // is invalid initially
        ////             expressionType = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 9367, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_82()
    {
        //// Line 204
 
        ////             expressionType = ExpressionType.Invalid;
        ////             ExpressionType leftFlags = ExpressionType.Invalid, rightFlags = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 9421, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "leftFlags", "rightFlags"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_83()
    {
        //// Line 206
 
        //// 
        ////             var invocation = (InvocationExpressionSyntax)expression;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 9524, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "(InvocationExpressionSyntax)expression", "leftFlags", "ExpressionType", "ExpressionType.Invalid", "rightFlags", "invocation"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_84()
    {
        //// Line 207
 
        ////             var invocation = (InvocationExpressionSyntax)expression;
        ////             CollectExpressionTerms(position, invocation.Expression, terms, ref leftFlags);
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 9594, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "invocation", "invocation.Expression", "terms", "leftFlags", "CollectExpressionTerms", "expression", "(InvocationExpressionSyntax)expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_85()
    {
        //// Line 208
 
        ////             CollectExpressionTerms(position, invocation.Expression, terms, ref leftFlags);
        ////             CollectArgumentTerms(position, invocation.ArgumentList, terms, ref rightFlags);
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 9686, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "invocation", "invocation.ArgumentList", "terms", "rightFlags", "CollectArgumentTerms", "invocation.Expression", "leftFlags", "CollectExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_86()
    {
        //// Line 210
 
        //// 
        ////             if ((leftFlags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 9781, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm", "position", "invocation", "invocation.ArgumentList", "terms", "rightFlags", "CollectArgumentTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_87()
    {
        //// Line 211
 
        ////             if ((leftFlags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 9866, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_88()
    {
        //// Line 212
 
        ////             {
        ////                 terms.Add(ConvertToString(invocation.Expression));
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 9885, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["leftFlags", "terms", "invocation", "invocation.Expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_89()
    {
        //// Line 216
 
        ////             // We're valid if both children are...
        ////             expressionType = (leftFlags & rightFlags) & ExpressionType.ValidExpression;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10018, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "ExpressionType.ValidTerm", "terms", "invocation", "invocation.Expression", "ConvertToString"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_90()
    {
        //// Line 220
 
        ////         private static void CollectPrefixUnaryExpressionTerms(int position, ExpressionSyntax expression, IList<string> terms, ref ExpressionType expressionType)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10278, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_91()
    {
        //// Line 221
 
        ////         {
        ////             expressionType = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10293, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_92()
    {
        //// Line 222
 
        ////             expressionType = ExpressionType.Invalid;
        ////             var flags = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10347, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "flags"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_93()
    {
        //// Line 223
 
        ////             var flags = ExpressionType.Invalid;
        ////             var prefixUnaryExpression = (PrefixUnaryExpressionSyntax)expression;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10396, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "(PrefixUnaryExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "prefixUnaryExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_94()
    {
        //// Line 226
 
        ////             // Ask our subexpression for terms
        ////             CollectExpressionTerms(position, prefixUnaryExpression.Operand, terms, ref flags);
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10528, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PrefixUnaryExpressionSyntax)expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_95()
    {
        //// Line 229
 
        ////             // Is our expression a valid term?
        ////             if ((flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10674, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_96()
    {
        //// Line 230
 
        ////             if ((flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10755, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["flags", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_97()
    {
        //// Line 231
 
        ////             {
        ////                 terms.Add(ConvertToString(prefixUnaryExpression.Operand));
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10774, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["flags", "terms", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_98()
    {
        //// Line 234
 
        //// 
        ////             if (expression.MatchesKind(SyntaxKind.LogicalNotExpression, SyntaxKind.BitwiseNotExpression, SyntaxKind.NegateExpression, SyntaxKind.PlusExpression))
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 10863, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["flags", "expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression", "ExpressionType", "ExpressionType.ValidTerm", "terms", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "ConvertToString"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_99()
    {
        //// Line 235
 
        ////             if (expression.MatchesKind(SyntaxKind.LogicalNotExpression, SyntaxKind.BitwiseNotExpression, SyntaxKind.NegateExpression, SyntaxKind.PlusExpression))
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 11026, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_100()
    {
        //// Line 237
 
        ////                 // We're a valid expression if our subexpression is...
        ////                 expressionType = flags & ExpressionType.ValidExpression;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 11117, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["flags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_101()
    {
        //// Line 242
 
        ////         private static void CollectPostfixUnaryExpressionTerms(int position, ExpressionSyntax expression, IList<string> terms, ref ExpressionType expressionType)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 11374, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_102()
    {
        //// Line 245
 
        ////             // effects, we never consider this an expression.
        ////             expressionType = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 11539, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_103()
    {
        //// Line 247
 
        //// 
        ////             var flags = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 11595, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "flags"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_104()
    {
        //// Line 248
 
        ////             var flags = ExpressionType.Invalid;
        ////             var postfixUnaryExpression = (PostfixUnaryExpressionSyntax)expression;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 11644, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "(PostfixUnaryExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "postfixUnaryExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_105()
    {
        //// Line 251
 
        ////             // Ask our subexpression for terms
        ////             CollectExpressionTerms(position, postfixUnaryExpression.Operand, terms, ref flags);
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 11778, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PostfixUnaryExpressionSyntax)expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_106()
    {
        //// Line 254
 
        ////             // Is our expression a valid term?
        ////             if ((flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 11925, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_107()
    {
        //// Line 255
 
        ////             if ((flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12006, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_108()
    {
        //// Line 256
 
        ////             {
        ////                 terms.Add(ConvertToString(postfixUnaryExpression.Operand));
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12025, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["flags", "terms", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_109()
    {
        //// Line 261
 
        ////         private static void CollectBinaryExpressionTerms(int position, ExpressionSyntax expression, IList<string> terms, ref ExpressionType expressionType)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12279, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_110()
    {
        //// Line 262
 
        ////         {
        ////             ExpressionType leftFlags = ExpressionType.Invalid, rightFlags = ExpressionType.Invalid;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12294, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "leftFlags", "rightFlags", "position", "expression", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_111()
    {
        //// Line 264
 
        //// 
        ////             var binaryExpression = (BinaryExpressionSyntax)expression;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12397, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["expression", "(BinaryExpressionSyntax)expression", "leftFlags", "ExpressionType", "ExpressionType.Invalid", "rightFlags", "binaryExpression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_112()
    {
        //// Line 265
 
        ////             var binaryExpression = (BinaryExpressionSyntax)expression;
        ////             CollectExpressionTerms(position, binaryExpression.Left, terms, ref leftFlags);
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12469, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "binaryExpression", "binaryExpression.Left", "terms", "leftFlags", "CollectExpressionTerms", "expression", "(BinaryExpressionSyntax)expression"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_113()
    {
        //// Line 266
 
        ////             CollectExpressionTerms(position, binaryExpression.Left, terms, ref leftFlags);
        ////             CollectExpressionTerms(position, binaryExpression.Right, terms, ref rightFlags);
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12561, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "binaryExpression", "binaryExpression.Right", "terms", "rightFlags", "CollectExpressionTerms", "binaryExpression.Left", "leftFlags"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_114()
    {
        //// Line 268
 
        //// 
        ////             if ((leftFlags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12657, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm", "position", "binaryExpression", "binaryExpression.Right", "terms", "rightFlags", "CollectExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_115()
    {
        //// Line 269
 
        ////             if ((leftFlags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12742, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_116()
    {
        //// Line 270
 
        ////             {
        ////                 terms.Add(ConvertToString(binaryExpression.Left));
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12761, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["leftFlags", "terms", "binaryExpression", "binaryExpression.Left", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_117()
    {
        //// Line 273
 
        //// 
        ////             if ((rightFlags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12842, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression", "binaryExpression.Left", "ConvertToString"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_118()
    {
        //// Line 274
 
        ////             if ((rightFlags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12928, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["rightFlags", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_119()
    {
        //// Line 275
 
        ////             {
        ////                 terms.Add(ConvertToString(binaryExpression.Right));
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 12947, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["terms", "rightFlags", "binaryExpression", "binaryExpression.Right", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_120()
    {
        //// Line 281
 
        //// 
        ////             switch (binaryExpression.Kind)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 13202, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_121()
    {
        //// Line 305
 
        ////                     // We're valid if both children are...
        ////                     expressionType = (leftFlags & rightFlags) & ExpressionType.ValidExpression;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 14452, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "binaryExpression", "binaryExpression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_122()
    {
        //// Line 306
 
        ////                     expressionType = (leftFlags & rightFlags) & ExpressionType.ValidExpression;
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 14549, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_123()
    {
        //// Line 309
 
        ////                 default:
        ////                     expressionType = ExpressionType.Invalid;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 14606, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "binaryExpression", "binaryExpression.Kind"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_124()
    {
        //// Line 310
 
        ////                     expressionType = ExpressionType.Invalid;
        ////                     return;
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 14668, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_125()
    {
        //// Line 315
 
        ////         private static void CollectArgumentTerms(int position, ArgumentListSyntax argumentList, IList<string> terms, ref ExpressionType expressionType)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 14866, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "argumentList", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_126()
    {
        //// Line 316
 
        ////         {
        ////             var validExpr = true;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 14881, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["validExpr", "position", "argumentList", "terms", "expressionType"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_127()
    {
        //// Line 320
 
        ////             // arguments to a function call(or a list of array index expressions)
        ////             foreach (var arg in argumentList.Arguments)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15078, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["arg", "argumentList", "argumentList.Arguments", "validExpr"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_128()
    {
        //// Line 321
 
        ////             foreach (var arg in argumentList.Arguments)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15135, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["arg", "argumentList", "argumentList.Arguments"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_129()
    {
        //// Line 322
 
        ////             {
        ////                 var flags = ExpressionType.Invalid;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15154, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "arg", "argumentList", "argumentList.Arguments", "flags"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_130()
    {
        //// Line 324
 
        //// 
        ////                 CollectExpressionTerms(position, arg.Expression, terms, ref flags);
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15209, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "arg", "arg.Expression", "terms", "flags", "CollectExpressionTerms", "ExpressionType", "ExpressionType.Invalid"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_131()
    {
        //// Line 325
 
        ////                 CollectExpressionTerms(position, arg.Expression, terms, ref flags);
        ////                 if ((flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15294, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "arg", "arg.Expression", "terms", "flags", "CollectExpressionTerms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_132()
    {
        //// Line 326
 
        ////                 if ((flags & ExpressionType.ValidTerm) == ExpressionType.ValidTerm)
        ////                 {
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15379, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_133()
    {
        //// Line 327
 
        ////                 {
        ////                     terms.Add(ConvertToString(arg.Expression));
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15402, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["flags", "terms", "arg", "arg.Expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_134()
    {
        //// Line 330
 
        //// 
        ////                 validExpr &= (flags & ExpressionType.ValidExpression) == ExpressionType.ValidExpression;
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15484, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "validExpr", "ExpressionType.ValidTerm", "terms", "arg", "arg.Expression", "ConvertToString"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_135()
    {
        //// Line 335
 
        ////             // the list elements are...
        ////             expressionType = validExpr ? ExpressionType.ValidExpression : 0;
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15722, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["flags", "ExpressionType", "validExpr", "ExpressionType.ValidExpression", "expressionType", "arg", "argumentList", "argumentList.Arguments"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_136()
    {
        //// Line 339
 
        ////         private static void CollectVariableTerms(int position, SeparatedSyntaxList<VariableDeclaratorSyntax> declarators, List<string> terms)
        ////         {
        ////         ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15952, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "declarators", "terms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_137()
    {
        //// Line 340
 
        ////         {
        ////             foreach (var declarator in declarators)
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 15967, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["declarator", "declarators", "position", "terms"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_138()
    {
        //// Line 341
 
        ////             foreach (var declarator in declarators)
        ////             {
        ////             ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 16020, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["declarator", "declarators"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_139()
    {
        //// Line 342
 
        ////             {
        ////                 if (declarator.InitializerOpt != null)
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 16039, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["declarator", "declarator.InitializerOpt", "declarators"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_140()
    {
        //// Line 343
 
        ////                 if (declarator.InitializerOpt != null)
        ////                 {
        ////                 ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 16095, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["declarator", "declarator.InitializerOpt"], terms);
    }
 
    [Fact]
    public void TestAtStartOfStatement_141()
    {
        //// Line 344
 
        ////                 {
        ////                     CollectExpressionTerms(position, declarator.Initializer.Value, terms);
        ////                     ^
        var tree = GetTree();
        var terms = CSharpProximityExpressionsService.GetProximityExpressions(tree, 16118, cancellationToken: default);
        Assert.NotNull(terms);
        AssertEx.SetEqual(["position", "declarator.InitializerOpt", "declarator.InitializerOpt.Value", "terms", "CollectExpressionTerms", "declarator"], terms);
    }
}