83AssertEx.AssertEqualToleratingWhitespaceDifferences("", errorOutput); 97AssertEx.Equal(expectedOutput, output);

36AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 37AssertEx.AssertEqualToleratingWhitespaceDifferences($"(home, {dir}, 1)", output); 48AssertEx.AssertEqualToleratingWhitespaceDifferences(@$" 63AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(), output); 67AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(), output); 75AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(srcDir.Path), output); 83AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(dllDir), output);

36AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(fxDir), output); 40AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(), output); 48AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(srcDir.Path), output); 56AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(fxDir, dllDir), output); 74AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 75AssertEx.AssertEqualToleratingWhitespaceDifferences("", output); 81AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 82AssertEx.AssertEqualToleratingWhitespaceDifferences("", output);

82AssertEx.AssertEqualToleratingWhitespaceDifferences( 493AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 494AssertEx.AssertEqualToleratingWhitespaceDifferences("1", output); 720AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 721AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 747AssertEx.AssertEqualToleratingWhitespaceDifferences( 800AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 801AssertEx.AssertEqualToleratingWhitespaceDifferences( 826AssertEx.AssertEqualToleratingWhitespaceDifferences($@"{initFile.Path}(1,3): error CS1002: {CSharpResources.ERR_SemicolonExpected} 829AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 851AssertEx.AssertEqualToleratingWhitespaceDifferences( 864AssertEx.AssertEqualToleratingWhitespaceDifferences($@"(1,8): error CS0234: {string.Format(CSharpResources.ERR_DottedTypeNameNotFoundInNS, "Missing", "Microsoft")}", 951AssertEx.AssertEqualToleratingWhitespaceDifferences("C { P=null }", output); 991AssertEx.AssertEqualToleratingWhitespaceDifferences("120", output); 992AssertEx.AssertEqualToleratingWhitespaceDifferences("System.Exception: Bang!", error); 999AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1000AssertEx.AssertEqualToleratingWhitespaceDifferences("8\r\n", await ReadOutputToEnd()); 1003AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1004AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadOutputToEnd()); 1007AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1008AssertEx.AssertEqualToleratingWhitespaceDifferences("4\r\n", await ReadOutputToEnd()); 1011AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1012AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadOutputToEnd()); 1015AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1016AssertEx.AssertEqualToleratingWhitespaceDifferences("8\r\n", await ReadOutputToEnd()); 1036AssertEx.AssertEqualToleratingWhitespaceDifferences($@"

76AssertEx.AssertEqualToleratingWhitespaceDifferences($$"""Copying reference assembly from "{{file.Path}}" to "{{dest}}".""", engine.Log); 98AssertEx.AssertEqualToleratingWhitespaceDifferences($$""" 129AssertEx.AssertEqualToleratingWhitespaceDifferences($$"""

222AssertEx.Equal("""/features:"InterceptorsNamespaces=NS1.NS2;NS3.NS4" /out:test.exe test.cs""", csc.GenerateResponseFileContents()); 231AssertEx.Equal("""/features:"InterceptorsNamespaces=NS1.NS2;NS3.NS4" /out:test.exe test.cs""", csc.GenerateResponseFileContents()); 241AssertEx.Equal("""/features:"InterceptorsNamespaces=NS1.NS2;NS3.NS4;NS5.NS6;NS7.NS8" /out:test.exe test.cs""", csc.GenerateResponseFileContents()); 561AssertEx.Equal("/reportivts", csc.GenerateResponseFileContents());

107AssertEx.AssertEqualToleratingWhitespaceDifferences( 146AssertEx.AssertEqualToleratingWhitespaceDifferences( 184AssertEx.AssertEqualToleratingWhitespaceDifferences( 222AssertEx.AssertEqualToleratingWhitespaceDifferences( 264AssertEx.AssertEqualToleratingWhitespaceDifferences( 304AssertEx.AssertEqualToleratingWhitespaceDifferences(

55AssertEx.AssertEqualToleratingWhitespaceDifferences("", engine.Log); 104AssertEx.AssertEqualToleratingWhitespaceDifferences("", engine.Log); 142AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 181AssertEx.AssertEqualToleratingWhitespaceDifferences("", engine.Log); 219AssertEx.AssertEqualToleratingWhitespaceDifferences("", engine.Log); 267AssertEx.AssertEqualToleratingWhitespaceDifferences( 328AssertEx.AssertEqualToleratingWhitespaceDifferences( 343AssertEx.NotNull(task.MappedSourceRoots); 344AssertEx.Equal(new[] 377AssertEx.AssertEqualToleratingWhitespaceDifferences("ERROR : " + string.Format(task.Log.FormatResourceString( 406AssertEx.AssertEqualToleratingWhitespaceDifferences("ERROR : " + string.Format(task.Log.FormatResourceString( 440AssertEx.AssertEqualToleratingWhitespaceDifferences("ERROR : " + string.Format(task.Log.FormatResourceString( 448AssertEx.NotNull(task.MappedSourceRoots); 449AssertEx.Equal(new[]

266AssertEx.NotNull(itemType); 270AssertEx.NotNull(metaName); 274AssertEx.NotNull(customMeta); 308AssertEx.NotNull(itemType); 312AssertEx.NotNull(metaName); 316AssertEx.NotNull(customMeta); 348AssertEx.NotNull(itemType); 352AssertEx.NotNull(metaName); 383AssertEx.NotNull(itemType); 387AssertEx.NotNull(metaName);

238AssertEx.Equal(expectedResults, evaluationResult);

528AssertEx.Equal("/optionstrict:custom /reportivts", vbc.GenerateResponseFileContents());

45AssertEx.AssertEqualToleratingWhitespaceDifferences($""" 122AssertEx.AssertEqualToleratingWhitespaceDifferences($""" 201AssertEx.AssertEqualToleratingWhitespaceDifferences($""" 286AssertEx.AssertEqualToleratingWhitespaceDifferences($"""

226AssertEx.Equal("Class1.cs(1,1): warning ID1000:", output.Trim()); 249AssertEx.Equal("", outWriter.ToString()); 460AssertEx.Equal(new[] { "System.dll" }, cmd.Arguments.MetadataReferences.Select(r => r.Reference)); 461AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "a.cs"), Path.Combine(WorkingDirectory, "b.cs") }, cmd.Arguments.SourceFiles.Select(file => file.Path)); 513AssertEx.Equal(new[] { "first.cs", "second.cs", "b.cs", "a.cs", "c.cs", "d.cs", "last.cs" }.Select(prependBasePath), resolvedSourceFiles); 514AssertEx.Equal(new[] { typeof(object).Assembly.Location, @"..\v4.0.30319\System.dll", @".\System.Data.dll" }, references); 515AssertEx.Equal(new[] { RuntimeEnvironment.GetRuntimeDirectory() }.Concat(new[] { @"x", @"..\goo", @"../bar", @"a b" }.Select(prependBasePath)), args.ReferencePaths.ToArray()); 524AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 536AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 550AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 566AssertEx.Equal(ImmutableArray<string>.Empty, parser.ReferencePaths); 608AssertEx.Equal(new[] { @"C:\temp\a.cs", @"C:\temp\b.cs", @"C:\temp\c.cs", @"C:\temp\a\x.cs", @"C:\temp\a\b\b.cs", @"C:\temp\a\c.cs" }, resolvedSourceFiles); 716AssertEx.Equal(new[] { folder.Path + @"\c.cpp", folder.Path + @"\B\B_c.cpx", folder.Path + @"\a\A_a.cs", folder.Path + @"\a\A_b.cs", }, resolvedSourceFiles); 1195AssertEx.Equal(new[] { "a", "b", "c" }, 1202AssertEx.Equal(new[] { " b " }, 1238AssertEx.Equal(new[] { "{DIR}\\a.cs", "{DIR}\\b.cs", "{DIR}\\d2\\e.cs" }, 1243AssertEx.Equal(new[] { "{DIR}\\a.cs", "{DIR}\\b.cs" }, 1273AssertEx.Equal(new[] { "a", "b", "c" }, 1280AssertEx.Equal(new[] { " b " }, 1733AssertEx.SetEqual(new[] { "default", "1", "2", "3", "4", "5", "6", "7.0", "7.1", "7.2", "7.3", "8.0", "9.0", "10.0", "11.0", "12.0", "13.0", "latest", "latestmajor", "preview" }, 1771AssertEx.SetEqual(versions, errorCodes); 2262AssertEx.Equal(File.ReadAllBytes(sl.Path), blob); 2291AssertEx.Equal(File.ReadAllBytes(sl.Path), blob); 2317AssertEx.Equal(slContent, actualData); 2332AssertEx.Equal(parsedArgs.SourceFiles, parsedArgs.EmbeddedFiles); 2333AssertEx.Equal( 2339AssertEx.Equal( 2345AssertEx.Equal( 2351AssertEx.Equal( 2357AssertEx.Equal( 2363AssertEx.Equal( 3603AssertEx.Equal( 3630AssertEx.Equal( 3680AssertEx.Equal(""" 3703AssertEx.Equal(""" 4679AssertEx.Equal(new[] 5340AssertEx.Equal(new[] { "Goo.Bar" }, parsedArgs.CompilationOptions.Usings.AsEnumerable()); 5344AssertEx.Equal(new[] { "Goo.Bar", "Baz", "System.Core", "System" }, parsedArgs.CompilationOptions.Usings.AsEnumerable()); 5348AssertEx.Equal(new[] { "Goo", "Bar" }, parsedArgs.CompilationOptions.Usings.AsEnumerable()); 5450AssertEx.Equal( 5454AssertEx.Equal(expectedOptions, actualOrdered.Select(entry => entry.Value)); 6636AssertEx.Equal(new[] { "a.cs", "b.cs", @"c.cs e.cs", "hello", "world" }, args); 6649AssertEx.Equal(new[] { "a.cs", "b#.cs", "c#d.cs", "#f.cs", "#g.cs #h.cs" }, args); 6656AssertEx.Equal(new[] { @"a\b\c", @"d\\e\\f\\", @"\\\g\\\h\\\i", @"\\\\", @"\\\\\k\\\\\" }, args); 6663AssertEx.Equal(new[] { @"a\""a", @"b\\""b c\\\""c d\\\\""d", @"e\\\\\""e", @"f"" g""" }, args); 6670AssertEx.Equal(new[] { @"/o:""goo.cs""", @"/o:""abc def""\baz", @"""/o:baz bar""bing" }, args); 6681AssertEx.Equal(new[] { @"d:\abc def\baz.cs", @"c:\abc de.cs" }, args.SourceFiles.Select(file => file.Path)); 8466AssertEx.Equal(csc.Arguments.MetadataReferences.Select(r => r.Reference), new string[] 8845AssertEx.AssertEqualToleratingWhitespaceDifferences("", outWriter.ToString()); 8850AssertEx.Equal(new byte[] { 0x4D, 0x5A }, ReadBytes(libDll.Path, 2)); 8851AssertEx.Equal(new[] { (byte)'D', (byte)'L', (byte)'L' }, ReadBytes(fsDll, 3)); 8853AssertEx.Equal(new byte[] { 0x4D, 0x69 }, ReadBytes(libPdb.Path, 2)); 8854AssertEx.Equal(new[] { (byte)'P', (byte)'D', (byte)'B' }, ReadBytes(fsPdb, 3)); 8859AssertEx.Equal(new[] { "Lib.cs", "Lib.dll", "Lib.pdb" }, Directory.GetFiles(dir.Path).Select(p => Path.GetFileName(p)).Order()); 8889AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 8910AssertEx.Equal(new[] { (byte)'B', (byte)'S', (byte)'J', (byte)'B' }, ReadBytes(libPdb.Path, 4)); 8916AssertEx.Equal(new[] { "Lib.cs", "Lib.dll", "Lib.pdb" }, Directory.GetFiles(dir.Path).Select(p => Path.GetFileName(p)).Order()); 8952AssertEx.Equal(new[] { (byte)'D', (byte)'L', (byte)'L' }, ReadBytes(libDll.Path, 3)); 8953AssertEx.Equal(new[] { (byte)'D', (byte)'L', (byte)'L' }, ReadBytes(fsDll, 3)); 8957AssertEx.Equal(new[] { "Lib.cs", "Lib.dll" }, Directory.GetFiles(dir.Path).Select(p => Path.GetFileName(p)).Order()); 10064AssertEx.Equal(expectedWarningsAll, compileAndRun(featureOpt: null)); 10065AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis")); 10066AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=always")); 10067AssertEx.Equal(expectedWarningsNone, compileAndRun("/features:run-nullable-analysis=never")); 10068AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=ALWAYS")); // unrecognized value (incorrect case) ignored 10069AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=NEVER")); // unrecognized value (incorrect case) ignored 10070AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=true")); // unrecognized value ignored 10071AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=false")); // unrecognized value ignored 10072AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=unknown")); // unrecognized value ignored 11450AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11451AssertEx.Equal(new[] { "b", "c" }, args.ScriptArguments); 11454AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "@script.csx") }, args.SourceFiles.Select(f => f.Path)); 11455AssertEx.Equal(new[] { "b", "c" }, args.ScriptArguments); 11458AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "-script.csx") }, args.SourceFiles.Select(f => f.Path)); 11459AssertEx.Equal(new[] { "b", "c" }, args.ScriptArguments); 11462AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11463AssertEx.Equal(new[] { "--", "b", "c" }, args.ScriptArguments); 11466AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11467AssertEx.Equal(new[] { "a", "b", "c" }, args.ScriptArguments); 11470AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11471AssertEx.Equal(new[] { "a", "--", "b", "c" }, args.ScriptArguments); 11475AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11476AssertEx.Equal(new[] { "a", "b", "c" }, args.ScriptArguments); 11480AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11481AssertEx.Equal(new[] { "a", "b", "c" }, args.ScriptArguments); 11485AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "--") }, args.SourceFiles.Select(f => f.Path)); 11487AssertEx.Equal(new[] { "--" }, args.ScriptArguments); 11597AssertEx.Equal(expected, CommandLineParser.SplitWithDoubledSeparatorEscaping(str, ',')); 11757AssertEx.Equal(programExe32.ReadAllBytes(), programExe64.ReadAllBytes()); 11758AssertEx.Equal(programPdb32.ReadAllBytes(), programPdb64.ReadAllBytes()); 12058AssertEx.AssertEqualToleratingWhitespaceDifferences( 12268AssertEx.AssertEqualToleratingWhitespaceDifferences( 12274AssertEx.AssertEqualToleratingWhitespaceDifferences("", result.Output.Trim());

85AssertEx.Equal(expected, actualFormatted);

6053AssertEx.Equal( 6083AssertEx.Equal(

3077AssertEx.Equal( 3178AssertEx.Equal(

190AssertEx.EqualOrDiff(expectedSourceOriginal, actualText);

46AssertEx.EqualOrDiff(

78AssertEx.EqualOrDiff(

454AssertEx.SetEqual(items.Select(i => i.DisplayText), toTypes); 516AssertEx.SetEqual(items.Select(i => i.DisplayText), expected);

64AssertEx.Equal((string[])["yy", "xx"], terms); 110AssertEx.Equal(expectedTerms, actualTerms ?? Array.Empty<string>());

135AssertEx.SetEqual(["expression"], terms); 147AssertEx.SetEqual(["expression"], terms); 159AssertEx.SetEqual(["expression"], terms); 204AssertEx.SetEqual(["position", "expression", "terms"], terms); 216AssertEx.SetEqual(["expression", "position", "terms"], terms); 228AssertEx.SetEqual(["expression", "position", "terms"], terms); 240AssertEx.SetEqual(["expression"], terms); 252AssertEx.SetEqual(["expression"], terms); 275AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expression", "expressionType"], terms); 287AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expression", "expressionType"], terms); 299AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expression", "expressionType"], terms); 311AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expression", "expressionType"], terms); 323AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectExpressionTerms", "ExpressionType", "ExpressionType.Invalid"], terms); 335AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "expression", "terms", "expressionType", "CollectExpressionTerms"], terms); 347AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "expression", "terms", "expressionType", "CollectExpressionTerms"], terms); 359AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm"], terms); 371AssertEx.SetEqual(["expressionType", "terms", "expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 383AssertEx.SetEqual(["expressionType", "terms", "expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 395AssertEx.SetEqual(["expressionType", "terms", "expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 407AssertEx.SetEqual(["terms", "expression", "ConvertToString"], terms); 419AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm", "terms", "expression", "ConvertToString"], terms); 453AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 465AssertEx.SetEqual(["expression", "position", "terms", "expressionType"], terms); 477AssertEx.SetEqual(["expression", "position", "terms", "expressionType"], terms); 489AssertEx.SetEqual(["expression"], terms); 501AssertEx.SetEqual(["expression"], terms); 524AssertEx.SetEqual(["expression", "expression.Kind"], terms); 536AssertEx.SetEqual(["expression", "expression.Kind"], terms); 548AssertEx.SetEqual(["expression", "expression.Kind"], terms); 560AssertEx.SetEqual(["expression", "expression.Kind"], terms); 572AssertEx.SetEqual(["expression", "expression.Kind"], terms); 584AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 596AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 608AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 620AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 632AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms); 644AssertEx.SetEqual(["expression", "expression.Kind"], terms); 656AssertEx.SetEqual(["expression", "expression.Kind"], terms); 668AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm", "expression", "expression.Kind"], terms); 680AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm", "expression", "expression.Kind"], terms); 692AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm"], terms); 704AssertEx.SetEqual(["expression", "expression.Kind"], terms); 716AssertEx.SetEqual(["expression", "expression.Kind"], terms); 728AssertEx.SetEqual(["expression", "expression.Kind"], terms); 740AssertEx.SetEqual(["expression", "expression.Kind"], terms); 752AssertEx.SetEqual(["expression", "expression.Kind"], terms); 764AssertEx.SetEqual(["expression", "expression.Kind"], terms); 776AssertEx.SetEqual(["expression", "expression.Kind"], terms); 788AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 800AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 812AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 824AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 836AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms); 848AssertEx.SetEqual(["expression", "expression.Kind"], terms); 860AssertEx.SetEqual(["expression", "expression.Kind"], terms); 872AssertEx.SetEqual(["position", "terms", "expressionType", "CollectExpressionTerms", "expression", "expression.Kind"], terms); 884AssertEx.SetEqual(["position", "terms", "expressionType", "CollectExpressionTerms", "expression", "expression.Kind"], terms); 896AssertEx.SetEqual(["position", "terms", "expressionType", "CollectExpressionTerms", "expression", "expression.Kind"], terms); 908AssertEx.SetEqual(["position", "terms", "expressionType", "CollectExpressionTerms", "expression", "expression.Kind"], terms); 920AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectExpressionTerms"], terms); 932AssertEx.SetEqual(["expression", "expression.Kind"], terms); 944AssertEx.SetEqual(["expression", "expression.Kind"], terms); 956AssertEx.SetEqual(["expression", "expression.Kind"], terms); 968AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectMemberAccessExpressionTerms", "expression.Kind"], terms); 980AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectMemberAccessExpressionTerms"], terms); 992AssertEx.SetEqual(["expression", "expression.Kind"], terms); 1004AssertEx.SetEqual(["expression", "expression.Kind"], terms); 1016AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectObjectCreationExpressionTerms", "expression.Kind"], terms); 1028AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectObjectCreationExpressionTerms"], terms); 1040AssertEx.SetEqual(["expression", "expression.Kind"], terms); 1052AssertEx.SetEqual(["expression", "expression.Kind"], terms); 1064AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectArrayCreationExpressionTerms", "expression.Kind"], terms); 1076AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectArrayCreationExpressionTerms"], terms); 1088AssertEx.SetEqual(["expression", "expression.Kind"], terms); 1100AssertEx.SetEqual(["expression", "expression.Kind"], terms); 1112AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectInvocationExpressionTerms", "expression.Kind"], terms); 1124AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectInvocationExpressionTerms"], terms); 1136AssertEx.SetEqual(["expression", "expression.Kind"], terms); 1148AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax", "expression.Kind"], terms); 1160AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax", "expression.Kind"], terms); 1172AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax", "expression.Kind"], terms); 1184AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax", "expression.Kind"], terms); 1196AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax", "expression.Kind"], terms); 1208AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax"], terms); 1220AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPrefixUnaryExpressionTerms", "PrefixUnaryExpressionSyntax"], terms); 1232AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPrefixUnaryExpressionTerms"], terms); 1255AssertEx.SetEqual(["expression", "PostfixUnaryExpressionSyntax", "PrefixUnaryExpressionSyntax"], terms); 1267AssertEx.SetEqual(["expression", "PostfixUnaryExpressionSyntax", "PrefixUnaryExpressionSyntax"], terms); 1279AssertEx.SetEqual(["expression", "PostfixUnaryExpressionSyntax"], terms); 1291AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPostfixUnaryExpressionTerms", "PostfixUnaryExpressionSyntax"], terms); 1303AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPostfixUnaryExpressionTerms"], terms); 1326AssertEx.SetEqual(["expression", "BinaryExpressionSyntax", "PostfixUnaryExpressionSyntax"], terms); 1338AssertEx.SetEqual(["expression", "BinaryExpressionSyntax", "PostfixUnaryExpressionSyntax"], terms); 1350AssertEx.SetEqual(["expression", "BinaryExpressionSyntax"], terms); 1362AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectBinaryExpressionTerms", "BinaryExpressionSyntax"], terms); 1374AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectBinaryExpressionTerms"], terms); 1397AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "expression", "BinaryExpressionSyntax"], terms); 1409AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "expression", "BinaryExpressionSyntax"], terms); 1421AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid"], terms); 1455AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 1467AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "flags", "position", "expression", "terms", "expressionType"], terms); 1479AssertEx.SetEqual(["expression", "(MemberAccessExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "memberAccess"], terms); 1491AssertEx.SetEqual(["expression", "(MemberAccessExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "memberAccess"], terms); 1503AssertEx.SetEqual(["expression", "(MemberAccessExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "memberAccess"], terms); 1515AssertEx.SetEqual(["expression", "(MemberAccessExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "memberAccess"], terms); 1527AssertEx.SetEqual(["expression", "(MemberAccessExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "memberAccess"], terms); 1539AssertEx.SetEqual(["position", "memberAccess", "memberAccess.Expression", "terms", "flags", "CollectExpressionTerms", "expression", "(MemberAccessExpressionSyntax)expression"], terms); 1551AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "position", "memberAccess", "memberAccess.Expression", "terms", "CollectExpressionTerms"], terms); 1563AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "position", "memberAccess", "memberAccess.Expression", "terms", "CollectExpressionTerms"], terms); 1575AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "position", "memberAccess", "memberAccess.Expression", "terms", "CollectExpressionTerms"], terms); 1587AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "position", "memberAccess", "memberAccess.Expression", "terms", "CollectExpressionTerms"], terms); 1599AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "position", "memberAccess", "memberAccess.Expression", "terms", "CollectExpressionTerms"], terms); 1611AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "position", "memberAccess", "memberAccess.Expression", "terms", "CollectExpressionTerms"], terms); 1623AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "position", "memberAccess", "memberAccess.Expression", "terms", "CollectExpressionTerms"], terms); 1635AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression"], terms); 1647AssertEx.SetEqual(["terms", "memberAccess", "memberAccess.Expression", "ConvertToString", "ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression"], terms); 1659AssertEx.SetEqual(["terms", "memberAccess", "memberAccess.Expression", "ConvertToString"], terms); 1671AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression", "ExpressionType.ValidTerm", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString"], terms); 1683AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression", "ExpressionType.ValidTerm", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString"], terms); 1695AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression", "ExpressionType.ValidTerm", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString"], terms); 1707AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression", "ExpressionType.ValidTerm", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString"], terms); 1719AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression", "ExpressionType.ValidTerm", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString"], terms); 1731AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms); 1743AssertEx.SetEqual(["ExpressionType", "flags", "expressionType", "ExpressionType.ValidTerm", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms); 1755AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm"], terms); 1767AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression", "ExpressionType.ValidTerm", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString"], terms); 1779AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms); 1791AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "flags", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms); 1803AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms); 1815AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression", "expressionType", "ExpressionType.ValidTerm"], terms); 1849AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 1861AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 1873AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 1885AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 1897AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 1909AssertEx.SetEqual(["expression", "(ObjectCreationExpressionSyntax)expression", "ExpressionType", "expressionType", "ExpressionType.Invalid", "objectionCreation"], terms); 1921AssertEx.SetEqual(["expression", "(ObjectCreationExpressionSyntax)expression", "ExpressionType", "expressionType", "ExpressionType.Invalid", "objectionCreation"], terms); 1933AssertEx.SetEqual(["objectionCreation", "objectionCreation.ArgumentListOpt", "expression", "(ObjectCreationExpressionSyntax)expression"], terms); 1945AssertEx.SetEqual(["objectionCreation", "objectionCreation.ArgumentListOpt"], terms); 1957AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "objectionCreation", "objectionCreation.ArgumentListOpt", "flags"], terms); 1969AssertEx.SetEqual(["position", "objectionCreation", "objectionCreation.ArgumentListOpt", "terms", "flags", "CollectArgumentTerms", "ExpressionType", "ExpressionType.Invalid"], terms); 1981AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "objectionCreation", "objectionCreation.ArgumentListOpt", "terms", "flags", "CollectArgumentTerms"], terms); 1993AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "objectionCreation", "objectionCreation.ArgumentListOpt", "terms", "flags", "CollectArgumentTerms"], terms); 2005AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "objectionCreation", "objectionCreation.ArgumentListOpt", "terms", "flags", "CollectArgumentTerms"], terms); 2017AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "objectionCreation", "objectionCreation.ArgumentListOpt", "terms", "flags", "CollectArgumentTerms"], terms); 2029AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm"], terms); 2041AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "flags", "ExpressionType.ValidTerm"], terms); 2053AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms); 2065AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expressionType", "ExpressionType.ValidExpression"], terms); 2077AssertEx.SetEqual(["objectionCreation", "objectionCreation.ArgumentListOpt", "ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms); 2111AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 2123AssertEx.SetEqual(["validTerm", "position", "expression", "terms", "expressionType"], terms); 2135AssertEx.SetEqual(["expression", "(ArrayCreationExpressionSyntax)expression", "validTerm", "arrayCreation"], terms); 2147AssertEx.SetEqual(["arrayCreation", "arrayCreation.InitializerOpt", "expression", "(ArrayCreationExpressionSyntax)expression"], terms); 2159AssertEx.SetEqual(["arrayCreation", "arrayCreation.InitializerOpt", "expression", "(ArrayCreationExpressionSyntax)expression"], terms); 2171AssertEx.SetEqual(["arrayCreation", "arrayCreation.InitializerOpt"], terms); 2183AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "arrayCreation", "arrayCreation.InitializerOpt", "flags"], terms); 2195AssertEx.SetEqual(["arrayCreation.InitializerOpt.Expressions", "flags", "ExpressionType", "ExpressionType.Invalid"], terms); 2207AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "validTerm", "arrayCreation.InitializerOpt.Expressions"], terms); 2219AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "validTerm", "arrayCreation.InitializerOpt.Expressions"], terms); 2231AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "validTerm"], terms); 2243AssertEx.SetEqual(["validTerm", "arrayCreation", "arrayCreation.InitializerOpt", "ExpressionType", "flags", "ExpressionType.ValidTerm"], terms); 2255AssertEx.SetEqual(["validTerm", "arrayCreation", "arrayCreation.InitializerOpt", "ExpressionType", "flags", "ExpressionType.ValidTerm"], terms); 2267AssertEx.SetEqual(["validTerm"], terms); 2279AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "validTerm"], terms); 2291AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms); 2303AssertEx.SetEqual(["validTerm", "arrayCreation", "arrayCreation.InitializerOpt", "ExpressionType", "flags", "ExpressionType.ValidTerm"], terms); 2315AssertEx.SetEqual(["validTerm"], terms); 2327AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "validTerm"], terms); 2339AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid"], terms); 2351AssertEx.SetEqual(["validTerm", "ExpressionType", "expressionType", "ExpressionType.ValidExpression", "ExpressionType.Invalid"], terms); 2385AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 2397AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 2409AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 2421AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 2433AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "leftFlags", "rightFlags"], terms); 2445AssertEx.SetEqual(["expression", "(InvocationExpressionSyntax)expression", "leftFlags", "ExpressionType", "ExpressionType.Invalid", "rightFlags", "invocation"], terms); 2457AssertEx.SetEqual(["expression", "(InvocationExpressionSyntax)expression", "leftFlags", "ExpressionType", "ExpressionType.Invalid", "rightFlags", "invocation"], terms); 2469AssertEx.SetEqual(["position", "invocation", "invocation.Expression", "terms", "leftFlags", "CollectExpressionTerms", "expression", "(InvocationExpressionSyntax)expression"], terms); 2481AssertEx.SetEqual(["position", "invocation", "invocation.ArgumentList", "terms", "rightFlags", "CollectArgumentTerms", "invocation.Expression", "leftFlags", "CollectExpressionTerms"], terms); 2493AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm", "position", "invocation", "invocation.ArgumentList", "terms", "rightFlags", "CollectArgumentTerms"], terms); 2505AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm", "position", "invocation", "invocation.ArgumentList", "terms", "rightFlags", "CollectArgumentTerms"], terms); 2517AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm"], terms); 2529AssertEx.SetEqual(["terms", "invocation", "invocation.Expression", "ConvertToString", "ExpressionType", "leftFlags", "ExpressionType.ValidTerm"], terms); 2541AssertEx.SetEqual(["terms", "invocation", "invocation.Expression", "ConvertToString"], terms); 2553AssertEx.SetEqual(["ExpressionType", "leftFlags", "rightFlags", "ExpressionType.ValidExpression", "expressionType", "ExpressionType.ValidTerm", "terms", "invocation", "invocation.Expression", "ConvertToString"], terms); 2565AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "ExpressionType.ValidTerm", "terms", "invocation", "invocation.Expression", "ConvertToString"], terms); 2577AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "ExpressionType.ValidTerm", "terms", "invocation", "invocation.Expression", "ConvertToString"], terms); 2589AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType"], terms); 2623AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 2635AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 2647AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "flags"], terms); 2659AssertEx.SetEqual(["expression", "(PrefixUnaryExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "prefixUnaryExpression"], terms); 2671AssertEx.SetEqual(["position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PrefixUnaryExpressionSyntax)expression"], terms); 2683AssertEx.SetEqual(["position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PrefixUnaryExpressionSyntax)expression"], terms); 2695AssertEx.SetEqual(["position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PrefixUnaryExpressionSyntax)expression"], terms); 2707AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms); 2719AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms); 2731AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms); 2743AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm"], terms); 2755AssertEx.SetEqual(["flags", "terms", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 2767AssertEx.SetEqual(["terms", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "ConvertToString"], terms); 2779AssertEx.SetEqual(["flags", "expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression", "ExpressionType", "ExpressionType.ValidTerm", "terms", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "ConvertToString"], terms); 2791AssertEx.SetEqual(["flags", "expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression", "ExpressionType", "ExpressionType.ValidTerm", "terms", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "ConvertToString"], terms); 2803AssertEx.SetEqual(["expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression"], terms); 2815AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expressionType", "expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression"], terms); 2827AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expressionType", "expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression"], terms); 2839AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expressionType"], terms); 2851AssertEx.SetEqual(["expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression", "ExpressionType", "flags", "ExpressionType.ValidExpression", "expressionType"], terms); 2885AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 2897AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 2909AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 2921AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 2933AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "flags"], terms); 2945AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "flags"], terms); 2957AssertEx.SetEqual(["expression", "(PostfixUnaryExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "postfixUnaryExpression"], terms); 2969AssertEx.SetEqual(["position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PostfixUnaryExpressionSyntax)expression"], terms); 2981AssertEx.SetEqual(["position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PostfixUnaryExpressionSyntax)expression"], terms); 2993AssertEx.SetEqual(["position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PostfixUnaryExpressionSyntax)expression"], terms); 3005AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms); 3017AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms); 3029AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms); 3041AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm"], terms); 3053AssertEx.SetEqual(["flags", "terms", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 3065AssertEx.SetEqual(["terms", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "ConvertToString"], terms); 3077AssertEx.SetEqual(["flags", "ExpressionType", "ExpressionType.ValidTerm", "terms", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "ConvertToString"], terms); 3111AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 3123AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "leftFlags", "rightFlags", "position", "expression", "terms", "expressionType"], terms); 3135AssertEx.SetEqual(["expression", "(BinaryExpressionSyntax)expression", "leftFlags", "ExpressionType", "ExpressionType.Invalid", "rightFlags", "binaryExpression"], terms); 3147AssertEx.SetEqual(["expression", "(BinaryExpressionSyntax)expression", "leftFlags", "ExpressionType", "ExpressionType.Invalid", "rightFlags", "binaryExpression"], terms); 3159AssertEx.SetEqual(["position", "binaryExpression", "binaryExpression.Left", "terms", "leftFlags", "CollectExpressionTerms", "expression", "(BinaryExpressionSyntax)expression"], terms); 3171AssertEx.SetEqual(["position", "binaryExpression", "binaryExpression.Right", "terms", "rightFlags", "CollectExpressionTerms", "binaryExpression.Left", "leftFlags"], terms); 3183AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm", "position", "binaryExpression", "binaryExpression.Right", "terms", "rightFlags", "CollectExpressionTerms"], terms); 3195AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm", "position", "binaryExpression", "binaryExpression.Right", "terms", "rightFlags", "CollectExpressionTerms"], terms); 3207AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm"], terms); 3219AssertEx.SetEqual(["leftFlags", "terms", "binaryExpression", "binaryExpression.Left", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 3231AssertEx.SetEqual(["terms", "binaryExpression", "binaryExpression.Left", "ConvertToString"], terms); 3243AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression", "binaryExpression.Left", "ConvertToString"], terms); 3255AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression", "binaryExpression.Left", "ConvertToString"], terms); 3267AssertEx.SetEqual(["rightFlags", "ExpressionType", "ExpressionType.ValidTerm"], terms); 3279AssertEx.SetEqual(["rightFlags", "terms", "binaryExpression", "binaryExpression.Right", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 3291AssertEx.SetEqual(["terms", "binaryExpression", "binaryExpression.Right", "ConvertToString"], terms); 3303AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3315AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3327AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3339AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3351AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3363AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3375AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3387AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3400AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3412AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "binaryExpression", "binaryExpression.Kind"], terms); 3424AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "binaryExpression", "binaryExpression.Kind"], terms); 3436AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType"], terms); 3448AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3460AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3472AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "binaryExpression", "binaryExpression.Kind"], terms); 3484AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid"], terms); 3496AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 3508AssertEx.SetEqual(["binaryExpression", "binaryExpression.Kind"], terms); 3542AssertEx.SetEqual(["position", "argumentList", "terms", "expressionType"], terms); 3554AssertEx.SetEqual(["validExpr", "position", "argumentList", "terms", "expressionType"], terms); 3566AssertEx.SetEqual(["arg", "argumentList", "argumentList.Arguments", "validExpr"], terms); 3578AssertEx.SetEqual(["arg", "argumentList", "argumentList.Arguments", "validExpr"], terms); 3590AssertEx.SetEqual(["arg", "argumentList", "argumentList.Arguments", "validExpr"], terms); 3602AssertEx.SetEqual(["arg", "argumentList", "argumentList.Arguments", "validExpr"], terms); 3614AssertEx.SetEqual(["arg", "argumentList", "argumentList.Arguments"], terms); 3626AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "arg", "argumentList", "argumentList.Arguments", "flags"], terms); 3638AssertEx.SetEqual(["position", "arg", "arg.Expression", "terms", "flags", "CollectExpressionTerms", "ExpressionType", "ExpressionType.Invalid"], terms); 3650AssertEx.SetEqual(["position", "arg", "arg.Expression", "terms", "flags", "CollectExpressionTerms", "ExpressionType", "ExpressionType.Invalid"], terms); 3662AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "arg", "arg.Expression", "terms", "flags", "CollectExpressionTerms"], terms); 3674AssertEx.SetEqual(["flags", "ExpressionType", "ExpressionType.ValidTerm"], terms); 3686AssertEx.SetEqual(["flags", "terms", "arg", "arg.Expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 3698AssertEx.SetEqual(["terms", "arg", "arg.Expression", "ConvertToString"], terms); 3710AssertEx.SetEqual(["flags", "ExpressionType", "ExpressionType.ValidExpression", "validExpr", "ExpressionType.ValidTerm", "terms", "arg", "arg.Expression", "ConvertToString"], terms); 3722AssertEx.SetEqual(["flags", "ExpressionType", "ExpressionType.ValidExpression", "validExpr", "ExpressionType.ValidTerm", "terms", "arg", "arg.Expression", "ConvertToString"], terms); 3734AssertEx.SetEqual(["flags", "ExpressionType", "ExpressionType.ValidExpression", "validExpr"], terms); 3746AssertEx.SetEqual(["flags", "ExpressionType", "validExpr", "ExpressionType.ValidExpression", "expressionType", "arg", "argumentList", "argumentList.Arguments"], terms); 3758AssertEx.SetEqual(["flags", "ExpressionType", "validExpr", "ExpressionType.ValidExpression", "expressionType", "arg", "argumentList", "argumentList.Arguments"], terms); 3770AssertEx.SetEqual(["flags", "ExpressionType", "validExpr", "ExpressionType.ValidExpression", "expressionType", "arg", "argumentList", "argumentList.Arguments"], terms); 3782AssertEx.SetEqual(["flags", "ExpressionType", "validExpr", "ExpressionType.ValidExpression", "expressionType", "arg", "argumentList", "argumentList.Arguments"], terms); 3794AssertEx.SetEqual(["ExpressionType", "validExpr", "ExpressionType.ValidExpression", "expressionType"], terms); 3828AssertEx.SetEqual(["position", "declarators", "terms"], terms); 3840AssertEx.SetEqual(["declarator", "declarators", "position", "terms"], terms); 3852AssertEx.SetEqual(["declarator", "declarators"], terms); 3864AssertEx.SetEqual(["declarator", "declarator.InitializerOpt", "declarators"], terms); 3876AssertEx.SetEqual(["declarator", "declarator.InitializerOpt"], terms); 3888AssertEx.SetEqual(["position", "declarator.InitializerOpt", "declarator.InitializerOpt.Value", "terms", "CollectExpressionTerms", "declarator"], terms); 3900AssertEx.SetEqual(["position", "declarator.InitializerOpt", "declarator.InitializerOpt.Value", "terms", "CollectExpressionTerms"], terms); 3912AssertEx.SetEqual(["declarator", "declarator.InitializerOpt", "position", "declarator.InitializerOpt.Value", "terms", "CollectExpressionTerms"], terms); 3924AssertEx.SetEqual(["declarator", "declarators", "position", "declarator.InitializerOpt", "declarator.InitializerOpt.Value", "terms", "CollectExpressionTerms"], terms);

28AssertEx.SetEqual(["expression"], terms); 42AssertEx.SetEqual(["expression"], terms); 56AssertEx.SetEqual(["position", "expression", "terms"], terms); 70AssertEx.SetEqual(["expression", "position", "terms"], terms); 84AssertEx.SetEqual(["expression"], terms); 98AssertEx.SetEqual(["expression"], terms); 112AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expression", "expressionType"], terms); 126AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectExpressionTerms", "ExpressionType", "ExpressionType.Invalid"], terms); 140AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "expression", "terms", "expressionType", "CollectExpressionTerms"], terms); 154AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm"], terms); 168AssertEx.SetEqual(["terms", "expressionType", "expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 182AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 196AssertEx.SetEqual(["expression", "position", "terms", "expressionType"], terms); 210AssertEx.SetEqual(["expression"], terms); 224AssertEx.SetEqual(["expression"], terms); 238AssertEx.SetEqual(["expression", "expression.Kind"], terms); 252AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 266AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms); 280AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm", "expression", "expression.Kind"], terms); 294AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidTerm"], terms); 308AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "expression", "expression.Kind"], terms); 322AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression"], terms); 336AssertEx.SetEqual(["position", "terms", "expressionType", "CollectExpressionTerms", "expression", "expression.Kind"], terms); 350AssertEx.SetEqual(["expression", "position", "terms", "expressionType", "CollectExpressionTerms"], terms); 364AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectMemberAccessExpressionTerms", "expression.Kind"], terms); 378AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectMemberAccessExpressionTerms"], terms); 392AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectObjectCreationExpressionTerms", "expression.Kind"], terms); 406AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectObjectCreationExpressionTerms"], terms); 420AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectArrayCreationExpressionTerms", "expression.Kind"], terms); 434AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectArrayCreationExpressionTerms"], terms); 448AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectInvocationExpressionTerms", "expression.Kind"], terms); 462AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectInvocationExpressionTerms"], terms); 476AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax", "expression.Kind"], terms); 490AssertEx.SetEqual(["expression", "PrefixUnaryExpressionSyntax"], terms); 504AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPrefixUnaryExpressionTerms", "PrefixUnaryExpressionSyntax"], terms); 518AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPrefixUnaryExpressionTerms"], terms); 532AssertEx.SetEqual(["expression", "PostfixUnaryExpressionSyntax", "PrefixUnaryExpressionSyntax"], terms); 546AssertEx.SetEqual(["expression", "PostfixUnaryExpressionSyntax"], terms); 560AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPostfixUnaryExpressionTerms", "PostfixUnaryExpressionSyntax"], terms); 574AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectPostfixUnaryExpressionTerms"], terms); 588AssertEx.SetEqual(["expression", "BinaryExpressionSyntax", "PostfixUnaryExpressionSyntax"], terms); 602AssertEx.SetEqual(["expression", "BinaryExpressionSyntax"], terms); 616AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectBinaryExpressionTerms", "BinaryExpressionSyntax"], terms); 630AssertEx.SetEqual(["position", "expression", "terms", "expressionType", "CollectBinaryExpressionTerms"], terms); 644AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "expression", "BinaryExpressionSyntax"], terms); 658AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 672AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "flags", "position", "expression", "terms", "expressionType"], terms); 686AssertEx.SetEqual(["expression", "(MemberAccessExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "memberAccess"], terms); 700AssertEx.SetEqual(["position", "memberAccess", "memberAccess.Expression", "terms", "flags", "CollectExpressionTerms", "expression", "(MemberAccessExpressionSyntax)expression"], terms); 714AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "position", "memberAccess", "memberAccess.Expression", "terms", "flags", "CollectExpressionTerms"], terms); 728AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression"], terms); 742AssertEx.SetEqual(["flags", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm", "expression", "SyntaxKind", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression"], terms); 756AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression", "ExpressionType.ValidTerm", "SyntaxKind.MemberAccessExpression", "SyntaxKind.PointerMemberAccessExpression", "terms", "memberAccess", "memberAccess.Expression", "ConvertToString"], terms); 770AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms); 784AssertEx.SetEqual(["ExpressionType", "flags", "expressionType", "ExpressionType.ValidTerm", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms); 798AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms); 812AssertEx.SetEqual(["ExpressionType", "flags", "expressionType", "ExpressionType.ValidExpression", "expression", "SyntaxKind", "SyntaxKind.InvocationExpression"], terms); 826AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 840AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 854AssertEx.SetEqual(["expression", "(ObjectCreationExpressionSyntax)expression", "ExpressionType", "expressionType", "ExpressionType.Invalid", "objectionCreation"], terms); 868AssertEx.SetEqual(["objectionCreation", "objectionCreation.ArgumentListOpt", "expression", "(ObjectCreationExpressionSyntax)expression"], terms); 882AssertEx.SetEqual(["objectionCreation", "objectionCreation.ArgumentListOpt"], terms); 896AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "objectionCreation", "objectionCreation.ArgumentListOpt", "flags"], terms); 910AssertEx.SetEqual(["position", "objectionCreation", "objectionCreation.ArgumentListOpt", "terms", "flags", "CollectArgumentTerms", "ExpressionType", "ExpressionType.Invalid"], terms); 924AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "objectionCreation", "objectionCreation.ArgumentListOpt", "terms", "flags", "CollectArgumentTerms"], terms); 938AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm"], terms); 952AssertEx.SetEqual(["ExpressionType", "flags", "expressionType", "ExpressionType.ValidExpression", "ExpressionType.ValidTerm"], terms); 966AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 980AssertEx.SetEqual(["validTerm", "position", "expression", "terms", "expressionType"], terms); 994AssertEx.SetEqual(["expression", "(ArrayCreationExpressionSyntax)expression", "validTerm", "arrayCreation"], terms); 1008AssertEx.SetEqual(["arrayCreation", "arrayCreation.InitializerOpt", "expression", "(ArrayCreationExpressionSyntax)expression"], terms); 1022AssertEx.SetEqual(["arrayCreation", "arrayCreation.InitializerOpt"], terms); 1036AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "arrayCreation", "arrayCreation.InitializerOpt", "flags"], terms); 1050AssertEx.SetEqual(["arrayCreation.InitializerOpt.Expressions", "flags", "ExpressionType", "ExpressionType.Invalid"], terms); 1064AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm", "validTerm", "arrayCreation.InitializerOpt.Expressions"], terms); 1078AssertEx.SetEqual(["flags", "validTerm", "arrayCreation", "arrayCreation.InitializerOpt", "ExpressionType", "ExpressionType.ValidTerm"], terms); 1092AssertEx.SetEqual(["validTerm"], terms); 1106AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.ValidExpression", "validTerm"], terms); 1120AssertEx.SetEqual(["validTerm"], terms); 1134AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "validTerm"], terms); 1148AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 1162AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 1176AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "leftFlags", "rightFlags"], terms); 1190AssertEx.SetEqual(["expression", "(InvocationExpressionSyntax)expression", "leftFlags", "ExpressionType", "ExpressionType.Invalid", "rightFlags", "invocation"], terms); 1204AssertEx.SetEqual(["position", "invocation", "invocation.Expression", "terms", "leftFlags", "CollectExpressionTerms", "expression", "(InvocationExpressionSyntax)expression"], terms); 1218AssertEx.SetEqual(["position", "invocation", "invocation.ArgumentList", "terms", "rightFlags", "CollectArgumentTerms", "invocation.Expression", "leftFlags", "CollectExpressionTerms"], terms); 1232AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm", "position", "invocation", "invocation.ArgumentList", "terms", "rightFlags", "CollectArgumentTerms"], terms); 1246AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm"], terms); 1260AssertEx.SetEqual(["leftFlags", "terms", "invocation", "invocation.Expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 1274AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "ExpressionType.ValidTerm", "terms", "invocation", "invocation.Expression", "ConvertToString"], terms); 1288AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 1302AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 1316AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "flags"], terms); 1330AssertEx.SetEqual(["expression", "(PrefixUnaryExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "prefixUnaryExpression"], terms); 1344AssertEx.SetEqual(["position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PrefixUnaryExpressionSyntax)expression"], terms); 1358AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms); 1372AssertEx.SetEqual(["flags", "ExpressionType", "ExpressionType.ValidTerm"], terms); 1386AssertEx.SetEqual(["flags", "terms", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 1400AssertEx.SetEqual(["flags", "expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression", "ExpressionType", "ExpressionType.ValidTerm", "terms", "prefixUnaryExpression", "prefixUnaryExpression.Operand", "ConvertToString"], terms); 1414AssertEx.SetEqual(["expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression"], terms); 1428AssertEx.SetEqual(["flags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "expression", "SyntaxKind", "SyntaxKind.LogicalNotExpression", "SyntaxKind.BitwiseNotExpression", "SyntaxKind.NegateExpression", "SyntaxKind.PlusExpression"], terms); 1442AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 1456AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "position", "expression", "terms"], terms); 1470AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "expressionType", "flags"], terms); 1484AssertEx.SetEqual(["expression", "(PostfixUnaryExpressionSyntax)expression", "flags", "ExpressionType", "ExpressionType.Invalid", "postfixUnaryExpression"], terms); 1498AssertEx.SetEqual(["position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms", "expression", "(PostfixUnaryExpressionSyntax)expression"], terms); 1512AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "terms", "flags", "CollectExpressionTerms"], terms); 1526AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm"], terms); 1540AssertEx.SetEqual(["flags", "terms", "postfixUnaryExpression", "postfixUnaryExpression.Operand", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 1554AssertEx.SetEqual(["position", "expression", "terms", "expressionType"], terms); 1568AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "leftFlags", "rightFlags", "position", "expression", "terms", "expressionType"], terms); 1582AssertEx.SetEqual(["expression", "(BinaryExpressionSyntax)expression", "leftFlags", "ExpressionType", "ExpressionType.Invalid", "rightFlags", "binaryExpression"], terms); 1596AssertEx.SetEqual(["position", "binaryExpression", "binaryExpression.Left", "terms", "leftFlags", "CollectExpressionTerms", "expression", "(BinaryExpressionSyntax)expression"], terms); 1610AssertEx.SetEqual(["position", "binaryExpression", "binaryExpression.Right", "terms", "rightFlags", "CollectExpressionTerms", "binaryExpression.Left", "leftFlags"], terms); 1624AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm", "position", "binaryExpression", "binaryExpression.Right", "terms", "rightFlags", "CollectExpressionTerms"], terms); 1638AssertEx.SetEqual(["ExpressionType", "leftFlags", "ExpressionType.ValidTerm"], terms); 1652AssertEx.SetEqual(["leftFlags", "terms", "binaryExpression", "binaryExpression.Left", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 1666AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression", "binaryExpression.Left", "ConvertToString"], terms); 1680AssertEx.SetEqual(["rightFlags", "ExpressionType", "ExpressionType.ValidTerm"], terms); 1694AssertEx.SetEqual(["terms", "rightFlags", "binaryExpression", "binaryExpression.Right", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 1708AssertEx.SetEqual(["rightFlags", "binaryExpression", "binaryExpression.Kind", "ExpressionType", "ExpressionType.ValidTerm", "terms", "binaryExpression.Right", "ConvertToString"], terms); 1722AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType", "binaryExpression", "binaryExpression.Kind"], terms); 1736AssertEx.SetEqual(["leftFlags", "rightFlags", "ExpressionType", "ExpressionType.ValidExpression", "expressionType"], terms); 1750AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid", "binaryExpression", "binaryExpression.Kind"], terms); 1764AssertEx.SetEqual(["ExpressionType", "expressionType", "ExpressionType.Invalid"], terms); 1778AssertEx.SetEqual(["position", "argumentList", "terms", "expressionType"], terms); 1792AssertEx.SetEqual(["validExpr", "position", "argumentList", "terms", "expressionType"], terms); 1806AssertEx.SetEqual(["arg", "argumentList", "argumentList.Arguments", "validExpr"], terms); 1820AssertEx.SetEqual(["arg", "argumentList", "argumentList.Arguments"], terms); 1834AssertEx.SetEqual(["ExpressionType", "ExpressionType.Invalid", "arg", "argumentList", "argumentList.Arguments", "flags"], terms); 1848AssertEx.SetEqual(["position", "arg", "arg.Expression", "terms", "flags", "CollectExpressionTerms", "ExpressionType", "ExpressionType.Invalid"], terms); 1862AssertEx.SetEqual(["ExpressionType", "ExpressionType.ValidTerm", "position", "arg", "arg.Expression", "terms", "flags", "CollectExpressionTerms"], terms); 1876AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidTerm"], terms); 1890AssertEx.SetEqual(["flags", "terms", "arg", "arg.Expression", "ConvertToString", "ExpressionType", "ExpressionType.ValidTerm"], terms); 1904AssertEx.SetEqual(["ExpressionType", "flags", "ExpressionType.ValidExpression", "validExpr", "ExpressionType.ValidTerm", "terms", "arg", "arg.Expression", "ConvertToString"], terms); 1918AssertEx.SetEqual(["flags", "ExpressionType", "validExpr", "ExpressionType.ValidExpression", "expressionType", "arg", "argumentList", "argumentList.Arguments"], terms); 1932AssertEx.SetEqual(["position", "declarators", "terms"], terms); 1946AssertEx.SetEqual(["declarator", "declarators", "position", "terms"], terms); 1960AssertEx.SetEqual(["declarator", "declarators"], terms); 1974AssertEx.SetEqual(["declarator", "declarator.InitializerOpt", "declarators"], terms); 1988AssertEx.SetEqual(["declarator", "declarator.InitializerOpt"], terms); 2002AssertEx.SetEqual(["position", "declarator.InitializerOpt", "declarator.InitializerOpt.Value", "terms", "CollectExpressionTerms", "declarator"], terms);

261AssertEx.Equal(expected, test.ToString());

341AssertEx.Any(diagnostics, d => d.Id == DocumentAnalysisExecutor.AnalyzerExceptionDiagnosticId);

52AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList); 64AssertEx.SetEqual(expectedApplicableAccessibilityList, symbolSpec.ApplicableAccessibilityList); 122AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList); 183AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList); 191AssertEx.SetEqual(expectedApplicableAccessibilityList, symbolSpec.ApplicableAccessibilityList); 231AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList); 272AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList); 311AssertEx.SetEqual(expectedApplicableSymbolKindList, symbolSpec.ApplicableSymbolKindList); 455AssertEx.SetEqual(expectedApplicableTypeKindList, symbolSpec.ApplicableSymbolKindList);

79AssertEx.Equal( 86AssertEx.Equal(["(0,10)-(0,15)", "(0,20)-(0,25)"], spans2.Select(s => s.LineSpan.ToString())); 93AssertEx.Equal( 99AssertEx.Empty(await trackingSession.GetAdjustedTrackingSpansAsync(document2, snapshot2, CancellationToken.None)); 106AssertEx.Equal( 117AssertEx.Equal(

336var update = AssertEx.Single(updates); 359var update = AssertEx.Single(updates); 372update = AssertEx.Single(updates); 392var update = AssertEx.Single(updates);

103AssertEx.EqualOrDiff(expected, actual);

2930AssertEx.EqualOrDiff(expected, newSnapshot.GetText());

76AssertEx.Equal(@"

89AssertEx.EqualOrDiff(expectedTexts[i], actualDocumentTexts[i]);

171AssertEx.Equal(Enumerable(new Span(62, 1), new Span(71, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start)); 183AssertEx.Equal(Enumerable(new Span(62, 1), new Span(71, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start)); 187AssertEx.Equal(Enumerable(new Span(82, 1), new Span(138, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start)); 199AssertEx.Equal(Enumerable(new Span(82, 1), new Span(138, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start));

116AssertEx.EqualOrDiff(expected, actual.ToString()); 154AssertEx.NotNull(file, $"No source document was found in the pdb for the symbol."); 234AssertEx.NotNull(symbol, $"Couldn't find symbol to go-to-def for.");

799AssertEx.NotNull(actualText); 800AssertEx.NotNull(actualText.Encoding); 801AssertEx.Equal(encoding.WebName, actualText.Encoding.WebName); 802AssertEx.EqualOrDiff(source, actualText.ToString()); 828AssertEx.NotNull(actualText); 829AssertEx.NotNull(actualText.Encoding); 830AssertEx.Equal(encoding.WebName, actualText.Encoding.WebName); 831AssertEx.EqualOrDiff(source, actualText.ToString()); 857AssertEx.NotNull(actualText); 858AssertEx.NotNull(actualText.Encoding); 859AssertEx.Equal(encoding.WebName, actualText.Encoding.WebName); 860AssertEx.EqualOrDiff(source, actualText.ToString()); 949AssertEx.NotNull(symbol, $"Couldn't find symbol to go-to-def for.");

84AssertEx.NotNull(info); 146AssertEx.NotNull(info); 315AssertEx.NotNull(info);

75AssertEx.AreEqual<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>?>(expectedContext, context, comparer: ContextDictionaryComparer.Instance);

1425AssertEx.SetEqual(workspace.Projects.SelectMany(p => p.Documents).Select(d => d.Id), eventArgs.Select(e => e.DocumentId));

74AssertEx.Equal(expectedTree!.Replace("\"", "\"\""), actualTree); 82AssertEx.Equal(RemoveMessagesInNonSupportedLanguage(expectedDiagnostics).Replace("\"", "\"\""), actualDiagnostics);

98AssertEx.NotNull(result);

1145AssertEx.SetEqual(new[] { "AsyncIteratorStateMachineAttribute" }, 1868AssertEx.SetEqual(new[] { 1888AssertEx.SetEqual(new[] { 2409AssertEx.SetEqual(new[] { 2430AssertEx.SetEqual(new[] { 4218AssertEx.SetEqual(expectedFields, fields);

238AssertEx.Equal(new[] 251AssertEx.Equal(new[] 290AssertEx.Equal(new[] 308AssertEx.Equal(new[] 997AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 1155AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 1249AssertEx.Equal(new[]

947AssertEx.Equal(new[] 962AssertEx.Equal(new[]

211AssertEx.Equal(expectedCtx[depth], ctx.VariablesByScope[depth]);

3973AssertEx.Equal(new[] 3982AssertEx.SetEqual(new[] 3992AssertEx.SetEqual(new[] 4002AssertEx.SetEqual(new[] 4012AssertEx.SetEqual(new[] 4044AssertEx.Equal(new[] 4085AssertEx.SetEqual(new[]

595AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(container.GetAttributes())); 649AssertEx.SetEqual(new[] { "<>p__0", "<>p__1", "<>p__2" }, memberNames); 832AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(d.GetAttributes()));

1003AssertEx.All(classCMembers.Select(m => m.Name), name => name == WellKnownMemberNames.InstanceConstructorName || name.StartsWith("Q::I.", StringComparison.Ordinal)); 1004AssertEx.All(classCMembers.Select(m => m.MetadataName), metadataName => metadataName == WellKnownMemberNames.InstanceConstructorName || metadataName.StartsWith("Q::I.", StringComparison.Ordinal)); 1005AssertEx.None(classCMembers.Select(m => m.ToString()), id => id.Contains("Q")); 1006AssertEx.None(classCMembers.Select(m => m.GetDocumentationCommentId()), id => id.Contains("Q"));

123AssertEx.Equal("delegate* unmanaged[Thiscall, Stdcall]<System.Void modopt(System.Runtime.CompilerServices.CallConvThiscall) modopt(System.Runtime.CompilerServices.CallConvStdcall)>", funcPtr.ToTestDisplayString()); 3083AssertEx.Equal(expectedMembers, model.GetMemberGroup(addressOfs[0].Operand).Select(m => m.ToTestDisplayString(includeNonNullable: false))); 3084AssertEx.Equal(expectedMembers, model.GetMemberGroup(addressOfs[1].Operand).Select(m => m.ToTestDisplayString(includeNonNullable: false))); 4125AssertEx.Equal(new[] { "void C.M1()" }, model.GetMemberGroup(methodGroup1).Select(m => m.ToTestDisplayString(includeNonNullable: false))); 6483AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 6536AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 6594AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString()); 6660AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 6738AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 6817AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 10810AssertEx.Equal("System.Func<delegate*<System.Int32, System.Void>>", 10812AssertEx.Equal("System.Func<delegate*<System.Int32, System.Void>>", 10819AssertEx.Equal("System.Func<delegate* unmanaged<System.Int32, System.Void>>",

2746AssertEx.Equal(baseMethods, interfaceMethods.Select(interfaceMethod => derivedType.FindImplementationForInterfaceMember(interfaceMethod)));

1178AssertEx.Equal(new[] 1195AssertEx.Equal(new[] 1235AssertEx.Equal(new[] 1251AssertEx.Equal(new[] 1283AssertEx.Equal(new[] 1295AssertEx.Equal(new[]

5360AssertEx.Equal(new[] { "NullableContextAttribute", "CompilerGeneratedAttribute" }, attrs1.Select(a => a.AttributeClass.Name));

4478AssertEx.Equal(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2" }, vt2.TupleElements.ToTestDisplayStrings()); 4481AssertEx.Equal(new[] { 5940AssertEx.SetEqual(vt2.MemberNames.ToArray(), new[] { ".ctor", "ToString" }); 6086AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, System.ValueTuple<System.String>[missing]>[missing]", 6136AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, (System.String, System.Int32)[missing]>[missing]", 6486AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, System.ValueTuple<System.String>[missing]>[missing]", 6506AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, (System.String, System.Int32)[missing]>[missing]", 6527AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, (System.String, System.Int32)[missing]>[missing]", 11167AssertEx.SetEqual(new[] { 11185AssertEx.SetEqual(new[] { 11430AssertEx.Equal(new[] { 11457AssertEx.Equal(new[] { 11494AssertEx.Equal(new[] { "T1", "T2", "T3", "T4", "T5", "T6", "T7", "TRest" }, m1Tuple.TypeParameters.ToTestDisplayStrings()); 11499AssertEx.Equal(new[] { "System.Int32", "System.Int32", "System.Int32", "System.Int32", "System.Int32", "System.Int32", "System.Int32", "(System.Int32, System.Int32)" }, 12699AssertEx.Equal(new[] { 13878AssertEx.Equal(baseLine, symbols.Select(s => s.ToTestDisplayString())); 14101AssertEx.Equal("System.ValueTuple<System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, (System.Int32 a, System.Int32 b)>", 16577AssertEx.Equal(new[] { 16582AssertEx.Equal("System.Int32 (System.Int32, System.Int32)[missing].Item1", 16614AssertEx.Equal(new[] { 16621AssertEx.Equal("System.Int32 (System.Int32 a, System.Int32 b)[missing].Item1", 16624AssertEx.Equal("System.Int32 (System.Int32 a, System.Int32 b)[missing].a", 22776AssertEx.SetEqual(new[] { "mscorlib 4.0", "System.ValueTuple 4.0" }, reader.DumpAssemblyReferences()); 22785AssertEx.SetEqual(new[] { "mscorlib 4.0", "System.ValueTuple 4.0" }, reader.DumpAssemblyReferences()); 22816AssertEx.SetEqual(new[] { "mscorlib 4.0", "lib 0.0" }, reader.DumpAssemblyReferences()); 22825AssertEx.SetEqual(new[] { "mscorlib 4.0", "lib 0.0" }, reader.DumpAssemblyReferences()); 22859AssertEx.SetEqual(xSymbol.GetMembers().OfType<IFieldSymbol>().Select(f => f.Name), 26825AssertEx.Equal("System.ValueTuple<System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.ValueTuple<System.Int32>[missing]>[missing]", tuple.ToTestDisplayString()); 26878AssertEx.Equal("System.Collections.Generic.IEnumerable<Container<(System.Int32 alice, System.Int32 bob)>[missing]>", 26950AssertEx.Equal(decodingSuccessful 27984AssertEx.SetEqual(new string[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "(T1, T2)..ctor()" }, 27986AssertEx.SetEqual(new string[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "(T1, T2)..ctor()" }, 28071AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2" }, fields.ToTestDisplayStrings()); 28201AssertEx.SetEqual(new[] { 28207AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2" }, 28310AssertEx.SetEqual(new[] { "System.ValueTuple<T1>", 28406AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "System.String (T1, T2).field" }, namedType.GetFieldsToEmit().ToTestDisplayStrings()); 28409AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "System.String (T1, T2).field" }, fields.ToTestDisplayStrings()); 28494AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "System.String (T1, T2).<Property>k__BackingField" }, fields.ToTestDisplayStrings()); 28695AssertEx.SetEqual(new[] { 28703AssertEx.SetEqual(new[] { 28711AssertEx.SetEqual(new[] { 28723AssertEx.SetEqual(new[] { 28735AssertEx.SetEqual(new[] { 28750AssertEx.SetEqual(new[] { 28809AssertEx.SetEqual(new[] { 28831AssertEx.SetEqual(new[] { 28854AssertEx.SetEqual(new[] { 28892AssertEx.SetEqual(new[] { 28905AssertEx.SetEqual(new[] { 29003AssertEx.Equal("System.ValueTuple<System.Object, System.Object, System.Object, System.Object, System.Object, System.Object, System.Object, (System.Object, System.Object)>", 29021AssertEx.Equal("System.ValueTuple<System.Object!, System.Object?, System.Object!, System.Object?, System.Object!, System.Object?, System.Object!, (System.Object?, System.Object!)>", 29035AssertEx.Equal($"System.Object{nullabilityString} System.ValueTuple<System.Object!, System.Object?, System.Object!, System.Object?, System.Object!, System.Object?, System.Object!, (System.Object?, System.Object!)>.{name}", 29062AssertEx.Equal($"System.Object{nullabilityString} System.ValueTuple<System.Object!, System.Object?, System.Object!, System.Object?, System.Object!, System.Object?, System.Object!, (System.Object?, System.Object!)>.Item{i + 1}",

43AssertEx.SetEqual(actualMembers.Select(s => s.Name), expectedMembers);

658AssertEx.Equal(new[] { ".text", ".rsrc", ".reloc", ".mvid" }, 899AssertEx.Equal( 913AssertEx.Equal(new[] { 934AssertEx.SetEqual(attributes.Select(a => MetadataReaderUtils.Dump(reader, reader.GetCustomAttribute(a).Constructor)), 956AssertEx.Equal(new string[] { 1214AssertEx.Equal(image1.GetBuffer(), image2.GetBuffer(), message: $"Expecting match for includePrivateMembers={includePrivateMembers} case, but differences were found."); 1218AssertEx.NotEqual(image1.GetBuffer(), image2.GetBuffer(), message: $"Expecting difference for includePrivateMembers={includePrivateMembers} case, but they matched."); 1262AssertEx.NotEqual(image1, image2, message: "Expecting different main assemblies produced by refout"); 1263AssertEx.Equal(metadataImage1, metadataImage2, message: "Expecting identical ref assemblies produced by refout"); 1272AssertEx.Equal(refOnlyMetadataImage1, refOnlyMetadataImage2, message: "Expecting identical ref assemblies produced by refonly"); 1911AssertEx.Equal(refOut1, refOut1); 1921AssertEx.Equal(refOut1, refOut15); 1935AssertEx.NotEqual(refOut1, refOut2); 1936AssertEx.NotEqual(refOut1, refOnly2); 1941AssertEx.Equal(refOut1, refOut2); 1942AssertEx.Equal(refOut1, refOnly2); 2134AssertEx.Equal( 2138AssertEx.Equal( 2149AssertEx.Equal( 2165AssertEx.Equal( 2169AssertEx.Equal( 2180AssertEx.Equal( 2193AssertEx.Equal( 2197AssertEx.Equal( 2207AssertEx.Equal( 2222AssertEx.Equal( 2226AssertEx.Equal( 2233AssertEx.Equal( 2300AssertEx.Equal( 2304AssertEx.Equal( 2367AssertEx.Equal( 2371AssertEx.Equal( 2434AssertEx.Equal( 2438AssertEx.Equal( 2469AssertEx.Equal( 2473AssertEx.Equal(new[] { "Microsoft.CodeAnalysis" }, globalNamespace.GetMember<NamespaceSymbol>("Microsoft").GetMembers().Select(m => m.ToDisplayString())); 2474AssertEx.Equal( 2478AssertEx.Equal( 2481AssertEx.Equal( 2485AssertEx.Equal( 2511AssertEx.Equal( 2515AssertEx.Equal( 2624AssertEx.Equal(expected, entries.Select(e => e.Type)); 3923AssertEx.SetEqual(expectedCMembers, actualCMembers.Select(s => s.Name)); 3946AssertEx.SetEqual(expectedAMembers, actualAMembers.Select(s => s.Name)); 3951AssertEx.SetEqual(expectedBMembers, actualBMembers.Select(s => s.Name)); 3956AssertEx.SetEqual(expectedCMembers, actualCMembers.Select(s => s.Name)); 5375AssertEx.Equal(expectedNames, actualNames); 5438AssertEx.Equal(expectedNames, actualNames);

155AssertEx.NotEqual(result1.pe, result2.pe); 220AssertEx.Equal(result1.pe, result2.pe); 221AssertEx.Equal(result1.pdb, result2.pdb); 225AssertEx.Equal(result3.pe, result4.pe); 226AssertEx.Equal(result3.pdb, result4.pdb); 230AssertEx.Equal(result5.pe, result6.pe); 231AssertEx.Equal(result5.pdb, result6.pdb); 247AssertEx.Equal(result1.pe, result2.pe); 248AssertEx.Equal(result1.pdb, result2.pdb); 252AssertEx.Equal(result3.pe, result4.pe); 253AssertEx.Equal(result3.pdb, result4.pdb); 257AssertEx.Equal(result5.pe, result6.pe); 258AssertEx.Equal(result5.pdb, result6.pdb);

1066AssertEx.Equal(expected, reader.GetSpans(methodData.Blob).Select(s => $"({s.StartLine},{s.StartColumn})-({s.EndLine},{s.EndColumn})")); 1080AssertEx.Equal(expected, actual);

90AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 270AssertEx.Equal(new[] 2309AssertEx.Equal(new byte[] 2322AssertEx.Equal(new byte[] 2349AssertEx.Equal(new byte[] { 0xFF, 0x25, 0x00, 0x20, 0x00, 0x10, 0x00, 0x00 }, startupStub); 2407AssertEx.Equal(new byte[] { 0, 0x20, 0, 0, 0x0c, 0, 0, 0, 0x80, 0x33, 0, 0 }, relocBytes);

2072AssertEx.NotNull(container); 2133AssertEx.NotNull(container); 2190AssertEx.NotNull(container); 2196AssertEx.NotNull(m); 6307AssertEx.NotNull(field); 6357AssertEx.NotNull(container); 6361AssertEx.SetEqual(expectedFields, fields); 6370AssertEx.NotNull(containingType);

97AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL); 171AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL); 508AssertEx.Equal(expected, reader.GetAssemblyReferences().Select(aref => $"{reader.GetString(aref.Name)}, {aref.Version}"));

163AssertEx.Equal( 174AssertEx.Equal( 185AssertEx.Equal( 196AssertEx.Equal( 203AssertEx.Equal(rows, reader.GetCustomAttributeRows(), itemInspector: AttributeRowToString); 227AssertEx.Equal(expectedValue, attributeData); 236AssertEx.Equal(expectedValue, attributeData);

9542AssertEx.Equal(new[] { "[0x23000002] System.Object" }, DumpTypeRefs(new[] { md0.MetadataReader, md1.Reader })); 9565AssertEx.Equal(new[] { "[0x23000003] System.Object" }, DumpTypeRefs(new[] { md0.MetadataReader, md1.Reader, md2.Reader })); 9652AssertEx.Equal(new[] { "[0x23000003] System.Object" }, DumpTypeRefs(new[] { md0.MetadataReader, md1.Reader, md2.Reader }));

574AssertEx.SetEqual(fields.Select(f => f.Name), new[] { "x1", "x2" }); 1128AssertEx.SetEqual(fields.Select(f => f.Name), new[] { "x", "y1", "y2" }); 1592AssertEx.SetEqual(new[] 1662AssertEx.SetEqual(new[]

577AssertEx.Equal(expectedMembers, actualMembers); 711AssertEx.Equal(expectedLocals, actualLocals); 1927AssertEx.Equal(expectedOperators, actualOperators); 1991AssertEx.Equal(expectedOperators, actualOperators);

74AssertEx.Equal(new[] { DebugDirectoryEntryType.CodeView, DebugDirectoryEntryType.PdbChecksum, DebugDirectoryEntryType.Reproducible, DebugDirectoryEntryType.EmbeddedPortablePdb }, entries.Select(e => e.Type));

2051AssertEx.AssertEqualToleratingWhitespaceDifferences(@"

915AssertEx.Equal(new[] 933AssertEx.Equal(new[] 1644AssertEx.AssertEqualToleratingWhitespaceDifferences(@"

57AssertEx.Equal(sourceLinkBlob, actualData); 99AssertEx.Equal(sourceLinkBlob, actualBlob); 192AssertEx.Equal(sourceLinkBlob, actualData);

3328AssertEx.AssertEqualToleratingWhitespaceDifferences(@"

79AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 88AssertEx.Equal(new byte[] 135AssertEx.AssertEqualToleratingWhitespaceDifferences("0: (12,31)-(12,36)", spString); 136AssertEx.Equal(new byte[] 177AssertEx.Equal(new[] { DebugDirectoryEntryType.CodeView, DebugDirectoryEntryType.PdbChecksum, DebugDirectoryEntryType.EmbeddedPortablePdb }, entries.Select(e => e.Type)); 192AssertEx.Equal(new[] { "goo.cs" }, mdReader.Documents.Select(doc => mdReader.GetString(mdReader.GetDocument(doc).Name))); 237AssertEx.Equal(new[] { DebugDirectoryEntryType.CodeView, DebugDirectoryEntryType.PdbChecksum, DebugDirectoryEntryType.Reproducible, DebugDirectoryEntryType.EmbeddedPortablePdb }, entries.Select(e => e.Type)); 253AssertEx.Equal(new[] { "goo.cs" }, mdReader.Documents.Select(doc => mdReader.GetString(mdReader.GetDocument(doc).Name))); 317AssertEx.Equal(sourceLinkBlob, actualBlob); 360AssertEx.Equal(sourceLinkBlob, actualBlob);

481AssertEx.Equal(expected, actual, itemSeparator: ",\n", itemInspector: i => $"(\"{i.typeName}\", \"{i.documentName}\")");

1805AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop1.GetMethod.GetAttributes())); 1806AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop1.SetMethod.GetAttributes())); 1809AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(1)" }), GetAttributeStrings(field1.GetAttributes())); 1813AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop2.GetMethod.GetAttributes())); 1817AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(2)" }), GetAttributeStrings(field2.GetAttributes())); 1821AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop3.GetMethod.GetAttributes())); 1825AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(33)" }), GetAttributeStrings(field3.GetAttributes())); 1829AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop3.GetMethod.GetAttributes())); 1833AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(44)", "A(444)" }), GetAttributeStrings(field4.GetAttributes())); 1866AssertEx.SetEqual(s_backingFieldAttributes.Concat(dynamicAndTupleNames), GetAttributeStrings(field1.GetAttributes())); 1904AssertEx.SetEqual(new[] { "System.Runtime.CompilerServices.SpecialNameAttribute" }, GetAttributeStrings(attributes1)); 1908AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(attributes1)); 1916AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(field2.GetAttributes())); 1923AssertEx.SetEqual(new[] { "System.Runtime.CompilerServices.SpecialNameAttribute" }, GetAttributeStrings(attributes3)); 1966AssertEx.SetEqual(new[] { "System.NonSerializedAttribute" }, GetAttributeStrings(attributes1)); 1970AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(attributes1)); 1978AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(field2.GetAttributes())); 1985AssertEx.SetEqual(new[] { "System.NonSerializedAttribute" }, GetAttributeStrings(attributes3)); 2202AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "System.Runtime.CompilerServices.DateTimeConstantAttribute(123456)" }), 2209AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "System.Runtime.CompilerServices.DateTimeConstantAttribute(123456)" }), 2253AssertEx.SetEqual(fieldAttributesExpected.Concat(decimalAttributeExpected), GetAttributeStrings(field1.GetAttributes())); 2257AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(field1.GetAttributes())); 2265AssertEx.SetEqual(fieldAttributesExpected.Concat(decimalAttributeExpected), GetAttributeStrings(field2.GetAttributes())); 2270AssertEx.SetEqual(decimalAttributeExpected, GetAttributeStrings(field3.GetAttributes())); 2333AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "System.ObsoleteAttribute" }), 2343AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { @"System.ObsoleteAttribute(""obsolete"", true)" }), 2465AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop1.GetMethod.GetAttributes())); 2466AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop1.SetMethod.GetAttributes())); 2469AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(1)" }), GetAttributeStrings(field1.GetAttributes())); 2475AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop2.GetMethod.GetAttributes())); 2476AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop2.SetMethod.GetAttributes())); 2479AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(field2.GetAttributes())); 2635AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event1.AddMethod.GetAttributes())); 2636AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event1.RemoveMethod.GetAttributes())); 2645AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event2.AddMethod.GetAttributes())); 2646AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event2.RemoveMethod.GetAttributes())); 2654AssertEx.SetEqual(accessorsExpected.Concat(new[] { "CC" }), GetAttributeNames(event3.AddMethod.GetAttributes())); 2655AssertEx.SetEqual(accessorsExpected.Concat(new[] { "CC" }), GetAttributeNames(event3.RemoveMethod.GetAttributes())); 2663AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event4.AddMethod.GetAttributes())); 2664AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event4.RemoveMethod.GetAttributes()));

1820Assert.True(expectedStr.Equals(actualStr), AssertEx.GetAssertMessage(expectedStr, actualStr)); 1846AssertEx.SetEqual(new[] 2299AssertEx.Equal("System.Runtime.CompilerServices.CompilationRelaxationsAttribute(8)", attrs[0].ToString()); 2300AssertEx.Equal("System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows = true)", attrs[1].ToString()); 2301AssertEx.Equal("System.Diagnostics.DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)", attrs[2].ToString()); 2302AssertEx.Equal("A1(1)", attrs[3].ToString()); 2355AssertEx.Equal("System.Runtime.CompilerServices.CompilationRelaxationsAttribute(8)", attrs[0].ToString()); 2356AssertEx.Equal("System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows = true)", attrs[1].ToString()); 2357AssertEx.Equal("System.Diagnostics.DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)", attrs[2].ToString()); 2358AssertEx.Equal("A1(typeof(C1))", attrs[3].ToString()); 2383AssertEx.Equal("System.Runtime.CompilerServices.CompilationRelaxationsAttribute(8)", attrs[0].ToString()); 2384AssertEx.Equal("System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows = true)", attrs[1].ToString()); 2385AssertEx.Equal("System.Diagnostics.DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)", attrs[2].ToString());

3243AssertEx.Equal(["System.Runtime.CompilerServices.CallerLineNumberAttribute"], goo.Parameters[0].GetAttributes().SelectAsArray(attr => attr.ToString())); 3244AssertEx.Equal(["System.Runtime.CompilerServices.CallerMemberNameAttribute"], goo.Parameters[1].GetAttributes().SelectAsArray(attr => attr.ToString())); 3245AssertEx.Equal(["System.Runtime.CompilerServices.CallerFilePathAttribute"], goo.Parameters[2].GetAttributes().SelectAsArray(attr => attr.ToString())); 5950AssertEx.Equal(["""System.Runtime.CompilerServices.CallerArgumentExpressionAttribute("value")"""], indexer.Parameters[1].GetAttributes().SelectAsArray(attr => attr.ToString()));

217AssertEx.SetEqual( 231AssertEx.SetEqual(

566AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, actual);

1384AssertEx.Equal(ImmutableArray.Create(true, true, true, false, true, true), reader.ReadBoolArray(customAttribute.Value)); 1615AssertEx.Equal(expectedNames, actualNames); 1626AssertEx.Equal(expectedNames, actualNames); 1637AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, actual);

70AssertEx.SetEqual( 74AssertEx.SetEqual( 91AssertEx.SetEqual( 97AssertEx.SetEqual( 134AssertEx.SetEqual( 138AssertEx.SetEqual( 169AssertEx.SetEqual( 173AssertEx.SetEqual( 276AssertEx.SetEqual( 280AssertEx.SetEqual( 4758AssertEx.Equal(ImmutableArray.Create<byte>(0, 0, 2, 0, 2, 0, 0, 0, 0, 2, 0, 2), reader.ReadByteArray(customAttribute.Value)); 4767AssertEx.Equal(ImmutableArray.Create<byte>(0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 2), reader.ReadByteArray(customAttribute.Value)); 4907AssertEx.Equal(expectedBits, reader.ReadByteArray(customAttribute.Value)); 5386AssertEx.SetEqual(expectedNames, actualNames); 5424AssertEx.SetEqual(expectedNames, actualNames); 5435AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, actual);

426AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, actual);

622AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, actual);

132AssertEx.SetEqual(expectedAttrs, actualAttrs); 154AssertEx.SetEqual(expectedAttrs, actualAttrs); 265AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(displayClass.GetAttributes())); 304AssertEx.SetEqual(expected, GetAttributeNames(anon.GetAttributes())); 335AssertEx.SetEqual(expected, actual); 431AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(iter.GetAttributes())); 444AssertEx.SetEqual(new[] { "DebuggerHiddenAttribute" }, GetAttributeNames(member.GetAttributes())); 450AssertEx.SetEqual(new string[] { }, GetAttributeNames(member.GetAttributes())); 486AssertEx.SetEqual(options.OptimizationLevel == OptimizationLevel.Debug ? 491AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(iter.GetAttributes())); 501AssertEx.SetEqual(new[] { "DebuggerHiddenAttribute" }, GetAttributeNames(member.GetAttributes())); 505AssertEx.SetEqual(new string[] { }, GetAttributeNames(member.GetAttributes())); 545AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute", "DebuggerHiddenAttribute" }, GetAttributeNames(attributes)); 582AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute", "DebuggerHiddenAttribute" }, GetAttributeNames(baseMethodWrapper.GetAttributes())); 625AssertEx.SetEqual(new[] { "CompilerGeneratedAttribute", "DebuggerHiddenAttribute" }, GetAttributeNames(baseMethodWrapper.GetAttributes()));

268AssertEx.Equal(srcMembers, peMembers); 640AssertEx.Equal(expectedElementNames, actualElementNames);

1127AssertEx.Equal(expectedConstant, actual); 1212AssertEx.Equal(expectedConstant, actual); 4900AssertEx.SetEqual(expectedAttributes, typeC.GetAttributes().Select(a => a.ToString()));

485AssertEx.Equal(identity.PublicKey, s_publicKey); 514AssertEx.Equal(identity.PublicKey, s_publicKey);

662AssertEx.SetEqual(programmaticSuppression.Suppressions, suppressionInfo.ProgrammaticSuppressions);

285AssertEx.Equal([ 303AssertEx.Equal(["file1"], completedCompilationUnits.OrderBy(name => name)); 1632AssertEx.SetEqual(expectedSymbolCallbacks, analyzer.AnalyzedSymbols.Select(s => s.Name).ToHashSet()); 1636AssertEx.All(analyzer.AnalyzedSyntaxNodes, node => node.IsKind(SyntaxKind.LocalDeclarationStatement)); 1637AssertEx.SetEqual(expectedSyntaxNodeCallbacks, analyzer.AnalyzedSyntaxNodes.Select(s => s.ToString()).ToHashSet()); 1640AssertEx.All(analyzer.AnalyzedSyntaxNodesInsideCodeBlock, node => node.IsKind(SyntaxKind.LocalDeclarationStatement)); 1641AssertEx.SetEqual(expectedSyntaxNodeInsideBlockCallbacks, analyzer.AnalyzedSyntaxNodesInsideCodeBlock.Select(s => s.ToString()).ToHashSet()); 1645AssertEx.All(analyzer.AnalyzedOperations, operation => operation.Kind == OperationKind.VariableDeclaration); 1646AssertEx.SetEqual(expectedOperationCallbacks, analyzer.AnalyzedOperations.Select(op => op.Syntax.ToString()).ToHashSet()); 1649AssertEx.All(analyzer.AnalyzedOperationsInsideOperationBlock, operation => operation.Kind == OperationKind.VariableDeclaration); 1650AssertEx.SetEqual(expectedOperationInsideBlockCallbacks, analyzer.AnalyzedOperationsInsideOperationBlock.Select(op => op.Syntax.ToString()).ToHashSet()); 1662AssertEx.SetEqual(expectedBlockSymbolCallbacks, actualBlockSymbolCallbacks.Select(s => s.Name).ToHashSet()); 1667AssertEx.SetEqual(expectedSymbolStartSymbolCallbacks, analyzer.AnalyzedSymbolStartSymbols.Select(s => s.Name).ToHashSet()); 1669AssertEx.SetEqual(expectedSymbolStartSymbolCallbacks, analyzer.AnalyzedSymbolEndSymbols.Select(s => s.Name).ToHashSet()); 1673AssertEx.SetEqual(expectedSemanticModelTreeCallbacks, analyzer.AnalyzedSemanticModels.Select(s => s.SyntaxTree).ToHashSet());

90AssertEx.Equal(expectedMembers, actualMembers); 155AssertEx.Equal(expectedMembers, actualMembers); 424AssertEx.Equal(expectedMembers, actualMembers); 474AssertEx.Equal(expectedMembers, actualMembers); 820AssertEx.Equal(expectedMembers, actualMembers); 918AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 1021AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 1128AssertEx.Equal(expectedMembers, actualMembers); 1243AssertEx.Equal(expectedMembers, actualMembers); 1517AssertEx.Equal([], actualFields); 1687AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 1854AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 1960AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 2044AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 2165AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 2247AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 4669AssertEx.Equal(expectedMembers, actualMembers); 4820AssertEx.Equal(expectedMembers, actualMembers); 4892AssertEx.Equal(expectedMembers, actualMembers); 4971AssertEx.Equal(expectedMembers, actualMembers); 5098AssertEx.Equal(expectedMembers, actualMembers); 5155AssertEx.Equal(expectedMembers, actualMembers); 5166AssertEx.Equal(expectedMembers, actualMembers); 8098AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 8395AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 8469AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 8637AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 8700AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 8754AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 8832AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 8907AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 9007AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 9083AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 9160AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 9283AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 9368AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 9437AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 9458AssertEx.Equal(expectedValues, actualValues); 9469AssertEx.Equal(expectedValues, actualValues); 9566AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 9797AssertEx.Equal(expectedMembers, actualMembers); 9857AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 9934AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 10008AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 10092AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 10094AssertEx.Equal(["A(2)"], actualFields[0].GetAttributes().ToStrings()); 10095AssertEx.Equal(["A(3)"], actualFields[1].GetAttributes().ToStrings()); 10096AssertEx.Equal(["A(5)", "A(6)"], actualFields[2].GetAttributes().ToStrings()); 10159AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings()); 10161AssertEx.Equal(["A(2)"], actualFields[0].GetAttributes().ToStrings()); 10162AssertEx.Equal(["A(3)"], actualFields[1].GetAttributes().ToStrings()); 10163AssertEx.Equal(["A(5)", "A(6)"], actualFields[2].GetAttributes().ToStrings()); 10358AssertEx.Equal(expectedFields, actualFields.ToTestDisplayStrings());

5002AssertEx.Equal("System.Int32[]", aSymbol.Type.ToTestDisplayString()); 5006AssertEx.Equal("System.Int32 System.Span<System.Int32>.M(System.Int32 y)", lookupResult.Single().ToTestDisplayString()); 8549AssertEx.Equal("C.M1<System.Int32>", DisplayInvokedMethodTypeArguments(comp)); 8581AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8613AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8628AssertEx.Equal("C.M1<System.Int32>", DisplayInvokedMethodTypeArguments(comp)); 8660AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8692AssertEx.Equal("C.M1<System.Int32>", DisplayInvokedMethodTypeArguments(comp)); 8707AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8722AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8754AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8773AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp, CandidateReason.OverloadResolutionFailure)); 8792AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp, CandidateReason.OverloadResolutionFailure)); 8825AssertEx.Equal("C.M1<System.Int32>", DisplayInvokedMethodTypeArguments(comp)); 8840AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8855AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8870AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8919AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8951AssertEx.Equal("C.M1<System.Int32>", DisplayInvokedMethodTypeArguments(comp)); 8966AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 8981AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp)); 9013AssertEx.Equal("C.M1<System.Object>", DisplayInvokedMethodTypeArguments(comp));

762AssertEx.Equal("RetValue C.this[System.Object o] { get; set; }", model.GetSymbolInfo(accesses[0]).Symbol!.ToTestDisplayString()); 763AssertEx.Equal("RetValue C.this[System.Object o] { get; set; }", model.GetSymbolInfo(accesses[1]).Symbol!.ToTestDisplayString()); 809AssertEx.Equal("Derived..ctor(System.Object o)", model.GetSymbolInfo(creation).Symbol!.ToTestDisplayString()); 907AssertEx.Equal("C..ctor(System.Object o)", attr.AttributeConstructor.ToTestDisplayString()); 989AssertEx.Equal(["System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute..ctor(System.Int32 priority)", "System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute..ctor(System.Object priority)"], 995AssertEx.Equal("System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute..ctor(System.Int32 priority)", 1482AssertEx.Equal("System.Int32 C.this[System.Object x] { get; set; }", indexer.ToTestDisplayString()); 1488AssertEx.Equal("System.Int32 C.this[System.String x] { get; set; }", indexer.ToTestDisplayString()); 2373AssertEx.Equal("System.Int32 C.this[System.Object o] { get; set; }", s.ToTestDisplayString()); 2500AssertEx.Equal("System.Int32 C.this[System.Object o] { get; set; }", s.ToTestDisplayString());

980AssertEx.SetEqual(new[] 1129AssertEx.SetEqual(new[] 1181AssertEx.SetEqual(new[]

4383AssertEx.Equal("C<T> where T : allows ref struct", t.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.TestFormatWithConstraints)); 5099AssertEx.Equal("C<T> where T : new(), allows ref struct", t.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.TestFormatWithConstraints)); 5123AssertEx.Equal("C<T> where T : new(), allows ref struct", t.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.TestFormatWithConstraints)); 5770AssertEx.Equal("C<T>", t.ContainingSymbol.ToDisplayString(SymbolDisplayFormat.TestFormatWithConstraints)); 7579AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> S.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 7580AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 7584AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> S.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 7586AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 7769AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> S.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 7770AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 7774AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> S.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 7776AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 7989AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 7990AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 7994AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 7996AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 8179AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 8180AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 8184AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 8186AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 8372AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> IMyEnumerable<System.Int32>.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 8373AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 8377AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> IMyEnumerable<System.Int32>.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 8379AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 8651AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 8652AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 8656AssertEx.Equal("System.Collections.Generic.IEnumerator<System.Int32> System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 8658AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 9022AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 9023AssertEx.Equal("System.Boolean S2.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 9024AssertEx.Equal("System.Int32 S2.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 9025AssertEx.Equal("void S2.Dispose()", info.DisposeMethod.ToTestDisplayString()); 9029AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 9030AssertEx.Equal("System.Boolean S2.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 9032AssertEx.Equal("System.Int32 S2.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 9036AssertEx.Equal("void S2.Dispose()", op.Info.PatternDisposeMethod.ToTestDisplayString()); 9226AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 9227AssertEx.Equal("System.Boolean S2.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 9228AssertEx.Equal("System.Int32 S2.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 9229AssertEx.Equal("void S2.Dispose()", info.DisposeMethod.ToTestDisplayString()); 9233AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 9234AssertEx.Equal("System.Boolean S2.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 9236AssertEx.Equal("System.Int32 S2.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 9240AssertEx.Equal("void S2.Dispose()", op.Info.PatternDisposeMethod.ToTestDisplayString()); 9590AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 9591AssertEx.Equal("System.Boolean S2.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 9592AssertEx.Equal("System.Int32 S2.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 9593AssertEx.Equal("void System.IDisposable.Dispose()", info.DisposeMethod.ToTestDisplayString()); 9597AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 9598AssertEx.Equal("System.Boolean S2.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 9600AssertEx.Equal("System.Int32 S2.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 9814AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 9815AssertEx.Equal("System.Boolean System.Collections.IEnumerator.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 9816AssertEx.Equal("System.Int32 System.Collections.Generic.IEnumerator<System.Int32>.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 9817AssertEx.Equal("void System.IDisposable.Dispose()", info.DisposeMethod.ToTestDisplayString()); 9821AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 9822AssertEx.Equal("System.Boolean System.Collections.IEnumerator.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 9824AssertEx.Equal("System.Int32 System.Collections.Generic.IEnumerator<System.Int32>.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 10023AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 10024AssertEx.Equal("System.Boolean System.Collections.IEnumerator.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 10025AssertEx.Equal("System.Int32 System.Collections.Generic.IEnumerator<System.Int32>.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 10026AssertEx.Equal("void System.IDisposable.Dispose()", info.DisposeMethod.ToTestDisplayString()); 10030AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 10031AssertEx.Equal("System.Boolean System.Collections.IEnumerator.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 10033AssertEx.Equal("System.Int32 System.Collections.Generic.IEnumerator<System.Int32>.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 10250AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 10251AssertEx.Equal("System.Boolean IMyEnumerator<System.Int32>.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 10252AssertEx.Equal("System.Int32 IMyEnumerator<System.Int32>.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 10253AssertEx.Equal("void System.IDisposable.Dispose()", info.DisposeMethod.ToTestDisplayString()); 10257AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 10258AssertEx.Equal("System.Boolean IMyEnumerator<System.Int32>.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 10260AssertEx.Equal("System.Int32 IMyEnumerator<System.Int32>.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 10633AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 10634AssertEx.Equal("System.Boolean S2.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 10635AssertEx.Equal("System.Int32 S2.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 10636AssertEx.Equal("void S2.Dispose()", info.DisposeMethod.ToTestDisplayString()); 10640AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 10641AssertEx.Equal("System.Boolean S2.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 10643AssertEx.Equal("System.Int32 S2.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 10647AssertEx.Equal("void S2.Dispose()", op.Info.PatternDisposeMethod.ToTestDisplayString()); 10830AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 10831AssertEx.Equal("System.Boolean S2.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 10832AssertEx.Equal("System.Int32 S2.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 10833AssertEx.Equal("void S2.Dispose()", info.DisposeMethod.ToTestDisplayString()); 10837AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 10838AssertEx.Equal("System.Boolean S2.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 10840AssertEx.Equal("System.Int32 S2.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 10844AssertEx.Equal("void S2.Dispose()", op.Info.PatternDisposeMethod.ToTestDisplayString()); 11071AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 11072AssertEx.Equal("System.Boolean S2.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 11073AssertEx.Equal("System.Int32 S2.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 11074AssertEx.Equal("void System.IDisposable.Dispose()", info.DisposeMethod.ToTestDisplayString()); 11078AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 11079AssertEx.Equal("System.Boolean S2.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 11081AssertEx.Equal("System.Int32 S2.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 11298AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 11299AssertEx.Equal("System.Boolean ICustomEnumerator.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 11300AssertEx.Equal("System.Int32 ICustomEnumerator.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 11301AssertEx.Equal("void System.IDisposable.Dispose()", info.DisposeMethod.ToTestDisplayString()); 11305AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 11306AssertEx.Equal("System.Boolean ICustomEnumerator.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 11308AssertEx.Equal("System.Int32 ICustomEnumerator.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 11510AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 11511AssertEx.Equal("System.Boolean ICustomEnumerator.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 11512AssertEx.Equal("System.Int32 ICustomEnumerator.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 11513AssertEx.Equal("void System.IDisposable.Dispose()", info.DisposeMethod.ToTestDisplayString()); 11517AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 11518AssertEx.Equal("System.Boolean ICustomEnumerator.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 11520AssertEx.Equal("System.Int32 ICustomEnumerator.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 11610AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 11611AssertEx.Equal("System.Boolean ICustomEnumerator.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 11612AssertEx.Equal("System.Int32 ICustomEnumerator.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 11617AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 11618AssertEx.Equal("System.Boolean ICustomEnumerator.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 11620AssertEx.Equal("System.Int32 ICustomEnumerator.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 11705AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 11706AssertEx.Equal("System.Boolean ICustomEnumerator.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 11707AssertEx.Equal("System.Int32 ICustomEnumerator.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 11712AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 11713AssertEx.Equal("System.Boolean ICustomEnumerator.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 11715AssertEx.Equal("System.Int32 ICustomEnumerator.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 14262AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> S.GetAsyncEnumerator([System.Threading.CancellationToken token = default(System.Threading.CancellationToken)])", info.GetEnumeratorMethod.ToTestDisplayString()); 14263AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 14267AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> S.GetAsyncEnumerator([System.Threading.CancellationToken token = default(System.Threading.CancellationToken)])", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 14269AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 14603AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> S.GetAsyncEnumerator([System.Threading.CancellationToken token = default(System.Threading.CancellationToken)])", info.GetEnumeratorMethod.ToTestDisplayString()); 14604AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 14608AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> S.GetAsyncEnumerator([System.Threading.CancellationToken token = default(System.Threading.CancellationToken)])", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 14610AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 14966AssertEx.Equal("new S()", foreachSyntax.Expression.ToString()); 14970AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> System.Collections.Generic.IAsyncEnumerable<System.Int32>.GetAsyncEnumerator([System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)])", info.GetEnumeratorMethod.ToTestDisplayString()); 14971AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 14975AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> System.Collections.Generic.IAsyncEnumerable<System.Int32>.GetAsyncEnumerator([System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)])", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 14977AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 15313AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> System.Collections.Generic.IAsyncEnumerable<System.Int32>.GetAsyncEnumerator([System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)])", info.GetEnumeratorMethod.ToTestDisplayString()); 15314AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 15318AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> System.Collections.Generic.IAsyncEnumerable<System.Int32>.GetAsyncEnumerator([System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)])", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 15320AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 15661AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> IMyAsyncEnumerable<System.Int32>.GetAsyncEnumerator([System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)])", info.GetEnumeratorMethod.ToTestDisplayString()); 15662AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 15666AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> IMyAsyncEnumerable<System.Int32>.GetAsyncEnumerator([System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)])", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 15668AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 16099AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> System.Collections.Generic.IAsyncEnumerable<System.Int32>.GetAsyncEnumerator([System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)])", info.GetEnumeratorMethod.ToTestDisplayString()); 16100AssertEx.Equal("System.Int32", info.ElementType.ToTestDisplayString()); 16104AssertEx.Equal("System.Collections.Generic.IAsyncEnumerator<System.Int32> System.Collections.Generic.IAsyncEnumerable<System.Int32>.GetAsyncEnumerator([System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)])", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 16106AssertEx.Equal("System.Int32", op.Info.ElementType.ToTestDisplayString()); 16764AssertEx.Equal("System.Threading.Tasks.ValueTask S2.DisposeAsync()", info.DisposeMethod.ToTestDisplayString()); 16770AssertEx.Equal("System.Threading.Tasks.ValueTask S2.DisposeAsync()", op.Info.PatternDisposeMethod.ToTestDisplayString()); 16829AssertEx.Equal("System.Threading.Tasks.ValueTask S2.DisposeAsync()", info.DisposeMethod.ToTestDisplayString()); 16835AssertEx.Equal("System.Threading.Tasks.ValueTask S2.DisposeAsync()", op.Info.PatternDisposeMethod.ToTestDisplayString()); 16894AssertEx.Equal("System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()", info.DisposeMethod.ToTestDisplayString()); 16978AssertEx.Equal("System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()", info.DisposeMethod.ToTestDisplayString()); 16984AssertEx.Equal("System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()", op.Info.PatternDisposeMethod.ToTestDisplayString()); 17066AssertEx.Equal("System.Threading.Tasks.ValueTask IMyAsyncDisposable.DisposeAsync()", info.DisposeMethod.ToTestDisplayString()); 17072AssertEx.Equal("System.Threading.Tasks.ValueTask IMyAsyncDisposable.DisposeAsync()", op.Info.PatternDisposeMethod.ToTestDisplayString()); 17256AssertEx.Equal("System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()", info.DisposeMethod.ToTestDisplayString()); 17766AssertEx.Equal("System.Collections.IEnumerator S.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 17767AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 17771AssertEx.Equal("System.Collections.IEnumerator S.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 17773AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 17963AssertEx.Equal("System.Collections.IEnumerator S.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 17964AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 17968AssertEx.Equal("System.Collections.IEnumerator S.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 17970AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 18183AssertEx.Equal("new S()", foreachSyntax.Expression.ToString()); 18187AssertEx.Equal("System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 18188AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 18192AssertEx.Equal("System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 18194AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 18383AssertEx.Equal("System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 18384AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 18388AssertEx.Equal("System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 18390AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 18584AssertEx.Equal("System.Collections.IEnumerator IMyEnumerable.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 18585AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 18589AssertEx.Equal("System.Collections.IEnumerator IMyEnumerable.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 18591AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 18868AssertEx.Equal("System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()", info.GetEnumeratorMethod.ToTestDisplayString()); 18869AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 18873AssertEx.Equal("System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()", op.Info.GetEnumeratorMethod.ToTestDisplayString()); 18875AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 19203AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 19204AssertEx.Equal("System.Boolean S2.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 19205AssertEx.Equal("System.Object S2.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 19210AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 19211AssertEx.Equal("System.Boolean S2.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 19213AssertEx.Equal("System.Object S2.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 19374AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 19375AssertEx.Equal("System.Boolean S2.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 19376AssertEx.Equal("System.Object S2.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 19381AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 19382AssertEx.Equal("System.Boolean S2.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 19384AssertEx.Equal("System.Object S2.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 19699AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 19700AssertEx.Equal("System.Boolean S2.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 19701AssertEx.Equal("System.Object S2.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 19706AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 19707AssertEx.Equal("System.Boolean S2.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 19709AssertEx.Equal("System.Object S2.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 19867AssertEx.Equal("System.Object", info.ElementType.ToTestDisplayString()); 19868AssertEx.Equal("System.Boolean System.Collections.IEnumerator.MoveNext()", info.MoveNextMethod.ToTestDisplayString()); 19869AssertEx.Equal("System.Object System.Collections.IEnumerator.Current { get; }", info.CurrentProperty.ToTestDisplayString()); 19870AssertEx.Equal("void System.IDisposable.Dispose()", info.DisposeMethod.ToTestDisplayString()); 19874AssertEx.Equal("System.Object", op.Info.ElementType.ToTestDisplayString()); 19875AssertEx.Equal("System.Boolean System.Collections.IEnumerator.MoveNext()", op.Info.MoveNextMethod.ToTestDisplayString()); 19877AssertEx.Equal("System.Object System.Collections.IEnumerator.Current { get; }", op.Info.CurrentProperty.ToTestDisplayString()); 21241AssertEx.Equal("scoped T u", parameter.ToTestDisplayString()); 21251AssertEx.Equal("scoped T u", parameter.ToTestDisplayString()); 21262AssertEx.Equal("scoped T x", p.ToTestDisplayString()); 21306AssertEx.Equal("x = default", declarator.ToString()); 21308AssertEx.Equal("T x", local.ToTestDisplayString()); 21510AssertEx.Equal("params T x", p.ToTestDisplayString()); 21647AssertEx.Equal("params T x", p.ToTestDisplayString()); 21651AssertEx.Equal("params S y", p.ToTestDisplayString()); 21655AssertEx.Equal("params T z", p.ToTestDisplayString()); 21710AssertEx.Equal("params T x", p.ToTestDisplayString()); 21714AssertEx.Equal("params S y", p.ToTestDisplayString()); 21718AssertEx.Equal("params T z", p.ToTestDisplayString()); 22850AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(params T1[] arg)", m.ToTestDisplayString()); 22874AssertEx.Equal("void <>f__AnonymousDelegate0<T1, T2>.Invoke(T1 arg1, params T2[] arg2)", m.ToTestDisplayString()); 22902AssertEx.Equal("void <>f__AnonymousDelegate0.Invoke(System.Int32* arg1, params System.Int32[] arg2)", m.ToTestDisplayString()); 22932AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(System.Int32* arg1, T1 arg2, params System.Int32[] arg3)", m.ToTestDisplayString()); 22963AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(System.Int32* arg1, T1 arg2, params System.Int32[] arg3)", m.ToTestDisplayString()); 22994AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(System.Int32* arg1, T1 arg2, params T1[] arg3)", m.ToTestDisplayString()); 23025AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(System.Int32* arg1, params T1[] arg2)", m.ToTestDisplayString()); 23057AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(System.Int32* arg1, params T1?[] arg2)", m.ToTestDisplayString()); 23088AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(System.Int32* arg1, params T1?[] arg2)", m.ToTestDisplayString()); 23119AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(System.Int32* arg1, params T1[][] arg2)", m.ToTestDisplayString()); 23143AssertEx.Equal("void <>f__AnonymousDelegate0.Invoke(params System.Collections.Generic.IEnumerable<System.Int32> arg)", m.ToTestDisplayString()); 23173AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(System.Int32* arg1, T1[] arg2)", m.ToTestDisplayString()); 23204AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(System.Int32* arg1, T1 arg2)", m.ToTestDisplayString()); 23228AssertEx.Equal("void <>A{00000001}<T1, T2>.Invoke(ref T1 arg1, T2 arg2)", m.ToTestDisplayString()); 28946AssertEx.Equal("void ITest29.M21<T1>() where T1 : allows ref struct", m21.ToDisplayString(SymbolDisplayFormat.TestFormatWithConstraints));

13444AssertEx.Equal( 13719AssertEx.Equal( 15586AssertEx.Equal(new[] { "<>y__InlineArray2", "<>y__InlineArray3" }, getInlineArrayTypeNames(module)); 15614AssertEx.Equal(new[] { "<>y__InlineArray3" }, getInlineArrayTypeNames(module)); 15642AssertEx.Equal(new[] { $"<>y__InlineArray{n}" }, getInlineArrayTypeNames(module));

14641AssertEx.Equal("System.Span<TElement> <PrivateImplementationDetails>.InlineArrayAsSpan<TBuffer, TElement>(ref TBuffer buffer, System.Int32 length)", 14691AssertEx.Equal("System.ReadOnlySpan<TElement> <PrivateImplementationDetails>.InlineArrayAsReadOnlySpan<TBuffer, TElement>(in TBuffer buffer, System.Int32 length)",

2744AssertEx.Equal("void Program.<>c.<Main>b__0_0(System.Collections.Generic.IEnumerable<System.Int64> x)", l1.ToTestDisplayString()); 2758AssertEx.Equal("params System.Collections.Generic.IEnumerable<System.Int64> x", parameter.ToTestDisplayString()); 2792AssertEx.Equal("params System.Int64[] x", parameter.ToTestDisplayString()); 2800AssertEx.Equal("void Program.<>c.<Main>b__0_0(System.Int64[] x)", l1.ToTestDisplayString()); 2946AssertEx.Equal("void Program.<Main>g__local|0_0(System.Collections.Generic.IEnumerable<System.Int64> x)", l1.ToTestDisplayString()); 2956AssertEx.Equal("params System.Collections.Generic.IEnumerable<System.Int64> x", parameter.ToTestDisplayString()); 2987AssertEx.Equal("params System.Int64[] x", parameter.ToTestDisplayString()); 2995AssertEx.Equal("void Program.<Main>g__local|0_0(System.Int64[] x)", l1.ToTestDisplayString()); 4341AssertEx.Equal("System.Collections.Generic.IEnumerable<System.Int64> e1", parameter.ToTestDisplayString()); 4347AssertEx.Equal("System.Int64[] e2", parameter.ToTestDisplayString()); 4467AssertEx.Equal("void <>f__AnonymousDelegate0.Invoke(params System.ReadOnlySpan<System.Int64> arg)", delegateInvokeMethod1.ToTestDisplayString()); 4471AssertEx.Equal("void <>f__AnonymousDelegate1<T1>.Invoke(params T1[] arg)", delegateInvokeMethod2.ToTestDisplayString()); 4529AssertEx.Equal("void <>f__AnonymousDelegate0.Invoke(params System.ReadOnlySpan<System.Int64> arg)", delegateInvokeMethod1.ToTestDisplayString()); 4533AssertEx.Equal("void <>f__AnonymousDelegate1<T1>.Invoke(params T1[] arg)", delegateInvokeMethod2.ToTestDisplayString()); 4539AssertEx.Equal("void Program.<>c.<Main>b__0_0(scoped System.ReadOnlySpan<System.Int64> a)", l1.ToTestDisplayString()); 4543AssertEx.Equal("void Program.<>c.<Main>b__0_1(System.Int64[] a)", l2.ToTestDisplayString()); 4625AssertEx.Equal("void <>f__AnonymousDelegate0.Invoke(params System.Collections.Generic.IEnumerable<System.Int64> arg)", m.ContainingAssembly.GetTypeByMetadataName("<>f__AnonymousDelegate0").DelegateInvokeMethod.ToTestDisplayString()); 4626AssertEx.Equal("void <>f__AnonymousDelegate1.Invoke(params System.Collections.Generic.List<System.Int64> arg)", m.ContainingAssembly.GetTypeByMetadataName("<>f__AnonymousDelegate1").DelegateInvokeMethod.ToTestDisplayString()); 4627AssertEx.Equal("void <>f__AnonymousDelegate2<T1>.Invoke(params T1[] arg)", m.ContainingAssembly.GetTypeByMetadataName("<>f__AnonymousDelegate2`1").DelegateInvokeMethod.ToTestDisplayString()); 4682AssertEx.Equal("void <>f__AnonymousDelegate0.Invoke(params System.ReadOnlySpan<System.Int64> arg)", delegateInvokeMethod1.ToTestDisplayString()); 4686AssertEx.Equal("void <>f__AnonymousDelegate1<T1>.Invoke(params T1[] arg)", delegateInvokeMethod2.ToTestDisplayString()); 4692AssertEx.Equal("void Program.<Main>g__Test1|0_0(scoped System.ReadOnlySpan<System.Int64> a)", l1.ToTestDisplayString()); 4696AssertEx.Equal("void Program.<Main>g__Test2|0_1(System.Int64[] a)", l2.ToTestDisplayString()); 4816AssertEx.Equal("void <>f__AnonymousDelegate0<T1>.Invoke(params T1 arg)", delegateInvokeMethod.ToTestDisplayString()); 10404AssertEx.Equal("System.Runtime.CompilerServices.ParamCollectionAttribute", test1.GetCustomAttributesToEmit(null).Single().ToString()); 10405AssertEx.Equal("System.ParamArrayAttribute", test2.GetCustomAttributesToEmit(null).Single().ToString()); 10418AssertEx.Equal("System.Runtime.CompilerServices.ParamCollectionAttribute", test1.GetCustomAttributesToEmit(null).Single().ToString()); 10419AssertEx.Equal("System.ParamArrayAttribute", test2.GetCustomAttributesToEmit(null).Single().ToString()); 10528AssertEx.Equal(attributes, test1.GetCustomAttributesToEmit(null).Select(a => a.ToString())); 10529AssertEx.Equal(attributes, test2.GetCustomAttributesToEmit(null).Select(a => a.ToString())); 10542AssertEx.Equal(attributes, test1.GetCustomAttributesToEmit(null).Select(a => a.ToString())); 10543AssertEx.Equal(attributes, test2.GetCustomAttributesToEmit(null).Select(a => a.ToString())); 10652AssertEx.Equal(attributes, test1.GetCustomAttributesToEmit(null).Select(a => a.ToString())); 10653AssertEx.Equal(attributes, test2.GetCustomAttributesToEmit(null).Select(a => a.ToString())); 10666AssertEx.Equal(attributes, test1.GetCustomAttributesToEmit(null).Select(a => a.ToString())); 10667AssertEx.Equal(attributes, test2.GetCustomAttributesToEmit(null).Select(a => a.ToString())); 10769AssertEx.Equal("System.ParamArrayAttribute", test1.GetCustomAttributesToEmit(null).Single().ToString()); 10770AssertEx.Equal("System.Runtime.CompilerServices.ParamCollectionAttribute", test2.GetCustomAttributesToEmit(null).Single().ToString()); 10783AssertEx.Equal("System.ParamArrayAttribute", test1.GetCustomAttributesToEmit(null).Single().ToString()); 10784AssertEx.Equal("System.Runtime.CompilerServices.ParamCollectionAttribute", test2.GetCustomAttributesToEmit(null).Single().ToString()); 12822AssertEx.Equal(adjustedMemberDisplay, member.ToTestDisplayString());

470AssertEx.Equal(expectedDecisionDag, decisionDag.Dump());

11391AssertEx.Equal(new[] { "System.ReadOnlySpan<System.Char>", "System.Span<System.Char>" }, types);

74AssertEx.Multiple( 284AssertEx.Multiple( 541AssertEx.Multiple( 728AssertEx.Multiple( 2454AssertEx.Multiple( 6692AssertEx.Multiple(

4021AssertEx.Equal( 4090AssertEx.Equal( 4163AssertEx.Equal( 4235AssertEx.Equal( 4279AssertEx.Equal( 4326AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4408AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4490AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4572AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4654AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4738AssertEx.AssertEqualToleratingWhitespaceDifferences("""

3039AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 6834AssertEx.Equal("System.Int32 X", model.GetSymbolInfo(xReference).Symbol.ToTestDisplayString()); 6905AssertEx.SetEqual(new string[] { "A..ctor()" }, 6907AssertEx.SetEqual(new string[] { "B..ctor()" }, 6909AssertEx.SetEqual(new string[] { "C..ctor(System.Int32 x)" }, 6911AssertEx.SetEqual(new string[] { "D..ctor(System.Int32 x)" }, 6933AssertEx.SetEqual(new string[] { "A..ctor()" }, 6935AssertEx.SetEqual(new string[] { "B..ctor()" }, 6937AssertEx.SetEqual(new string[] { "C..ctor(System.Int32 x)", "C..ctor()" }, 6939AssertEx.SetEqual(new string[] { "D..ctor(System.Int32 x)", "D..ctor()" }, 6961AssertEx.SetEqual(new string[] { ".ctor" }, 6963AssertEx.SetEqual(new string[] { ".ctor" }, 6965AssertEx.SetEqual(new string[] { ".ctor" }, 6967AssertEx.SetEqual(new string[] { ".ctor" }, 6989AssertEx.SetEqual(new string[] { ".ctor" }, 6991AssertEx.SetEqual(new string[] { ".ctor" }, 6993AssertEx.SetEqual(new string[] { ".ctor" }, 6995AssertEx.SetEqual(new string[] { ".ctor" }, 19777AssertEx.Equal("System.Int32 C.this[System.Int32 i] { get; }", info.Symbol.ToTestDisplayString()); 22026AssertEx.Equal(new[] { "<x>P", "<y>P" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22047AssertEx.Equal(new[] { "<x>P", "<y>P", "a" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22073AssertEx.Equal(new[] { "b", "<x>P", "<y>P", "a" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22099AssertEx.Equal(new[] { "<x>P", "<y>P", "a", "b" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name)); 22130AssertEx.Equal(new[] { "b", "<x>P", "<y>P", "a", "c" }, c1.GetMembers().OfType<FieldSymbol>().Select(f => f.Name));

295AssertEx.SetEqual(new[] { "System.Boolean RecordB.op_Equality(RecordB? left, RecordB? right)" }, 509AssertEx.Equal(expectedMembers, 512AssertEx.Equal(new[] { "A..ctor(System.Int32 i, ?)", "A..ctor(A original)" }, 598AssertEx.Equal(expectedMembers, 632AssertEx.Equal(expectedMembers, 635AssertEx.Equal(new[] { "A..ctor(System.Int32, System.String)", "A..ctor(A original)" }, 666AssertEx.Equal(expectedMembers, 669AssertEx.Equal(new[] { "A..ctor(System.Int32, System.Int32)", "A..ctor(A original)" }, 840AssertEx.Equal(expectedMemberNames, comp.GetMember<NamedTypeSymbol>("C").GetPublicSymbol().MemberNames); 1018AssertEx.Equal(expectedMembers, 1044AssertEx.Equal(expectedMemberNames, comp.GetMember<NamedTypeSymbol>("C").GetPublicSymbol().MemberNames); 1070AssertEx.Equal(expectedMembers, 1096AssertEx.Equal(expectedMemberNames, comp.GetMember<NamedTypeSymbol>("C").GetPublicSymbol().MemberNames); 1148AssertEx.Equal(expectedMembers, actualMembers); 1584AssertEx.Equal(expectedMembers, actualMembers); 1635AssertEx.Equal(expectedMembers, actualMembers); 5983AssertEx.Equal(expectedMembers, actualMembers); 6026AssertEx.Equal(expectedMembers, actualMembers); 6067AssertEx.Equal(expectedMembers, actualMembers); 6108AssertEx.Equal(expectedMembers, actualMembers); 9750AssertEx.Equal(expectedMembers, actualMembers); 9777AssertEx.Equal(new[] { "System.Type A.B.EqualityContract { get; }" }, actualMembers); 9800AssertEx.Equal(new[] { "System.Type C1.EqualityContract { get; }" }, GetProperties(comp, "C1").ToTestDisplayStrings()); 9813AssertEx.Equal(new[] { "System.Type C2.EqualityContract { get; }", "System.Object C2.P { get; init; }" }, GetProperties(comp, "C2").ToTestDisplayStrings()); 9865AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 9896AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 9943AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 9977AssertEx.Equal(new[] { "System.Type B1.EqualityContract { get; }", "System.Int32 B1.X { get; init; }" }, GetProperties(comp, "B1").ToTestDisplayStrings()); 9978AssertEx.Equal(new[] { "System.Type B2.EqualityContract { get; }", "System.Int32 B2.X { get; init; }" }, GetProperties(comp, "B2").ToTestDisplayStrings()); 10016AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }", "System.Int32 C.X { get; init; }", "System.Int32 C.Y { get; init; }" }, actualMembers); 10061AssertEx.Equal(expectedMembers, actualMembers); 10083AssertEx.Equal(expectedMemberNames, c.GetPublicSymbol().MemberNames); 10090AssertEx.Equal(expectedCtors, c.GetPublicSymbol().Constructors.ToTestDisplayStrings()); 10184AssertEx.Equal(expectedMembers, actualMembers); 10221AssertEx.Equal(expectedMembers, actualMembers); 10264AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }" }, actualMembers); 10297AssertEx.Equal(expectedMembers, actualMembers); 10343AssertEx.Equal(expectedMembers, actualMembers); 10390AssertEx.Equal(expectedMembers, actualMembers); 10439AssertEx.Equal(expectedMembers, actualMembers); 10491AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 10551AssertEx.Equal(expectedMembers, actualMembers); 10588AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }" }, actualMembers); 10664AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }" }, actualMembers); 10696AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }" }, actualMembers); 10754AssertEx.Equal(expectedMembers, comp.GetMember<NamedTypeSymbol>("B").GetMembers().ToTestDisplayStrings()); 10778AssertEx.Equal(expectedMembers, comp.GetMember<NamedTypeSymbol>("C").GetMembers().ToTestDisplayStrings()); 10822AssertEx.Equal(expectedMembers, actualMembers); 10847AssertEx.Equal(expectedMembers, actualMembers); 10870AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 10876AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }", "System.Object B.P { get; init; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 10900AssertEx.Equal(expectedMembers, actualMembers); 10924AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }", "System.Object B.P { get; init; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 10925AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }", "System.Object C.P { get; init; }", "System.Object C.I.P { get; }" }, GetProperties(comp, "C").ToTestDisplayStrings()); 10987AssertEx.Equal(expectedMembers, actualMembers); 11055AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 11150AssertEx.Equal(expectedMembers, actualMembers); 11202AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 11263AssertEx.Equal(expectedMembers, actualMembers); 11299AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 11340AssertEx.Equal(expectedMembers, actualMembers); 11554AssertEx.Equal(expectedMembers, actualMembers); 11790AssertEx.Equal(expectedMembers, actualMembers); 12103AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }", }, GetProperties(comp, "C").ToTestDisplayStrings()); 12211AssertEx.Equal(new[] { "System.Type CA.EqualityContract { get; }", "System.Object CA.P { get; init; }" }, GetProperties(comp, "CA").ToTestDisplayStrings()); 12212AssertEx.Equal(new[] { "System.Type CB.EqualityContract { get; }" }, GetProperties(comp, "CB").ToTestDisplayStrings()); 12493AssertEx.Equal(expectedModifiers, returnType.CustomModifiers); 12500AssertEx.Equal(expectedModifiers, parameterType.CustomModifiers); 12583AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 12743AssertEx.Equal(expectedMembers, actualMembers); 13476AssertEx.Equal(expectedMembers, actualMembers); 15780AssertEx.Equal(expectedMembers, actualMembers); 15839AssertEx.Equal(expectedMembers, actualMembers); 20707AssertEx.Equal(expectedMembers, actualMembers); 20749AssertEx.Equal(expectedMembers, actualMembers); 20779AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 23640AssertEx.Equal(expectedMembers, actualMembers); 23788AssertEx.Equal(expectedMembers, actualMembers); 24021AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24022AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24025AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B?>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24026AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B?>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24076AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24077AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24080AssertEx.Equal(new[] { "System.IEquatable<B>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24081AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24141AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24142AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24145AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24146AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24186AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24187AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24190AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24191AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24211AssertEx.Equal(new[] { "System.IEquatable<B1>", "System.IEquatable<B2>", "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24212AssertEx.Equal(new[] { "System.IEquatable<B1>", "System.IEquatable<B2>", "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24215AssertEx.Equal(new[] { "System.IEquatable<B1>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24216AssertEx.Equal(new[] { "System.IEquatable<B2>", "System.IEquatable<A<System.Object>>", "System.IEquatable<B1>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24219AssertEx.Equal(new[] { "System.IEquatable<B2>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24220AssertEx.Equal(new[] { "System.IEquatable<B1>", "System.IEquatable<A<System.Int32>>", "System.IEquatable<B2>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24240AssertEx.Equal(new[] { "I<A<T>>", "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24241AssertEx.Equal(new[] { "I<A<T>>", "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24244AssertEx.Equal(new[] { "I<A<System.Object>>", "I<B>", "System.IEquatable<B>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24245AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "I<A<System.Object>>", "I<B>", "System.IEquatable<B>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24305AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24306AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24309AssertEx.Equal(new[] { "System.IEquatable<B>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24310AssertEx.Equal(new[] { "System.IEquatable<A<System.Int32>>[missing]", "System.IEquatable<B>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24375AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24376AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24379AssertEx.Equal(new[] { "System.IEquatable<B>", "System.IEquatable<B>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24380AssertEx.Equal(new[] { "System.IEquatable<A<System.Int32>>[missing]", "System.IEquatable<B>", "System.IEquatable<B>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24449AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24450AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24453AssertEx.Equal(new[] { "IEquatable<B>", "System.IEquatable<B>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24454AssertEx.Equal(new[] { "System.IEquatable<A<System.Int32>>[missing]", "IEquatable<B>", "System.IEquatable<B>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24879AssertEx.Equal(expectedMembers, actualMembers); 24924AssertEx.Equal(expectedMembers, actualMembers); 25087AssertEx.SetEqual(new[] { "B" }, getAttributeStrings(prop1)); 25090AssertEx.SetEqual(new[] { "A" }, getAttributeStrings(field1)); 25093AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25147AssertEx.SetEqual(new[] { "B" }, getAttributeStrings(prop1)); 25150AssertEx.SetEqual(new[] { "A" }, getAttributeStrings(field1)); 25153AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25224AssertEx.SetEqual(new[] { "B" }, getAttributeStrings(prop1)); 25227AssertEx.SetEqual(new[] { "A" }, getAttributeStrings(field1)); 25230AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25281AssertEx.SetEqual(new string[] { }, getAttributeStrings(prop1)); 25284AssertEx.SetEqual(new string[] { }, getAttributeStrings(field1)); 25287AssertEx.SetEqual(new string[] { }, getAttributeStrings(param1)); 25362AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25446AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25516AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 28153AssertEx.Equal( 28305AssertEx.Equal( 28597AssertEx.Equal( 28644AssertEx.Equal( 28692AssertEx.Equal( 28740AssertEx.Equal( 28792AssertEx.Equal( 28843AssertEx.Equal( 28901AssertEx.Equal( 29008AssertEx.Equal( 29059AssertEx.Equal( 30186AssertEx.Equal(expectedMembers, actualMembers); 30216AssertEx.Equal(expectedMembers, actualMembers); 30373AssertEx.Equal("System.Int32 X", model.GetSymbolInfo(xReference).Symbol.ToTestDisplayString());

56AssertEx.AreEqual( 81AssertEx.Equal(expectedSpans, actualSpans,

115AssertEx.Equal(Array.Empty<SyntaxKind>(), unhandledKinds); 768AssertEx.Equal([expectedDiagnostic], result.RudeEdits.Select(d => d.ToDiagnostic(newSyntaxTree))

32AssertEx.Equal( 48AssertEx.Equal( 64AssertEx.Equal( 80AssertEx.Equal(

257AssertEx.Empty(SyntaxUtilities.GetSuspensionPoints(x.Initializer)); 258AssertEx.Equal(["yield return 1;"], SyntaxUtilities.GetSuspensionPoints(m1.Body).Select(n => n.ToString())); 259AssertEx.Empty(SyntaxUtilities.GetSuspensionPoints(m2.Body)); 261AssertEx.Equal(

83AssertEx.Equal(["namespace N"], results.Select(Inspect)); 178AssertEx.Equal(string.Format(FeaturesResources.Semantic_search_query_terminated_with_exception, "CSharpAssembly1", expectedMessage), result.ErrorMessage); 181AssertEx.Equal($"CSharpAssembly1: [179..179) 'F(x + 1);': InsufficientExecutionStackException: '{expectedMessage}'", Inspect(exception, query)); 183AssertEx.Equal( 236AssertEx.Equal(string.Format(FeaturesResources.Semantic_search_query_terminated_with_exception, "CSharpAssembly1", expectedMessage), result.ErrorMessage); 239AssertEx.Equal($"CSharpAssembly1: [190..190) 'var x = s.ToString();': NullReferenceException: '{expectedMessage}'", Inspect(exception, query)); 240AssertEx.Equal(

561AssertEx.Equal(expectedTestNames, testMethodNames);

53AssertEx.AssertEqualToleratingWhitespaceDifferences( 68AssertEx.AssertEqualToleratingWhitespaceDifferences( 91AssertEx.AssertEqualToleratingWhitespaceDifferences( 126AssertEx.AssertEqualToleratingWhitespaceDifferences( 151AssertEx.AssertEqualToleratingWhitespaceDifferences( 166AssertEx.AssertEqualToleratingWhitespaceDifferences( 257AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Out.ToString()); 258AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Error.ToString()); 281AssertEx.AssertEqualToleratingWhitespaceDifferences( 304AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 321AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 348AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 370AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 389AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 404AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Out.ToString()); 405AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Error.ToString()); 415AssertEx.AssertEqualToleratingWhitespaceDifferences( 428AssertEx.AssertEqualToleratingWhitespaceDifferences(s_compilerVersion, runner.Console.Out.ToString()); 432AssertEx.AssertEqualToleratingWhitespaceDifferences(s_compilerVersion, runner.Console.Out.ToString()); 436AssertEx.AssertEqualToleratingWhitespaceDifferences(s_compilerVersion, runner.Console.Out.ToString()); 440AssertEx.AssertEqualToleratingWhitespaceDifferences(s_compilerVersion, runner.Console.Out.ToString()); 458AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Out.ToString()); 459AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Error.ToString()); 468AssertEx.AssertEqualToleratingWhitespaceDifferences( 476AssertEx.AssertEqualToleratingWhitespaceDifferences( 495AssertEx.AssertEqualToleratingWhitespaceDifferences("3", runner.Console.Out.ToString()); 547AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 584AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 608AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 623AssertEx.AssertEqualToleratingWhitespaceDifferences( 644AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 659AssertEx.AssertEqualToleratingWhitespaceDifferences( 683AssertEx.Equal(new[] 694AssertEx.Equal(new[] 714AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 734AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 743AssertEx.AssertEqualToleratingWhitespaceDifferences( 843AssertEx.AssertEqualToleratingWhitespaceDifferences( 866AssertEx.AssertEqualToleratingWhitespaceDifferences( 879AssertEx.AssertEqualToleratingWhitespaceDifferences( 895AssertEx.AssertEqualToleratingWhitespaceDifferences( 914AssertEx.AssertEqualToleratingWhitespaceDifferences(

900AssertEx.Equal(new[] { "hello", "hello" }, result); 1024AssertEx.Equal(new object[] { 1, 1, null }, result); 1038AssertEx.Equal(new[] { 1, 2, 3, 4 }, result1); 1041AssertEx.Equal(new[] { 1, 2, 3, 4, 5 }, result2); 1044AssertEx.Equal(new[] { 1, 2, 3, 4, 5, 6 }, s1.ReturnValue); 1047AssertEx.Equal(new[] { 1, 2, 3, 4, 5, 6, 7 }, s2.ReturnValue); 1050AssertEx.Equal(new[] { 1, 2, 3, 4, 5, 6, 7, 8 }, s3.ReturnValue); 1675AssertEx.SetEqual(new[] { "<implicit>", "<host>" }, aliases); 1682AssertEx.SetEqual(new[] { "<host>", "global" }, aliases); 1687AssertEx.SetEqual(new[] { "<host>" }, aliases); 1723AssertEx.SetEqual(Array.Empty<string>(), aliases); 1729AssertEx.SetEqual(new[] { "<implicit>", "global" }, aliases); 1737AssertEx.SetEqual(new[] { "<implicit>", "<host>", "global" }, aliases); 1744AssertEx.SetEqual(new[] { "<host>", "global" }, aliases); 1751AssertEx.SetEqual(new[] { "<host>", "global" }, aliases); 1789AssertEx.SetEqual(Array.Empty<string>(), aliases); 1795AssertEx.SetEqual(new[] { "<implicit>", "global" }, aliases); 1803AssertEx.SetEqual(new[] { "<implicit>", "<host>", "global" }, aliases); 1810AssertEx.SetEqual(new[] { "<host>", "global" }, aliases); 1817AssertEx.SetEqual(new[] { "<host>", "global" }, aliases);

403AssertEx.Equal(new[] { "a", "b", "a", "x", "X" }, state.Variables.Select(v => v.Name)); 404AssertEx.Equal(new object[] { '1', 2u, 3m, 5m, 20 }, state.Variables.Select(v => v.Value)); 405AssertEx.Equal(new Type[] { typeof(char), typeof(uint), typeof(decimal), typeof(decimal), typeof(int) }, state.Variables.Select(v => v.Type));

1381AssertEx.Equal(["void System.Object.F(System.Object y)", "void System.Object.F<T>(T y)"], 1424AssertEx.Equal(["void System.Object.F<T>()", "void System.Object.F()"], 2087AssertEx.Equal(["void C.M()", "void C.M(System.Object o)"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2152AssertEx.Equal(["void C.M()", "void C.M()", "void C.M(System.Object o)"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2215AssertEx.Equal(["void C.M()", "void C.M(System.Object o)", "void C.M(System.Object o)"], 2273AssertEx.Equal(["void C.M()", "void C.M(System.Object o)"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2322AssertEx.Equal(["void C.M()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2362AssertEx.Equal(["void C.M()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2405AssertEx.Equal(["void C.M()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2456AssertEx.Equal(["void C.M(C c)"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2497AssertEx.Equal(["void C.M<T>()", "void C.M()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2545AssertEx.Equal(["void C.M<T>()", "void C.M()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2597AssertEx.Equal(["void C.M<C>()", "void C.M()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2643AssertEx.Equal(["void C.M<System.Int32, System.Int32>()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2691AssertEx.Equal(["void C.M<System.Int32, System.Int32>()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2738AssertEx.Equal(["void C.M<T>()", "void C.M<T, U>()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2782AssertEx.Equal(["void C.M()", "void C.M(System.Object o)"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2832AssertEx.Equal(["void System.Object.M<System.Object>()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2862AssertEx.Equal(["void C<System.Int32, System.Int64>.M<System.Int32, System.Int64>()"], 2891AssertEx.Equal(["void C.M<T>()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 2920AssertEx.Equal(["void C.M<System.Int32>()", "void C.M<System.Int32>(System.Object o)"], 2951AssertEx.Equal(["void C.M<System.Object?>()", "void C.M<System.Object?>(System.Object o)"], 2983AssertEx.Equal(["void C.M<System.Object?>()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 3014AssertEx.Equal(["void System.Object.M<System.Object>()"], model.GetMemberGroup(memberAccess).ToTestDisplayStrings()); 3046AssertEx.Equal(["void System.Object.M<System.Object>()", "void System.Object.M<System.Object>(System.Object ignored)"], 3081AssertEx.Equal(["void System.Object.F<System.Object>()", "void System.Object.F()"], 10393AssertEx.Equal(expectedInfo, variables.Select(v => getVariableInfo(model, v))); 12038AssertEx.Equal(expectedTypes, actualTypes); 12083AssertEx.Equal(expectedTypes, actualTypes); 12132AssertEx.Equal(expectedTypes, actualTypes);

4982AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 4986AssertEx.Equal(@"i1.Test(""name"", value)", call.ToString()); 4988AssertEx.Equal("System.Object I1.Test(System.String name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 4990AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 4991AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 4994AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 5063AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5106AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5110AssertEx.Equal(@"i1.Test(""name"", value)", call.ToString()); 5112AssertEx.Equal("System.Int32 I1.Test(System.String name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 5114AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5115AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5118AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 5186AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5229AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5233AssertEx.Equal(@"i1.Test(""name"", value)", call.ToString()); 5235AssertEx.Equal("dynamic I1.Test(System.String name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 5237AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5238AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5241AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 5310AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5347AssertEx.Equal(@"new C().Test(""name"", d)", call.ToString()); 5388AssertEx.Equal(@"Test(name: ""name"", d)", call.ToString()); 5390AssertEx.Equal(@"System.Int32 C.Test(System.String name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 5392AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5393AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5432AssertEx.Equal(@"Test(&name, d)", call.ToString()); 5434AssertEx.Equal("System.Int32 C.Test(System.String* name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 5436AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5437AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5476AssertEx.Equal(@"Test(""name"", d)", call.ToString()); 5478AssertEx.Equal(@"System.Int32 C.Test(System.String name, System.Object value, params System.Collections.Generic.List<System.Int32> list)", symbolInfo.Symbol.ToTestDisplayString()); 5480AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5481AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5484AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 5520AssertEx.Equal(@"Test(""name"", d)", call.ToString()); 5522AssertEx.Equal(@"System.Int32 C.Test(System.String name, System.Object value, params System.Int32[] list)", symbolInfo.Symbol.ToTestDisplayString()); 5524AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5525AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5528AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 5697AssertEx.Equal(@"i1(""name"", value)", call.ToString()); 5699AssertEx.Equal("System.Object Test.Invoke(System.String name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 5701AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5702AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5705AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 5738AssertEx.Equal(@"Test(name: ""name"", d)", call.ToString()); 5740AssertEx.Equal(@"System.Int32 C.D.Invoke(System.String name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 5742AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5743AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5783AssertEx.Equal(@"Test(&name, d)", call.ToString()); 5785AssertEx.Equal("System.Int32 C.D.Invoke(System.String* name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 5787AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5788AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5828AssertEx.Equal(@"Test(""name"", d)", call.ToString()); 5830AssertEx.Equal(@"System.Int32 C.D.Invoke(System.String name, System.Object value, params System.Collections.Generic.List<System.Int32> list)", symbolInfo.Symbol.ToTestDisplayString()); 5832AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5833AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5836AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 5873AssertEx.Equal(@"Test(""name"", d)", call.ToString()); 5875AssertEx.Equal(@"System.Int32 C.D.Invoke(System.String name, System.Object value, params System.Int32[] list)", symbolInfo.Symbol.ToTestDisplayString()); 5877AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 5878AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 5881AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 6028AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6033AssertEx.Equal("System.Object I1.this[System.String name, System.Object value] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 6035AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6036AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6039AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 6108AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6151AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6156AssertEx.Equal("System.Int32 I1.this[System.String name, System.Object value] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 6158AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6159AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6162AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 6231AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6271AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6276AssertEx.Equal("dynamic I1.this[System.String name, System.Object value] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 6278AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6279AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6282AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 6351AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6384AssertEx.Equal("System.Int32 C.this[System.String name, System.Object value] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 6386AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6387AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6390AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 6426AssertEx.Equal("System.Int32 C.this[System.String* name, System.Object value] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 6428AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6429AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6473AssertEx.Equal("System.Int32 C.this[System.String name, System.Object value, params System.Collections.Generic.List<System.Int32> list] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 6475AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6476AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6517AssertEx.Equal("System.Int32 C.this[System.String name, System.Object value, params System.Int32[] list] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 6519AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6520AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6562AssertEx.Equal("ref System.Int32 C.this[System.Int32 x] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 6564AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6565AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6573AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6574AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6616AssertEx.Equal("System.Int32* C.this[System.Int32 x] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 6618AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6619AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6677AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6682AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 6684AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6685AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6692AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6693AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6696AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 6697AssertEx.Equal("System.Int32", operation.Value.Type.ToTestDisplayString()); 6698AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 6702AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 6703AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 6740AssertEx.Equal("dynamic?", typeInfo.Type.ToTestDisplayString()); 6786AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6791AssertEx.Equal("dynamic C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 6793AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6794AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6801AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6802AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6805AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 6806AssertEx.Equal("System.Int32", operation.Value.Type.ToTestDisplayString()); 6807AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 6811AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 6812AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 6849AssertEx.Equal("dynamic?", typeInfo.Type.ToTestDisplayString()); 6896AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6901AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 6903AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6904AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6911AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6912AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6915AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 6916AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 6917AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 6921AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 6922AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 6960AssertEx.Equal("dynamic?", typeInfo.Type.ToTestDisplayString()); 6998AssertEx.Equal("System.IO.Stream C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 7000AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7001AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7008AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7009AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7012AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 7013AssertEx.Equal("System.Object", operation.Value.Type.ToTestDisplayString()); 7014AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 7018AssertEx.Equal("System.Object", typeInfo.Type.ToTestDisplayString()); 7019AssertEx.Equal("System.Object", typeInfo.ConvertedType.ToTestDisplayString()); 7065AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7070AssertEx.Equal("ref System.Int32 C.this[System.Int32 x] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 7072AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7073AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7080AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7081AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7085AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 7086AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 7122AssertEx.Equal("dynamic?", typeInfo.Type.ToTestDisplayString()); 7168AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7173AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 7175AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7176AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7183AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7184AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7186AssertEx.Equal("dynamic dynamic.op_Addition(dynamic left, System.Int32 right)", symbolInfo.Symbol.ToTestDisplayString()); 7189AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 7190AssertEx.Equal("System.Int32", operation.Value.Type.ToTestDisplayString()); 7191AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 7196AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 7197AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 7234AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7281AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7286AssertEx.Equal("dynamic C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 7288AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7289AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7296AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7297AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7299AssertEx.Equal("dynamic dynamic.op_Addition(dynamic left, System.Int32 right)", symbolInfo.Symbol.ToTestDisplayString()); 7302AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 7303AssertEx.Equal("System.Int32", operation.Value.Type.ToTestDisplayString()); 7304AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 7309AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 7310AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 7350AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7397AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7402AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 7404AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7405AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7412AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7413AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7415AssertEx.Equal("dynamic dynamic.op_Addition(dynamic left, dynamic right)", symbolInfo.Symbol.ToTestDisplayString()); 7418AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 7419AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 7420AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 7425AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7426AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7467AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7510AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7515AssertEx.Equal("C2 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 7517AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7518AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7525AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7527AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7529AssertEx.Equal("dynamic dynamic.op_Addition(dynamic left, C2 right)", symbolInfo.Symbol.ToTestDisplayString()); 7532AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 7533AssertEx.Equal("C2", operation.Value.Type.ToTestDisplayString()); 7534AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 7540AssertEx.Equal("C2", typeInfo.Type.ToTestDisplayString()); 7541AssertEx.Equal("C2", typeInfo.ConvertedType.ToTestDisplayString()); 7587AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7592AssertEx.Equal("ref System.Int32 C.this[System.Int32 x] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 7594AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7595AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7602AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7603AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7605AssertEx.Equal("dynamic dynamic.op_Addition(dynamic left, System.Int32 right)", symbolInfo.Symbol.ToTestDisplayString()); 7609AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 7610AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 7646AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7692AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7697AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 7699AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7700AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7707AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7708AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7710AssertEx.Equal("dynamic dynamic.op_Increment(dynamic value)", symbolInfo.Symbol.ToTestDisplayString()); 7713AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 7714AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 7752AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7798AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7803AssertEx.Equal("dynamic C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 7805AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7806AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7813AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7814AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7816AssertEx.Equal("dynamic dynamic.op_Increment(dynamic value)", symbolInfo.Symbol.ToTestDisplayString()); 7819AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 7820AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 7858AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7901AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7907AssertEx.Equal("C2 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 7909AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7910AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7917AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7921AssertEx.Equal("dynamic dynamic.op_Increment(dynamic value)", symbolInfo.Symbol.ToTestDisplayString()); 7924AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 7925AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 7973AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7978AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 7980AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7981AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7988AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 7989AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 7991AssertEx.Equal("dynamic dynamic.op_Increment(dynamic value)", symbolInfo.Symbol.ToTestDisplayString()); 7994AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 7995AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8033AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8079AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8084AssertEx.Equal("dynamic C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 8086AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8087AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8094AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8095AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8097AssertEx.Equal("dynamic dynamic.op_Increment(dynamic value)", symbolInfo.Symbol.ToTestDisplayString()); 8100AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8101AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8139AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8184AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8189AssertEx.Equal("ref System.Int32 C.this[System.Int32 x] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 8191AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8192AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8199AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8200AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8202AssertEx.Equal("dynamic dynamic.op_Increment(dynamic value)", symbolInfo.Symbol.ToTestDisplayString()); 8205AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8206AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8243AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8289AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8294AssertEx.Equal("System.String C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 8296AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8297AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8304AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8305AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8308AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8309AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 8310AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8314AssertEx.Equal("System.String", typeInfo.Type.ToTestDisplayString()); 8315AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8352AssertEx.Equal("dynamic?", typeInfo.Type.ToTestDisplayString()); 8398AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8403AssertEx.Equal("System.Int32? C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 8405AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8406AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8413AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8414AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8417AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8418AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 8419AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8423AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 8424AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8461AssertEx.Equal("dynamic?", typeInfo.Type.ToTestDisplayString()); 8507AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8512AssertEx.Equal("dynamic C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 8514AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8515AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8522AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8523AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8526AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8527AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 8528AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8532AssertEx.Equal("System.String", typeInfo.Type.ToTestDisplayString()); 8533AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8570AssertEx.Equal("dynamic?", typeInfo.Type.ToTestDisplayString()); 8617AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8622AssertEx.Equal("System.String C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 8624AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8625AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8632AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8633AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8636AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8637AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 8638AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8642AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8643AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8681AssertEx.Equal("dynamic?", typeInfo.Type.ToTestDisplayString()); 8731AssertEx.Equal("C2? C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 8733AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8734AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8741AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8742AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8745AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8746AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 8747AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8751AssertEx.Equal("System.String", typeInfo.Type.ToTestDisplayString()); 8752AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8800AssertEx.Equal("C2 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 8802AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8803AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8810AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8811AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8814AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8815AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 8816AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8820AssertEx.Equal("C2", typeInfo.Type.ToTestDisplayString()); 8821AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8867AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8872AssertEx.Equal("ref System.Int32? C.this[System.Int32 x] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 8874AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8875AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8882AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8883AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8886AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8887AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 8888AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8892AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 8893AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8930AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8931AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8938AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 8939AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 8942AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 8943AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 8944AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 8948AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 8949AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9020AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9021AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9028AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9029AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9032AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 9033AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 9034AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 9038AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 9039AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9111AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9112AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9119AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9120AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9123AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 9124AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 9125AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 9129AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9130AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9201AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9202AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9209AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9210AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9213AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 9214AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 9215AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 9219AssertEx.Equal("System.String", typeInfo.Type.ToTestDisplayString()); 9220AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9257AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9258AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9265AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9266AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9269AssertEx.Equal("dynamic", operation.Target.Type.ToTestDisplayString()); 9270AssertEx.Equal("dynamic", operation.Value.Type.ToTestDisplayString()); 9271AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 9275AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 9276AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9318AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9319AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9326AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9327AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9330AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 9439AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9440AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9447AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9448AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9451AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 9559AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9560AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9567AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9568AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9571AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 9673AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9674AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9681AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9682AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9685AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 9784AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9785AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9792AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9793AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9796AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 9895AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9896AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9903AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 9904AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 9907AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 10019AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10024AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 10026AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10027AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10034AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.Type.ToTestDisplayString()); 10035AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.ConvertedType.ToTestDisplayString()); 10039AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10040AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10051AssertEx.Equal("(System.Int32, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10052AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10056AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 10057AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10096AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10147AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10152AssertEx.Equal("dynamic C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 10154AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10155AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10162AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.Type.ToTestDisplayString()); 10163AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.ConvertedType.ToTestDisplayString()); 10167AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10168AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10179AssertEx.Equal("(System.Int32, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10180AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10184AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 10185AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10224AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10275AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10280AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 10282AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10283AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10290AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.Type.ToTestDisplayString()); 10291AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.ConvertedType.ToTestDisplayString()); 10295AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10296AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10307AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10308AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10312AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10313AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10352AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10429AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10434AssertEx.Equal("ref System.Int32 C.this[System.Int32 x] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 10436AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10437AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10444AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.Type.ToTestDisplayString()); 10445AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.ConvertedType.ToTestDisplayString()); 10449AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10450AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10461AssertEx.Equal("(System.Int32, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10462AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10466AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 10467AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10504AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10563AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10568AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 10570AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10571AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10578AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.Type.ToTestDisplayString()); 10579AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.ConvertedType.ToTestDisplayString()); 10583AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10584AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10595AssertEx.Equal("C2", typeInfo.Type.ToTestDisplayString()); 10596AssertEx.Equal("C2", typeInfo.ConvertedType.ToTestDisplayString()); 10651AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10711AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10716AssertEx.Equal("dynamic C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 10718AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10719AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10726AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.Type.ToTestDisplayString()); 10727AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.ConvertedType.ToTestDisplayString()); 10731AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 10732AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 10743AssertEx.Equal("C2", typeInfo.Type.ToTestDisplayString()); 10744AssertEx.Equal("C2", typeInfo.ConvertedType.ToTestDisplayString()); 10801AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10981AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10986AssertEx.Equal("ref System.Int32 C.this[System.Int32 x] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 10988AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 10989AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 10996AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.Type.ToTestDisplayString()); 10997AssertEx.Equal("(dynamic, System.Int32)", tupleTypeInfo.ConvertedType.ToTestDisplayString()); 11001AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 11002AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11013AssertEx.Equal("C2", typeInfo.Type.ToTestDisplayString()); 11014AssertEx.Equal("C2", typeInfo.ConvertedType.ToTestDisplayString()); 11067AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11107AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 11109AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11110AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11114AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 11115AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11119AssertEx.Equal("((dynamic, System.Int32), System.Int32)", typeInfo.Type.ToTestDisplayString()); 11120AssertEx.Equal("((dynamic, System.Int32), System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11124AssertEx.Equal("((dynamic, System.Int32), System.Int32)", typeInfo.Type.ToTestDisplayString()); 11125AssertEx.Equal("((dynamic, System.Int32), System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11131AssertEx.Equal("((System.Int32, System.Int32), System.Int32)", typeInfo.Type.ToTestDisplayString()); 11132AssertEx.Equal("((dynamic, System.Int32), System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11136AssertEx.Equal("(System.Int32, System.Int32)", typeInfo.Type.ToTestDisplayString()); 11137AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11141AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 11142AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11191AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 11193AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11194AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11198AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 11199AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11203AssertEx.Equal("((dynamic, System.Int32), System.Int32)", typeInfo.Type.ToTestDisplayString()); 11204AssertEx.Equal("((dynamic, System.Int32), System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11208AssertEx.Equal("((dynamic, System.Int32), System.Int32)", typeInfo.Type.ToTestDisplayString()); 11209AssertEx.Equal("((dynamic, System.Int32), System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11215AssertEx.Equal("(C2, System.Int32)", typeInfo.Type.ToTestDisplayString()); 11216AssertEx.Equal("(C2, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11220AssertEx.Equal("C2", typeInfo.Type.ToTestDisplayString()); 11221AssertEx.Equal("C2", typeInfo.ConvertedType.ToTestDisplayString()); 11269AssertEx.Equal("System.Int32 C.this[System.Int32 x] { get; set; }", symbolInfo.Symbol.ToTestDisplayString()); 11271AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11272AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11276AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 11277AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11281AssertEx.Equal("(dynamic, System.Int32)", typeInfo.Type.ToTestDisplayString()); 11282AssertEx.Equal("(dynamic, System.Int32)", typeInfo.ConvertedType.ToTestDisplayString()); 11323AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11327AssertEx.Equal(@"i1.Test(""name"", value)", call.ToString()); 11329AssertEx.Equal("System.Object I1.Test(System.String name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 11331AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11332AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11335AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 11376AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11380AssertEx.Equal(@"i1.Test(""name"", value)", call.ToString()); 11382AssertEx.Equal("System.Int32 I1.Test(System.String name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 11384AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11385AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11388AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 11456AssertEx.Equal(@"Test(""name"", d)", call.ToString()); 11458AssertEx.Equal(@"System.Int32 C.Test(System.String name, System.Object value, params System.Int32[] list)", symbolInfo.Symbol.ToTestDisplayString()); 11460AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11461AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11464AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 11500AssertEx.Equal(@"i1(""name"", value)", call.ToString()); 11502AssertEx.Equal("System.Object Test.Invoke(System.String name, System.Object value)", symbolInfo.Symbol.ToTestDisplayString()); 11504AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11505AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11508AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 11541AssertEx.Equal(@"Test(""name"", d)", call.ToString()); 11543AssertEx.Equal(@"System.Int32 C.D.Invoke(System.String name, System.Object value, params System.Int32[] list)", symbolInfo.Symbol.ToTestDisplayString()); 11545AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11546AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11549AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 11590AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11595AssertEx.Equal("System.Object I1.this[System.String name, System.Object value] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 11597AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11598AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11601AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 11642AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11647AssertEx.Equal("System.Int32 I1.this[System.String name, System.Object value] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 11649AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11650AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11653AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString()); 11687AssertEx.Equal("System.Int32 C.this[System.String name, System.Object value, params System.Int32[] list] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 11689AssertEx.Equal("dynamic", typeInfo.Type.ToTestDisplayString()); 11690AssertEx.Equal("dynamic", typeInfo.ConvertedType.ToTestDisplayString()); 11693AssertEx.Equal("dynamic", operation.Type.ToTestDisplayString());

907AssertEx.Equal(expectedOriginalType, typeInfo.Type!.ToTestDisplayString()); 908AssertEx.Equal(expectedConvertedType, typeInfo.ConvertedType!.ToTestDisplayString()); 1664AssertEx.Equal("void C.M1<System.String>(delegate*<System.String, System.Void> param1, delegate*<System.String, System.Void> param2)", 1697AssertEx.Equal("void C.M1<System.Object>(delegate*<delegate*<System.Object, System.Void>, System.Void> param1, delegate*<delegate*<System.Object, System.Void>, System.Void> param2)", 1730AssertEx.Equal("void C.M1<System.String>(delegate*<delegate*<System.String>, System.Void> param1, delegate*<delegate*<System.String>, System.Void> param2)", 1824AssertEx.Equal("void C.M1<System.Object>(delegate*<System.Object> param1, delegate*<System.Object> param2)", 1857AssertEx.Equal("void C.M1<System.String>(delegate*<delegate*<System.String, System.Void>> param1, delegate*<delegate*<System.String, System.Void>> param2)", 1890AssertEx.Equal("void C.M1<System.Object>(delegate*<delegate*<System.Object>> param1, delegate*<delegate*<System.Object>> param2)", 2009AssertEx.Equal("void C<D1, D2, D3, D4, D5, D6>.M1(delegate*<ref modopt(A<D6>) A<D4> modopt(A<D5>), ref modopt(A<T3>) A<D1> modopt(A<D2>)> param)", 2058AssertEx.Equal("void C.M1<D1, D2, D3, D4, D5, D6>(delegate*<ref modopt(A<D6>) A<D4> modopt(A<D5>), ref modopt(A<T3>) A<D1> modopt(A<D2>)> param)", 2089AssertEx.Equal("ptr = M(C.Field)", localSyntax.ToString()); 2092AssertEx.Equal("delegate* unmanaged<System.Int32>", local.Type.ToTestDisplayString()); 2095AssertEx.Equal("delegate* unmanaged<System.Int32>", typeInfo.Type.ToTestDisplayString()); 2127AssertEx.Equal("delegate* unmanaged[Stdcall, Cdecl]<System.Int32 modopt(System.Runtime.CompilerServices.CallConvStdcall) modopt(System.Runtime.CompilerServices.CallConvCdecl)>", funcPtrType.ToTestDisplayString()); 2128AssertEx.SetEqual(new[] 2246AssertEx.Equal(expectedTypes, invocationTypes); 2301AssertEx.Equal(expectedTypes, invocationTypes); 2376AssertEx.Equal(expectedTypes, invocationTypes); 2444AssertEx.Equal(expectedTypes, invocationTypes); 2512AssertEx.Equal(expectedTypes, invocationTypes); 2611AssertEx.Equal(expectedTypes, invocationTypes); 2684AssertEx.Equal(expectedTypes, invocationTypes);

632AssertEx.SetEqual(new[] { "System.Enum", "MyEnum" }, constraintTypeNames); 1145AssertEx.SetEqual(new[] { "System.Delegate", "D1" }, constraintTypeNames); 1630AssertEx.SetEqual(new[] { "System.MulticastDelegate", "D1" }, constraintTypeNames); 1906AssertEx.Equal(new string[] { "Enum", "IDisposable" }, typeParameter.ConstraintTypes().Select(type => type.Name));

3286AssertEx.SetEqual(new[] { comp2.SyntaxTrees[1] }, comp2.UsageOfUsingsRecordedInTrees); 3288AssertEx.SetEqual(new[] { comp2.SyntaxTrees[1] }, comp2.UsageOfUsingsRecordedInTrees); 3291AssertEx.SetEqual(new[] { comp2.SyntaxTrees[1], comp2.SyntaxTrees[2] }, comp2.UsageOfUsingsRecordedInTrees); 3293AssertEx.SetEqual(new[] { comp2.SyntaxTrees[1], comp2.SyntaxTrees[2] }, comp2.UsageOfUsingsRecordedInTrees); 3303AssertEx.SetEqual(new[] { comp2.SyntaxTrees[1] }, comp2.UsageOfUsingsRecordedInTrees);

49AssertEx.SetEqual(new[] { "C", "D" }, usingAliases1.Select(a => a.Key)); 57AssertEx.SetEqual(new[] { "C", "D" }, usingAliases2.Select(a => a.Key)); 85AssertEx.SetEqual(new[] { "D", "E", "F" }, usingAliases1.Select(a => a.Key)); 94AssertEx.SetEqual(new[] { "D", "E", "F" }, usingAliases2.Select(a => a.Key));

403AssertEx.SetEqual(members.ToTestDisplayStrings(), 1459AssertEx.Empty(propertyAttributes); 1468AssertEx.Empty(getterAttributes); 1472AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, getterAttributes); 1485AssertEx.Empty(setterAttributes); 1489AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, setterAttributes); 1497AssertEx.Empty(backingFieldAttributes); 1501AssertEx.Equal( 2429AssertEx.SetEqual(members.ToTestDisplayStrings(), new[] { 2540AssertEx.SetEqual(new[] {

6880AssertEx.Equal("xRCCFCvTOZMORzSr/fZQFlIAAABQcm9ncmFtLmNz", locationSpecifier.Data); 6881AssertEx.Equal("""[global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "xRCCFCvTOZMORzSr/fZQFlIAAABQcm9ncmFtLmNz")]""", locationSpecifier.GetInterceptsLocationAttributeSyntax()); 6889AssertEx.Equal("xRCCFCvTOZMORzSr/fZQFmAAAABQcm9ncmFtLmNz", otherLocation.Data); 6890AssertEx.Equal("""[global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "xRCCFCvTOZMORzSr/fZQFmAAAABQcm9ncmFtLmNz")]""", otherLocation.GetInterceptsLocationAttributeSyntax()); 7200AssertEx.Equal("""[global::System.Runtime.CompilerServices.InterceptsLocationAttribute(1, "jB4qgCy292LkEGCwmD+R6FIAAAA=")]""", locationSpecifier.GetInterceptsLocationAttributeSyntax()); 7958AssertEx.Equal("System.Span<System.Int32> D.M(this ref S s)", method.ToTestDisplayString());

4618AssertEx.Equal("System.String System.String.op_Addition(System.String left, System.String right)", semanticInfo.Symbol.ToTestDisplayString()); 6824AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6850AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6882AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6917AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6957AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6992AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7032AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7070AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7110AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7145AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7185AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7220AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7253AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7293AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7333AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7373AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7413AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7448AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7490AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7525AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7567AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7608AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7648AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7716AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7810AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7922AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7988AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8018AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8120AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8262AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8322AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8442AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8680AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8805AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8956AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9067AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9134AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9190AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9306AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9422AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9547AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9808AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9883AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 11941AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute",

3621AssertEx.Equal(expectedAttributes, pairs.Select(p => getAttributesInternal(p.Item1, p.Item2))); 3622AssertEx.Equal(expectedAttributes, pairs.Select(p => getAttributesPublic(p.Item1, p.Item2))); 3905AssertEx.Equal(expectedAttributes, actualAttributes); 7013AssertEx.Equal("System.Action", model.GetTypeInfo(action).Type.ToTestDisplayString()); 8444AssertEx.Equal("TResult <>f__AnonymousDelegate0<T1, TResult>.Invoke(params T1[] arg)", lam1.DelegateInvokeMethod.ToTestDisplayString()); 8455AssertEx.Equal("TResult <>f__AnonymousDelegate1<T1, T2, TResult>.Invoke(T1 arg1, params T2[] arg2)", lam3.DelegateInvokeMethod.ToTestDisplayString());

7049AssertEx.Equal(expectedSymbols, actualSymbols); 7107AssertEx.Equal(expectedSymbols, actualSymbols);

2302AssertEx.SetEqual(new[] { "default", "case int i:", "label1" }, symbols.Select(s => s.ToTestDisplayString())); 3130AssertEx.Equal(expectedSymbols, actualSymbols,

1082AssertEx.SetEqual( 1246AssertEx.SetEqual(

305AssertEx.Equal(nativeIntegerMembers.SelectAsArray(m => m.Name), nativeIntegerMemberNames); 309AssertEx.Equal(expectedMembers, actualMembers); 414AssertEx.Equal(nativeIntegerMembers.SelectAsArray(m => m.Name), nativeIntegerMemberNames); 1799AssertEx.Equal(expectedLocals, actualLocals); 1820AssertEx.Equal(expectedMembers, actualMembers); 1985AssertEx.Equal(expectedMembers, actualMembers); 2149AssertEx.Equal(expectedMembers, actualMembers); 2248AssertEx.Equal(expectedMembers, actualMembers); 2354AssertEx.Equal(expectedLocals, actualLocals); 2373AssertEx.Equal(expectedMembers, actualMembers); 2474AssertEx.Equal(expectedLocals, actualLocals); 2501AssertEx.Equal(expectedMembers, actualMembers); 2650AssertEx.Equal(expectedMembers, actualMembers); 2751AssertEx.Equal(expectedMembers, actualMembers); 2902AssertEx.Equal(expectedMembers, actualMembers); 6071AssertEx.Equal(expectedOperators, actualOperators); 6130AssertEx.Equal(expectedOperators, actualOperators);

427AssertEx.Equal(new[] { "void C.M(System.Int32 a, System.Int32 b, [System.Int32 c = 1])" },

211AssertEx.Equal(expectedAnalyzedKeys, actualAnalyzedKeys); 260AssertEx.Equal(expectedAnalyzedKeys, actualAnalyzedKeys); 319AssertEx.Equal(expectedAnalyzedKeys, actualAnalyzedKeys); 357AssertEx.Equal(expectedAnalyzedKeys, actualAnalyzedKeys); 396AssertEx.Equal(expectedAnalyzedKeys, actualAnalyzedKeys); 431AssertEx.Equal(expectedAnalyzedKeys, actualAnalyzedKeys); 727AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 728AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 987AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 988AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1068AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 1069AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1152AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 1153AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1211AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 1212AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1302AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 1303AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1359AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 1360AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1455AssertEx.Equal(expectedAnalyzedKeys, actualAnalyzedKeys); 1495AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 1496AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1531AssertEx.Equal(new[] { "= null", "= null", "F2" }, actualAnalyzedKeys); 1617AssertEx.Equal(expectedAnalyzedKeys, actualAnalyzedKeys); 1741AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 1742AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1784AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 1785AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1846AssertEx.Equal(expectedAnalyzedKeys, GetNullableDataKeysAsStrings(comp.TestOnlyCompilationData, requiredAnalysis: true)); 1847AssertEx.Equal(expectedAnalyzedKeys, GetIsNullableEnabledMethods(comp.TestOnlyCompilationData)); 1884AssertEx.Equal(new[] { "A(A.F1 = null)" }, actualAnalyzedKeys); 1939AssertEx.Equal(new[] { expectedAnalyzedKey }, actualAnalyzedKeys); 1975AssertEx.Equal(new[] { "o1" }, actualAnalyzedKeys); 2016AssertEx.Equal(new[] { "F2", "F3" }, actualAnalyzedKeys); 2055AssertEx.Equal(new[] { "P2", "P3" }, actualAnalyzedKeys);

13512AssertEx.Equal("S?[]", model.GetTypeInfo(returnStatement.Expression).Type.ToTestDisplayString()); 30175AssertEx.Empty(copenAttributes); 30179AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)" }, copenAttributes); 30186AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.MaybeNullAttribute" }, propertyAttributes); 30190AssertEx.Empty(propertyAttributes); 30197AssertEx.Empty(getterAttributes); 30201AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, getterAttributes); 30208AssertEx.Empty(getterReturnAttributes); 30212AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.MaybeNullAttribute" }, getterReturnAttributes); 30219AssertEx.Empty(setterAttributes); 30223AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, setterAttributes.Select(a => a.ToString())); 30228AssertEx.Empty(setterReturnAttributes); 30278AssertEx.Empty(copenAttributes); 30282AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)" }, copenAttributes); 30289AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.MaybeNullAttribute", "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, propertyAttributes); 30293AssertEx.Empty(propertyAttributes); 30300AssertEx.Empty(getterAttributes); 30304AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, getterAttributes); 30311AssertEx.Empty(getterReturnAttributes); 30315AssertEx.Equal(new[] { 30802AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.MaybeNullAttribute" }, fieldAttributes); 30806AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableAttribute(1)", "System.Diagnostics.CodeAnalysis.MaybeNullAttribute" }, fieldAttributes); 40789AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.AllowNullAttribute" }, fieldAttributes); 40793AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableAttribute(1)", "System.Diagnostics.CodeAnalysis.AllowNullAttribute" }, fieldAttributes); 40963AssertEx.Empty(copenAttributes); 40967AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)", "System.Reflection.DefaultMemberAttribute(\"Item\")" }, copenAttributes); 40974AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.AllowNullAttribute" }, propertyAttributes); 40978AssertEx.Empty(propertyAttributes); 40983AssertEx.Empty(setterAttributes); 40989AssertEx.Empty(setterValueAttributes); 40993AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.AllowNullAttribute" }, setterValueAttributes); 40998AssertEx.Empty(setterReturnAttributes); 41024AssertEx.Empty(copenAttributes); 41028AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)", "System.Reflection.DefaultMemberAttribute(\"Item\")" }, copenAttributes); 41035AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.AllowNullAttribute", "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, propertyAttributes); 41039AssertEx.Empty(propertyAttributes); 41044AssertEx.Empty(setterAttributes); 41050AssertEx.Empty(setterValueAttributes); 41054AssertEx.Equal(new[] { 44644AssertEx.Empty(copenAttributes); 44648AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)" }, copenAttributes); 44655AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, propertyAttributes); 44659AssertEx.Empty(propertyAttributes); 44666AssertEx.Empty(setterAttributes); 44670AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, setterAttributes); 44677AssertEx.Empty(setterValueAttributes); 44681AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, setterValueAttributes); 44893AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, fieldAttributes); 44897AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableAttribute(1)", "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, fieldAttributes); 47981AssertEx.Empty(copenAttributes); 47985AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)", "System.Reflection.DefaultMemberAttribute(\"Item\")" }, copenAttributes); 47992AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, propertyAttributes); 47996AssertEx.Empty(propertyAttributes); 48005AssertEx.Empty(getterReturnAttributes); 48009AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, getterReturnAttributes); 48093AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, fieldAttributes); 48097AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableAttribute(1)", "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, fieldAttributes); 111714AssertEx.Equal(expectedTypes, constraintTypes.SelectAsArray(t => t.ToTestDisplayString(true))); 111779AssertEx.Equal(expectedConstraintTypes, constraintTypes.SelectAsArray(t => t.ToTestDisplayString(true))); 111832AssertEx.Equal(expectedConstraintTypes, constraintTypes.SelectAsArray(t => t.ToTestDisplayString(true))); 116598AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, actual); 126918AssertEx.Equal<NullableAnnotation>(expected, getResult, (na1, na2) => na1 == na2, na => $"NullableAnnotation.{na}", "{0,-32:G}", size); 126923AssertEx.Equal<NullableFlowState>(expected, getResult, (na1, na2) => na1 == na2, na => $"NullableFlowState.{na}", "{0,-32:G}", size); 138242AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138249AssertEx.Equal("I<T>", interfaces[0].ToTestDisplayString(includeNonNullable: true)); 138251AssertEx.Equal("I<T>", interfaces[1].ToTestDisplayString(includeNonNullable: true)); 138257AssertEx.Equal("I<T>", i.ToTestDisplayString(includeNonNullable: true)); 138286AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138290AssertEx.Equal("I<T, T>", i.ToTestDisplayString(includeNonNullable: true)); 138326AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138330AssertEx.Equal("I<T, System.Object?>", i.ToTestDisplayString(includeNonNullable: true)); 138334AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138338AssertEx.Equal("I<System.Object!, T>", i.ToTestDisplayString(includeNonNullable: true)); 138374AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138378AssertEx.Equal("I<T, System.Object>", i.ToTestDisplayString(includeNonNullable: true)); 138382AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138386AssertEx.Equal("I<System.Object!, T>", i.ToTestDisplayString(includeNonNullable: true)); 138411AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138415AssertEx.Equal("I<T?>", i.ToTestDisplayString(includeNonNullable: true)); 138441AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138445AssertEx.Equal("I<T?>", i.ToTestDisplayString(includeNonNullable: true)); 138471AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138475AssertEx.Equal("I<T?>", i.ToTestDisplayString(includeNonNullable: true)); 138499AssertEx.Equal("T", cT.ToTestDisplayString(includeNonNullable: true)); 138503AssertEx.Equal("I<T?>", i.ToTestDisplayString(includeNonNullable: true)); 157922AssertEx.Equal(new string[] { "I<dynamic>", "I2<object>" }, 157924AssertEx.Equal(new string[] { "I<dynamic>", "I2<object>", "I<object>" }, 157956AssertEx.Equal(new string[] { "I<(int a, int b)>", "I2<(int notA, int notB)>" }, 157958AssertEx.Equal(new string[] { "I<(int a, int b)>", "I2<(int notA, int notB)>", "I<(int notA, int notB)>" }, 157994AssertEx.Equal(new string[] { "I<(object a, object b)>", "I2<(object notA, object notB)>" }, 157996AssertEx.Equal(new string[] { "I<(object a, object b)>", "I2<(object notA, object notB)>", "I<(object notA, object notB)>" }, 158022AssertEx.Equal(new string[] { "I<object>", "I2<object>" }, 158024AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 158054AssertEx.Equal(new string[] { "I<object>", "I2<object>" }, 158056AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 158223AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 158225AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 158264AssertEx.Equal(new string[] { "I<object>", "I2<object>" }, 158266AssertEx.Equal(new string[] { "I<object>", "I2<object>", "I<object!>" }, 158304AssertEx.Equal(new string[] { "I<object>", "I2<object>" }, 158306AssertEx.Equal(new string[] { "I<object>", "I2<object>", "I<object!>" }, 158518AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 158520AssertEx.Equal(new string[] { "I2<object>", "I<object!>", "I<object>" }, 158560AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 158562AssertEx.Equal(new string[] { "I2<object>", "I<object!>", "I<object>" }, 158641AssertEx.Equal(new string[] { "I<object?>", "I2<object>" }, 158643AssertEx.Equal(new string[] { "I<object?>", "I2<object>", "I<object!>" }, 158673AssertEx.Equal(new string[] { "I<object?>", "I2<object>" }, 158675AssertEx.Equal(new string[] { "I<object?>", "I2<object>", "I<object>" }, 158707AssertEx.Equal(new string[] { "I<object?>", "I2<object!>" }, 158709AssertEx.Equal(new string[] { "I<object?>", "I2<object!>", "I<object!>" },

4229AssertEx.Equal("ref System.Int32 C.this[System.Int32 x] { get; }", symbolInfo.Symbol.ToTestDisplayString()); 4231AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 4232AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 4235AssertEx.Equal(symbolInfo.Symbol.ToTestDisplayString(), propertyRef.Property.ToTestDisplayString()); 4240AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 4241AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 4244AssertEx.Equal("System.Int32", operation.Target.Type.ToTestDisplayString()); 4245AssertEx.Equal("System.Int32", operation.Value.Type.ToTestDisplayString()); 4246AssertEx.Equal("System.Int32", operation.Type.ToTestDisplayString()); 4250AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 4251AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 4283AssertEx.Equal("ref System.Int32 C.P { get; }", symbolInfo.Symbol.ToTestDisplayString()); 4285AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 4286AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 4289AssertEx.Equal(symbolInfo.Symbol.ToTestDisplayString(), propertyRef.Property.ToTestDisplayString()); 4294AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 4295AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString()); 4298AssertEx.Equal("System.Int32", operation.Target.Type.ToTestDisplayString()); 4299AssertEx.Equal("System.Int32", operation.Value.Type.ToTestDisplayString()); 4300AssertEx.Equal("System.Int32", operation.Type.ToTestDisplayString()); 4304AssertEx.Equal("System.Int32", typeInfo.Type.ToTestDisplayString()); 4305AssertEx.Equal("System.Int32", typeInfo.ConvertedType.ToTestDisplayString());