85AssertEx.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);

38AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(fxDir), output); 42AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(), output); 50AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(srcDir.Path), output); 58AssertEx.AssertEqualToleratingWhitespaceDifferences(PrintSearchPaths(fxDir, dllDir), output); 76AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 77AssertEx.AssertEqualToleratingWhitespaceDifferences("", output); 83AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 84AssertEx.AssertEqualToleratingWhitespaceDifferences("", output);

84AssertEx.AssertEqualToleratingWhitespaceDifferences( 495AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 496AssertEx.AssertEqualToleratingWhitespaceDifferences("1", output); 722AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 723AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 749AssertEx.AssertEqualToleratingWhitespaceDifferences( 802AssertEx.AssertEqualToleratingWhitespaceDifferences("", error); 803AssertEx.AssertEqualToleratingWhitespaceDifferences( 828AssertEx.AssertEqualToleratingWhitespaceDifferences($@"{initFile.Path}(1,3): error CS1002: {CSharpResources.ERR_SemicolonExpected} 831AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 853AssertEx.AssertEqualToleratingWhitespaceDifferences( 866AssertEx.AssertEqualToleratingWhitespaceDifferences($@"(1,8): error CS0234: {string.Format(CSharpResources.ERR_DottedTypeNameNotFoundInNS, "Missing", "Microsoft")}", 953AssertEx.AssertEqualToleratingWhitespaceDifferences("C { P=null }", output); 993AssertEx.AssertEqualToleratingWhitespaceDifferences("120", output); 994AssertEx.AssertEqualToleratingWhitespaceDifferences("System.Exception: Bang!", error); 1001AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1002AssertEx.AssertEqualToleratingWhitespaceDifferences("8\r\n", await ReadOutputToEnd()); 1005AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1006AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadOutputToEnd()); 1009AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1010AssertEx.AssertEqualToleratingWhitespaceDifferences("4\r\n", await ReadOutputToEnd()); 1013AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1014AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadOutputToEnd()); 1017AssertEx.AssertEqualToleratingWhitespaceDifferences("", await ReadErrorOutputToEnd()); 1018AssertEx.AssertEqualToleratingWhitespaceDifferences("8\r\n", await ReadOutputToEnd());

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

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);

488AssertEx.Fail(BuildFailureMessage(expectedSpans, WellKnownDiagnosticTags.Unnecessary, markupKey, initialMarkupWithoutSpans, diagnostics)); 617AssertEx.EqualOrDiff(expectedText, actualText); 686AssertEx.Fail($"Could not find document with name '{doc.Name}'");

244AssertEx.Empty(analyzerExceptionDiagnostics, "Found analyzer exception diagnostics");

404AssertEx.Equal(new[] { "System.dll" }, cmd.Arguments.MetadataReferences.Select(r => r.Reference)); 405AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "a.cs"), Path.Combine(WorkingDirectory, "b.cs") }, cmd.Arguments.SourceFiles.Select(file => file.Path)); 457AssertEx.Equal(new[] { "first.cs", "second.cs", "b.cs", "a.cs", "c.cs", "d.cs", "last.cs" }.Select(prependBasePath), resolvedSourceFiles); 458AssertEx.Equal(new[] { typeof(object).Assembly.Location, @"..\v4.0.30319\System.dll", @".\System.Data.dll" }, references); 459AssertEx.Equal(new[] { RuntimeEnvironment.GetRuntimeDirectory() }.Concat(new[] { @"x", @"..\goo", @"../bar", @"a b" }.Select(prependBasePath)), args.ReferencePaths.ToArray()); 468AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 480AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 494AssertEx.Equal(ImmutableArray.Create<string>(), parser.KeyFileSearchPaths); 510AssertEx.Equal(ImmutableArray<string>.Empty, parser.ReferencePaths); 552AssertEx.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); 660AssertEx.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); 1139AssertEx.Equal(new[] { "a", "b", "c" }, 1146AssertEx.Equal(new[] { " b " }, 1182AssertEx.Equal(new[] { "{DIR}\\a.cs", "{DIR}\\b.cs", "{DIR}\\d2\\e.cs" }, 1187AssertEx.Equal(new[] { "{DIR}\\a.cs", "{DIR}\\b.cs" }, 1217AssertEx.Equal(new[] { "a", "b", "c" }, 1224AssertEx.Equal(new[] { " b " }, 1677AssertEx.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", "latest", "latestmajor", "preview" }, 1713AssertEx.SetEqual(versions, errorCodes); 2198AssertEx.Equal(File.ReadAllBytes(sl.Path), blob); 2227AssertEx.Equal(File.ReadAllBytes(sl.Path), blob); 2253AssertEx.Equal(slContent, actualData); 2268AssertEx.Equal(parsedArgs.SourceFiles, parsedArgs.EmbeddedFiles); 2269AssertEx.Equal( 2275AssertEx.Equal( 2281AssertEx.Equal( 2287AssertEx.Equal( 2293AssertEx.Equal( 2299AssertEx.Equal( 3486AssertEx.Equal( 3513AssertEx.Equal( 4487AssertEx.Equal(new[] 5119AssertEx.Equal(new[] { "Goo.Bar" }, parsedArgs.CompilationOptions.Usings.AsEnumerable()); 5123AssertEx.Equal(new[] { "Goo.Bar", "Baz", "System.Core", "System" }, parsedArgs.CompilationOptions.Usings.AsEnumerable()); 5127AssertEx.Equal(new[] { "Goo", "Bar" }, parsedArgs.CompilationOptions.Usings.AsEnumerable()); 5229AssertEx.Equal( 5233AssertEx.Equal(expectedOptions, actualOrdered.Select(entry => entry.Value)); 6415AssertEx.Equal(new[] { "a.cs", "b.cs", @"c.cs e.cs", "hello", "world" }, args); 6428AssertEx.Equal(new[] { "a.cs", "b#.cs", "c#d.cs", "#f.cs", "#g.cs #h.cs" }, args); 6435AssertEx.Equal(new[] { @"a\b\c", @"d\\e\\f\\", @"\\\g\\\h\\\i", @"\\\\", @"\\\\\k\\\\\" }, args); 6442AssertEx.Equal(new[] { @"a\""a", @"b\\""b c\\\""c d\\\\""d", @"e\\\\\""e", @"f"" g""" }, args); 6449AssertEx.Equal(new[] { @"/o:""goo.cs""", @"/o:""abc def""\baz", @"""/o:baz bar""bing" }, args); 6460AssertEx.Equal(new[] { @"d:\abc def\baz.cs", @"c:\abc de.cs" }, args.SourceFiles.Select(file => file.Path)); 8245AssertEx.Equal(csc.Arguments.MetadataReferences.Select(r => r.Reference), new string[] 8624AssertEx.AssertEqualToleratingWhitespaceDifferences("", outWriter.ToString()); 8629AssertEx.Equal(new byte[] { 0x4D, 0x5A }, ReadBytes(libDll.Path, 2)); 8630AssertEx.Equal(new[] { (byte)'D', (byte)'L', (byte)'L' }, ReadBytes(fsDll, 3)); 8632AssertEx.Equal(new byte[] { 0x4D, 0x69 }, ReadBytes(libPdb.Path, 2)); 8633AssertEx.Equal(new[] { (byte)'P', (byte)'D', (byte)'B' }, ReadBytes(fsPdb, 3)); 8638AssertEx.Equal(new[] { "Lib.cs", "Lib.dll", "Lib.pdb" }, Roslyn.Utilities.EnumerableExtensions.Order(Directory.GetFiles(dir.Path).Select(p => Path.GetFileName(p)))); 8668AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 8689AssertEx.Equal(new[] { (byte)'B', (byte)'S', (byte)'J', (byte)'B' }, ReadBytes(libPdb.Path, 4)); 8695AssertEx.Equal(new[] { "Lib.cs", "Lib.dll", "Lib.pdb" }, Roslyn.Utilities.EnumerableExtensions.Order(Directory.GetFiles(dir.Path).Select(p => Path.GetFileName(p)))); 8731AssertEx.Equal(new[] { (byte)'D', (byte)'L', (byte)'L' }, ReadBytes(libDll.Path, 3)); 8732AssertEx.Equal(new[] { (byte)'D', (byte)'L', (byte)'L' }, ReadBytes(fsDll, 3)); 8736AssertEx.Equal(new[] { "Lib.cs", "Lib.dll" }, Roslyn.Utilities.EnumerableExtensions.Order(Directory.GetFiles(dir.Path).Select(p => Path.GetFileName(p)))); 9842AssertEx.Equal(expectedWarningsAll, compileAndRun(featureOpt: null)); 9843AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis")); 9844AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=always")); 9845AssertEx.Equal(expectedWarningsNone, compileAndRun("/features:run-nullable-analysis=never")); 9846AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=ALWAYS")); // unrecognized value (incorrect case) ignored 9847AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=NEVER")); // unrecognized value (incorrect case) ignored 9848AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=true")); // unrecognized value ignored 9849AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=false")); // unrecognized value ignored 9850AssertEx.Equal(expectedWarningsAll, compileAndRun("/features:run-nullable-analysis=unknown")); // unrecognized value ignored 11183AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11184AssertEx.Equal(new[] { "b", "c" }, args.ScriptArguments); 11187AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "@script.csx") }, args.SourceFiles.Select(f => f.Path)); 11188AssertEx.Equal(new[] { "b", "c" }, args.ScriptArguments); 11191AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "-script.csx") }, args.SourceFiles.Select(f => f.Path)); 11192AssertEx.Equal(new[] { "b", "c" }, args.ScriptArguments); 11195AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11196AssertEx.Equal(new[] { "--", "b", "c" }, args.ScriptArguments); 11199AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11200AssertEx.Equal(new[] { "a", "b", "c" }, args.ScriptArguments); 11203AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11204AssertEx.Equal(new[] { "a", "--", "b", "c" }, args.ScriptArguments); 11208AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11209AssertEx.Equal(new[] { "a", "b", "c" }, args.ScriptArguments); 11213AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "script.csx") }, args.SourceFiles.Select(f => f.Path)); 11214AssertEx.Equal(new[] { "a", "b", "c" }, args.ScriptArguments); 11218AssertEx.Equal(new[] { Path.Combine(WorkingDirectory, "--") }, args.SourceFiles.Select(f => f.Path)); 11220AssertEx.Equal(new[] { "--" }, args.ScriptArguments); 11330AssertEx.Equal(expected, CommandLineParser.SplitWithDoubledSeparatorEscaping(str, ',')); 11490AssertEx.Equal(programExe32.ReadAllBytes(), programExe64.ReadAllBytes()); 11491AssertEx.Equal(programPdb32.ReadAllBytes(), programPdb64.ReadAllBytes()); 11791AssertEx.AssertEqualToleratingWhitespaceDifferences( 12001AssertEx.AssertEqualToleratingWhitespaceDifferences( 12007AssertEx.AssertEqualToleratingWhitespaceDifferences("", result.Output.Trim());

46AssertEx.EqualOrDiff(

78AssertEx.EqualOrDiff(

450AssertEx.SetEqual(items.Select(i => i.DisplayText), toTypes); 512AssertEx.SetEqual(items.Select(i => i.DisplayText), expected);

68AssertEx.Equal(new[] { "yy", "xx" }, terms); 114AssertEx.Equal(expectedTerms, actualTerms ?? Array.Empty<string>());

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

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

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

342AssertEx.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);

202AssertEx.Equal(new[] 209AssertEx.Equal(new[] { "(0,10)-(0,15)", "(0,20)-(0,25)" }, spans2.Select(s => s.LineSpan.ToString())); 216AssertEx.Equal(new[] 222AssertEx.Empty(await trackingSession.GetAdjustedTrackingSpansAsync(document2, snapshot2, CancellationToken.None)); 229AssertEx.Equal(new[] 240AssertEx.Equal(new[]

80AssertEx.Equal(expectedSpans, actualSpans,

117AssertEx.Equal(Array.Empty<SyntaxKind>(), unhandledKinds); 769AssertEx.Equal(new[] { expectedDiagnostic }, result.RudeEditErrors.Select(d => d.ToDiagnostic(newSyntaxTree))

29AssertEx.Equal(new[] 45AssertEx.Equal(new[] 61AssertEx.Equal(new[] 77AssertEx.Equal(new[]

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

114AssertEx.EqualOrDiff(expected, actual);

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

76AssertEx.Equal(@"

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

177AssertEx.Equal(Enumerable(new Span(62, 1), new Span(71, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start)); 189AssertEx.Equal(Enumerable(new Span(62, 1), new Span(71, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start)); 193AssertEx.Equal(Enumerable(new Span(82, 1), new Span(138, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start)); 205AssertEx.Equal(Enumerable(new Span(82, 1), new Span(138, 1)), result.Select(ts => ts.Span.Span).OrderBy(s => s.Start));

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

786AssertEx.NotNull(actualText); 787AssertEx.NotNull(actualText.Encoding); 788AssertEx.Equal(encoding.WebName, actualText.Encoding.WebName); 789AssertEx.EqualOrDiff(source, actualText.ToString()); 815AssertEx.NotNull(actualText); 816AssertEx.NotNull(actualText.Encoding); 817AssertEx.Equal(encoding.WebName, actualText.Encoding.WebName); 818AssertEx.EqualOrDiff(source, actualText.ToString()); 844AssertEx.NotNull(actualText); 845AssertEx.NotNull(actualText.Encoding); 846AssertEx.Equal(encoding.WebName, actualText.Encoding.WebName); 847AssertEx.EqualOrDiff(source, actualText.ToString()); 936AssertEx.NotNull(symbol, $"Couldn't find symbol to go-to-def for.");

78AssertEx.NotNull(info); 115AssertEx.NotNull(info); 267AssertEx.NotNull(info);

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

98AssertEx.NotNull(result);

854AssertEx.SetEqual(new[] { "AsyncIteratorStateMachineAttribute" }, 1577AssertEx.SetEqual(new[] { 1597AssertEx.SetEqual(new[] { 2115AssertEx.SetEqual(new[] { 2136AssertEx.SetEqual(new[] { 3924AssertEx.SetEqual(expectedFields, fields);

238AssertEx.Equal(new[] 251AssertEx.Equal(new[] 290AssertEx.Equal(new[] 308AssertEx.Equal(new[] 1000AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 1158AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 1252AssertEx.Equal(new[]

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

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

3957AssertEx.Equal(new[] 3966AssertEx.SetEqual(new[] 3976AssertEx.SetEqual(new[] 3986AssertEx.SetEqual(new[] 3996AssertEx.SetEqual(new[] 4028AssertEx.Equal(new[] 4069AssertEx.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()); 3075AssertEx.Equal(expectedMembers, model.GetMemberGroup(addressOfs[0].Operand).Select(m => m.ToTestDisplayString(includeNonNullable: false))); 3076AssertEx.Equal(expectedMembers, model.GetMemberGroup(addressOfs[1].Operand).Select(m => m.ToTestDisplayString(includeNonNullable: false))); 4117AssertEx.Equal(new[] { "void C.M1()" }, model.GetMemberGroup(methodGroup1).Select(m => m.ToTestDisplayString(includeNonNullable: false))); 6469AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 6522AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 6580AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString()); 6646AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 6724AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 6803AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, m.ToTestDisplayString(includeNonNullable: true)); 10763AssertEx.Equal("System.Func<delegate*<System.Int32, System.Void>>", 10765AssertEx.Equal("System.Func<delegate*<System.Int32, System.Void>>", 10772AssertEx.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));

4473AssertEx.Equal(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2" }, vt2.TupleElements.ToTestDisplayStrings()); 4476AssertEx.Equal(new[] { 5935AssertEx.SetEqual(vt2.MemberNames.ToArray(), new[] { ".ctor", "ToString" }); 6081AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, System.ValueTuple<System.String>[missing]>[missing]", 6131AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, (System.String, System.Int32)[missing]>[missing]", 6481AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, System.ValueTuple<System.String>[missing]>[missing]", 6501AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, (System.String, System.Int32)[missing]>[missing]", 6522AssertEx.Equal("System.ValueTuple<System.Int32, System.String, System.Int32, System.String, System.Int32, System.String, System.Int32, (System.String, System.Int32)[missing]>[missing]", 11173AssertEx.SetEqual(new[] { 11191AssertEx.SetEqual(new[] { 11436AssertEx.Equal(new[] { 11463AssertEx.Equal(new[] { 11500AssertEx.Equal(new[] { "T1", "T2", "T3", "T4", "T5", "T6", "T7", "TRest" }, m1Tuple.TypeParameters.ToTestDisplayStrings()); 11505AssertEx.Equal(new[] { "System.Int32", "System.Int32", "System.Int32", "System.Int32", "System.Int32", "System.Int32", "System.Int32", "(System.Int32, System.Int32)" }, 12705AssertEx.Equal(new[] { 13884AssertEx.Equal(baseLine, symbols.Select(s => s.ToTestDisplayString())); 14107AssertEx.Equal("System.ValueTuple<System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, (System.Int32 a, System.Int32 b)>", 16583AssertEx.Equal(new[] { 16588AssertEx.Equal("System.Int32 (System.Int32, System.Int32)[missing].Item1", 16620AssertEx.Equal(new[] { 16627AssertEx.Equal("System.Int32 (System.Int32 a, System.Int32 b)[missing].Item1", 16630AssertEx.Equal("System.Int32 (System.Int32 a, System.Int32 b)[missing].a", 22808AssertEx.SetEqual(new[] { "mscorlib 4.0", "System.ValueTuple 4.0" }, reader.DumpAssemblyReferences()); 22817AssertEx.SetEqual(new[] { "mscorlib 4.0", "System.ValueTuple 4.0" }, reader.DumpAssemblyReferences()); 22848AssertEx.SetEqual(new[] { "mscorlib 4.0", "lib 0.0" }, reader.DumpAssemblyReferences()); 22857AssertEx.SetEqual(new[] { "mscorlib 4.0", "lib 0.0" }, reader.DumpAssemblyReferences()); 22891AssertEx.SetEqual(xSymbol.GetMembers().OfType<IFieldSymbol>().Select(f => f.Name), 26863AssertEx.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()); 26916AssertEx.Equal("System.Collections.Generic.IEnumerable<Container<(System.Int32 alice, System.Int32 bob)>[missing]>", 26988AssertEx.Equal(decodingSuccessful 28022AssertEx.SetEqual(new string[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "(T1, T2)..ctor()" }, 28024AssertEx.SetEqual(new string[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "(T1, T2)..ctor()" }, 28109AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2" }, fields.ToTestDisplayStrings()); 28239AssertEx.SetEqual(new[] { 28245AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2" }, 28348AssertEx.SetEqual(new[] { "System.ValueTuple<T1>", 28444AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "System.String (T1, T2).field" }, namedType.GetFieldsToEmit().ToTestDisplayStrings()); 28447AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "System.String (T1, T2).field" }, fields.ToTestDisplayStrings()); 28532AssertEx.SetEqual(new[] { "T1 (T1, T2).Item1", "T2 (T1, T2).Item2", "System.String (T1, T2).<Property>k__BackingField" }, fields.ToTestDisplayStrings()); 28733AssertEx.SetEqual(new[] { 28741AssertEx.SetEqual(new[] { 28749AssertEx.SetEqual(new[] { 28761AssertEx.SetEqual(new[] { 28773AssertEx.SetEqual(new[] { 28788AssertEx.SetEqual(new[] { 28847AssertEx.SetEqual(new[] { 28869AssertEx.SetEqual(new[] { 28892AssertEx.SetEqual(new[] { 28930AssertEx.SetEqual(new[] { 28943AssertEx.SetEqual(new[] { 29041AssertEx.Equal("System.ValueTuple<System.Object, System.Object, System.Object, System.Object, System.Object, System.Object, System.Object, (System.Object, System.Object)>", 29059AssertEx.Equal("System.ValueTuple<System.Object!, System.Object?, System.Object!, System.Object?, System.Object!, System.Object?, System.Object!, (System.Object?, System.Object!)>", 29073AssertEx.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}", 29100AssertEx.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)); 5370AssertEx.Equal(expectedNames, actualNames); 5433AssertEx.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);

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

41AssertEx.Equal(expected, actual, message: GetAssertMessage("TypeDefs don't match")); 47AssertEx.Equal(expected, actual, message: GetAssertMessage("MethodDefs don't match")); 53AssertEx.Equal(expected, actual, message: GetAssertMessage("MemberRefs don't match")); 59AssertEx.Equal(expected, actual, message: GetAssertMessage("FieldDefs don't match")); 65AssertEx.Equal(expected, actual, message: GetAssertMessage("PropertyDefs don't match")); 71AssertEx.SetEqual(expected, actual, itemSeparator: ",\r\n", itemInspector: s => $"\"{s}\""); 76AssertEx.AreEqual(expected, _metadataReader.GetTableRowCount(table), message: GetAssertMessage($"{table} table size doesnt't match")); 81AssertEx.Equal(expected, _metadataReader.GetEditAndContinueLogEntries(), itemInspector: EncLogRowToString, message: GetAssertMessage("EncLog doesn't match")); 86AssertEx.Equal(expected, _metadataReader.GetEditAndContinueMapEntries(), itemInspector: EncMapRowToString, message: GetAssertMessage("EncMap doesn't match")); 91AssertEx.Equal(expected, _metadataReader.GetEditAndContinueLogEntries().Where(e => IsDefinition(e.Handle.Kind)), itemInspector: EncLogRowToString, message: GetAssertMessage("EncLog definitions don't match")); 96AssertEx.Equal(expected, _metadataReader.GetEditAndContinueMapEntries().Where(e => IsDefinition(e.Kind)), itemInspector: EncMapRowToString, message: GetAssertMessage("EncMap definitions don't match")); 101AssertEx.Equal(expected, _metadataReader.GetCustomAttributeRows(), itemInspector: AttributeRowToString);

158AssertEx.Equal( 169AssertEx.Equal( 180AssertEx.Equal( 191AssertEx.Equal( 198AssertEx.Equal(rows, reader.GetCustomAttributeRows(), itemInspector: AttributeRowToString); 209AssertEx.Equal(expectedNames, actualNames); 215AssertEx.Equal(expectedNames, actualNames); 233AssertEx.Equal(expectedNames, entityHandles.Select(handle => 249AssertEx.Equal(expectedValue, attributeData); 258AssertEx.Equal(expectedValue, attributeData);

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

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

90AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 270AssertEx.Equal(new[] 2308AssertEx.Equal(new byte[] 2321AssertEx.Equal(new byte[] 2348AssertEx.Equal(new byte[] { 0xFF, 0x25, 0x00, 0x20, 0x00, 0x10, 0x00, 0x00 }, startupStub); 2406AssertEx.Equal(new byte[] { 0, 0x20, 0, 0, 0x0c, 0, 0, 0, 0x80, 0x33, 0, 0 }, relocBytes);

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);

2786AssertEx.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}\")");

1767AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop1.GetMethod.GetAttributes())); 1768AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop1.SetMethod.GetAttributes())); 1771AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(1)" }), GetAttributeStrings(field1.GetAttributes())); 1775AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop2.GetMethod.GetAttributes())); 1779AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(2)" }), GetAttributeStrings(field2.GetAttributes())); 1783AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop3.GetMethod.GetAttributes())); 1787AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(33)" }), GetAttributeStrings(field3.GetAttributes())); 1791AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop3.GetMethod.GetAttributes())); 1795AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(44)", "A(444)" }), GetAttributeStrings(field4.GetAttributes())); 1828AssertEx.SetEqual(s_backingFieldAttributes.Concat(dynamicAndTupleNames), GetAttributeStrings(field1.GetAttributes())); 1866AssertEx.SetEqual(new[] { "System.Runtime.CompilerServices.SpecialNameAttribute" }, GetAttributeStrings(attributes1)); 1870AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(attributes1)); 1878AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(field2.GetAttributes())); 1885AssertEx.SetEqual(new[] { "System.Runtime.CompilerServices.SpecialNameAttribute" }, GetAttributeStrings(attributes3)); 1928AssertEx.SetEqual(new[] { "System.NonSerializedAttribute" }, GetAttributeStrings(attributes1)); 1932AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(attributes1)); 1940AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(field2.GetAttributes())); 1947AssertEx.SetEqual(new[] { "System.NonSerializedAttribute" }, GetAttributeStrings(attributes3)); 2164AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "System.Runtime.CompilerServices.DateTimeConstantAttribute(123456)" }), 2171AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "System.Runtime.CompilerServices.DateTimeConstantAttribute(123456)" }), 2215AssertEx.SetEqual(fieldAttributesExpected.Concat(decimalAttributeExpected), GetAttributeStrings(field1.GetAttributes())); 2219AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(field1.GetAttributes())); 2227AssertEx.SetEqual(fieldAttributesExpected.Concat(decimalAttributeExpected), GetAttributeStrings(field2.GetAttributes())); 2232AssertEx.SetEqual(decimalAttributeExpected, GetAttributeStrings(field3.GetAttributes())); 2295AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "System.ObsoleteAttribute" }), 2305AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { @"System.ObsoleteAttribute(""obsolete"", true)" }), 2427AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop1.GetMethod.GetAttributes())); 2428AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop1.SetMethod.GetAttributes())); 2431AssertEx.SetEqual(fieldAttributesExpected.Concat(new[] { "A(1)" }), GetAttributeStrings(field1.GetAttributes())); 2437AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop2.GetMethod.GetAttributes())); 2438AssertEx.SetEqual(propAttributesExpected, GetAttributeStrings(prop2.SetMethod.GetAttributes())); 2441AssertEx.SetEqual(fieldAttributesExpected, GetAttributeStrings(field2.GetAttributes())); 2597AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event1.AddMethod.GetAttributes())); 2598AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event1.RemoveMethod.GetAttributes())); 2607AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event2.AddMethod.GetAttributes())); 2608AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event2.RemoveMethod.GetAttributes())); 2616AssertEx.SetEqual(accessorsExpected.Concat(new[] { "CC" }), GetAttributeNames(event3.AddMethod.GetAttributes())); 2617AssertEx.SetEqual(accessorsExpected.Concat(new[] { "CC" }), GetAttributeNames(event3.RemoveMethod.GetAttributes())); 2625AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event4.AddMethod.GetAttributes())); 2626AssertEx.SetEqual(accessorsExpected, GetAttributeNames(event4.RemoveMethod.GetAttributes()));

1814Assert.True(expectedStr.Equals(actualStr), AssertEx.GetAssertMessage(expectedStr, actualStr)); 1840AssertEx.SetEqual(new[]

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);

1126AssertEx.Equal(expectedConstant, actual); 1211AssertEx.Equal(expectedConstant, actual); 4811AssertEx.SetEqual(expectedAttributes, typeC.GetAttributes().Select(a => a.ToString()));

432AssertEx.Equal(identity.PublicKey, s_publicKey); 461AssertEx.Equal(identity.PublicKey, s_publicKey);

2074AssertEx.NotNull(container); 2135AssertEx.NotNull(container); 2192AssertEx.NotNull(container); 2198AssertEx.NotNull(m); 6309AssertEx.NotNull(field); 6359AssertEx.NotNull(container); 6363AssertEx.SetEqual(expectedFields, fields); 6372AssertEx.NotNull(containingType);

1244AssertEx.SetEqual(expectedSymbolCallbacks, analyzer.AnalyzedSymbols.Select(s => s.Name).ToHashSet()); 1248AssertEx.All(analyzer.AnalyzedSyntaxNodes, node => node.IsKind(SyntaxKind.LocalDeclarationStatement)); 1249AssertEx.SetEqual(expectedSyntaxNodeCallbacks, analyzer.AnalyzedSyntaxNodes.Select(s => s.ToString()).ToHashSet()); 1252AssertEx.All(analyzer.AnalyzedSyntaxNodesInsideCodeBlock, node => node.IsKind(SyntaxKind.LocalDeclarationStatement)); 1253AssertEx.SetEqual(expectedSyntaxNodeInsideBlockCallbacks, analyzer.AnalyzedSyntaxNodesInsideCodeBlock.Select(s => s.ToString()).ToHashSet()); 1257AssertEx.All(analyzer.AnalyzedOperations, operation => operation.Kind == OperationKind.VariableDeclaration); 1258AssertEx.SetEqual(expectedOperationCallbacks, analyzer.AnalyzedOperations.Select(op => op.Syntax.ToString()).ToHashSet()); 1261AssertEx.All(analyzer.AnalyzedOperationsInsideOperationBlock, operation => operation.Kind == OperationKind.VariableDeclaration); 1262AssertEx.SetEqual(expectedOperationInsideBlockCallbacks, analyzer.AnalyzedOperationsInsideOperationBlock.Select(op => op.Syntax.ToString()).ToHashSet()); 1274AssertEx.SetEqual(expectedBlockSymbolCallbacks, actualBlockSymbolCallbacks.Select(s => s.Name).ToHashSet()); 1279AssertEx.SetEqual(expectedSymbolStartSymbolCallbacks, analyzer.AnalyzedSymbolStartSymbols.Select(s => s.Name).ToHashSet()); 1281AssertEx.SetEqual(expectedSymbolStartSymbolCallbacks, analyzer.AnalyzedSymbolEndSymbols.Select(s => s.Name).ToHashSet()); 1285AssertEx.SetEqual(expectedSemanticModelTreeCallbacks, analyzer.AnalyzedSemanticModels.Select(s => s.SyntaxTree).ToHashSet());

577AssertEx.Equal(expectedMembers, actualMembers); 711AssertEx.Equal(expectedLocals, actualLocals); 1893AssertEx.Equal(expectedOperators, actualOperators); 1957AssertEx.Equal(expectedOperators, actualOperators);

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

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

74AssertEx.Multiple( 285AssertEx.Multiple( 542AssertEx.Multiple( 729AssertEx.Multiple( 2455AssertEx.Multiple( 6699AssertEx.Multiple(

3970AssertEx.Equal( 4039AssertEx.Equal( 4112AssertEx.Equal( 4184AssertEx.Equal( 4228AssertEx.Equal( 4275AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4357AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4439AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4521AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4603AssertEx.AssertEqualToleratingWhitespaceDifferences(""" 4687AssertEx.AssertEqualToleratingWhitespaceDifferences("""

164AssertEx.Equal(new[] 205AssertEx.Equal(new[] 239AssertEx.Equal(new[] 359AssertEx.Equal( 390AssertEx.Equal(new[]

42AssertEx.AssertEqualToleratingWhitespaceDifferences( 51AssertEx.AssertEqualToleratingWhitespaceDifferences( 61AssertEx.AssertEqualToleratingWhitespaceDifferences( 70AssertEx.AssertEqualToleratingWhitespaceDifferences( 97AssertEx.AssertEqualToleratingWhitespaceDifferences( 127AssertEx.AssertEqualToleratingWhitespaceDifferences( 163AssertEx.AssertEqualToleratingWhitespaceDifferences( 199AssertEx.AssertEqualToleratingWhitespaceDifferences( 253AssertEx.AssertEqualToleratingWhitespaceDifferences( 360AssertEx.AssertEqualToleratingWhitespaceDifferences( 445AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL);

619AssertEx.SetEqual(result.FormatSpecifiers, new[] { "nq" });

394AssertEx.All(method.TypeParameters, typeParameter => method.IsContainingSymbolOfAllTypeParameters(typeParameter)); 395AssertEx.All(method.TypeArgumentsWithAnnotations, typeArgument => method.IsContainingSymbolOfAllTypeParameters(typeArgument.Type)); 396AssertEx.All(method.Parameters, parameter => method.IsContainingSymbolOfAllTypeParameters(parameter.Type)); 434AssertEx.All(type.TypeParameters, typeParameter => type.IsContainingSymbolOfAllTypeParameters(typeParameter)); 435AssertEx.All(type.TypeArguments(), typeArgument => type.IsContainingSymbolOfAllTypeParameters(typeArgument));

3766AssertEx.SetEqual(missingAssemblyIdentities, EvaluationContextBase.SystemCoreIdentity); 3946AssertEx.SetEqual(missingAssemblyIdentities, EvaluationContextBase.SystemCoreIdentity); 3959AssertEx.SetEqual(missingAssemblyIdentities, EvaluationContextBase.SystemCoreIdentity); 6043AssertEx.SetEqual(symReader.GetLocalNames(methodToken, methodVersion: 1), "x"); 6044AssertEx.SetEqual(symReader.GetLocalNames(methodToken, methodVersion: 2), "x", "y"); 6064AssertEx.SetEqual(locals.Select(l => l.LocalName), "x"); 6083AssertEx.SetEqual(locals.Select(l => l.LocalName), "x", "y"); 7988AssertEx.Equal("System.Int32 <>x.<>m0(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8030AssertEx.Equal("System.String <>x.<>m0(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8073AssertEx.Equal("System.String <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8118AssertEx.Equal("System.Int32 <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8161AssertEx.Equal("T <>x<T>.<>m0(C<T>.<>c__DisplayClass2_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8238AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8283AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8329AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String x)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8376AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String x)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8420AssertEx.Equal("System.Int32 <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8463AssertEx.Equal("System.Int32 <>x.<>m0(C <>4__this, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8506AssertEx.Equal("System.Int32 <>x.<>m0(C <>4__this, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8582AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8625AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String y, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8668AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String value, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8711AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String x)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8756AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String x, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8801AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String x, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8846AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String value, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8888AssertEx.Equal("System.Int32 <>x.<>m0(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8930AssertEx.Equal("T <>x<T>.<>m0(" + (isStruct ? "ref " : "") + "C<T> <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8972AssertEx.Equal("System.String <>x.<>m0(" + (isStruct ? "ref " : "") + "C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9015AssertEx.Equal("System.String <>x.<>m0(" + (isStruct ? "ref " : "") + "C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9060AssertEx.Equal("System.String <>x.<>m0(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9105AssertEx.Equal("System.String <>x.<>m0(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9246AssertEx.Equal("T <>x<T>.<>m0(" + (isStruct ? "out " : "") + "C<T> <>4__this, T y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9281AssertEx.Equal("System.Object <>x.<>m0(C <>4__this, System.Int32 y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9299AssertEx.Equal("System.Int32 <>x.<>c__DisplayClass0_0.<<>m0>b__0()", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9342AssertEx.Equal("System.Object <>x.<>m0(S y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9360AssertEx.Equal("S <>x.<>c__DisplayClass0_0.<<>m0>b__0()", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9401AssertEx.Equal("System.Object <>x.<>m0(out C <>4__this, System.Int32 y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9420AssertEx.Equal("System.Int32 <>x.<>c__DisplayClass0_0.<<>m0>b__0()", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9460AssertEx.Equal("System.Int32 <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9500AssertEx.Equal("System.Int32 <>x.<>m0(C.<>c__DisplayClass0_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9631AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9672AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9715AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String z)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9758AssertEx.Equal("System.String <>x.<>m0(C <>4__this, System.String z)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9823AssertEx.Equal("System.Int32 <>x.<>m0(C <>4__this, System.Int32 y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9857AssertEx.Equal("C <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9896AssertEx.Equal("C <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9936AssertEx.Equal("C <>x.<>m0(C.<>c__DisplayClass0_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9977AssertEx.Equal("C <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10017AssertEx.Equal("C <>x.<>m0(C.<>c__DisplayClass0_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10056AssertEx.Equal("System.Int32 <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10095AssertEx.Equal("System.Int32 <>x.<>m0(C.<>c__DisplayClass0_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10137AssertEx.Equal("System.Int32 <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10178AssertEx.Equal("System.Int32 <>x.<>m0(C.<>c__DisplayClass0_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10243AssertEx.Equal("C <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10287AssertEx.Equal("System.Int32 <>x.<>m0(" + (isStruct ? "out " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10326AssertEx.Equal("System.Byte <>x.<>m0(" + (isStruct ? "out " : "") + "C <>4__this, System.Byte y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10370AssertEx.Equal("System.Int32 <>x.<>m0(" + (isStruct ? "out " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10410AssertEx.Equal("System.Byte <>x.<>m0(" + (isStruct ? "out " : "") + "C <>4__this, System.Byte y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10496AssertEx.Equal("System.Int32 <>x.<>m0(" + (isStruct ? "out " : "") + "C <>4__this, System.Int32 y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10555AssertEx.Equal("System.Int32 <>x.<>m0(C <>4__this, System.Int32 y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10647AssertEx.Equal("System.Int32 <>x.<>m0(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 10686AssertEx.Equal("System.Int32 <>x.<>m0()", ((MethodSymbol)methodData.Method).ToTestDisplayString());

299AssertEx.SetEqual(GetLocalNames(context), "ch"); 353AssertEx.SetEqual(GetLocalNames(context), "ch", "x"); 407AssertEx.SetEqual(GetLocalNames(context), "ch", "u"); 447AssertEx.SetEqual(GetLocalNames(context), "ch"); 501AssertEx.SetEqual(GetLocalNames(context), "this", "ch"); 570AssertEx.SetEqual(GetLocalNames(context), "this", "ch", "x"); 610AssertEx.SetEqual(GetLocalNames(context), "ch"); 664AssertEx.SetEqual(GetLocalNames(context), "ch", "x"); 718AssertEx.SetEqual(GetLocalNames(context), "ch", "u"); 758AssertEx.SetEqual(GetLocalNames(context), "ch"); 804AssertEx.SetEqual(GetLocalNames(context), "ch", "<>TypeVariables"); 864AssertEx.SetEqual(GetLocalNames(context), "ch", "x", "<>TypeVariables"); 924AssertEx.SetEqual(GetLocalNames(context), "ch", "u", "<>TypeVariables"); 970AssertEx.SetEqual(GetLocalNames(context), "ch", "<>TypeVariables"); 1030AssertEx.SetEqual(GetLocalNames(context), "this", "ch", "<>TypeVariables"); 1105AssertEx.SetEqual(GetLocalNames(context), "this", "ch", "x", "<>TypeVariables"); 1151AssertEx.SetEqual(GetLocalNames(context), "ch", "<>TypeVariables"); 1211AssertEx.SetEqual(GetLocalNames(context), "ch", "x", "<>TypeVariables"); 1271AssertEx.SetEqual(GetLocalNames(context), "ch", "u", "<>TypeVariables"); 1317AssertEx.SetEqual(GetLocalNames(context), "ch", "<>TypeVariables");

1029AssertEx.None(locals, l => l.LocalName.Contains("this"));

746AssertEx.AssertEqualToleratingWhitespaceDifferences(actualIL, 6479AssertEx.Equal("System.Int32 <>x.<>m1(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 6530AssertEx.Equal("System.String <>x.<>m1(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 6584AssertEx.Equal("System.String <>x.<>m2(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 6635AssertEx.Equal("System.Int32 <>x.<>m1(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 6688AssertEx.Equal("T <>x<T>.<>m2(C<T>.<>c__DisplayClass2_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 6779AssertEx.Equal("System.String <>x.<>m1(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 6836AssertEx.Equal("System.String <>x.<>m1(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 6889AssertEx.Equal("System.String <>x.<>m2(C <>4__this, System.String x)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 6947AssertEx.Equal("System.String <>x.<>m3(C <>4__this, System.String x)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 6998AssertEx.Equal("System.Int32 <>x.<>m1(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7050AssertEx.Equal("System.Int32 <>x.<>m2(C <>4__this, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7102AssertEx.Equal("System.Int32 <>x.<>m2(C <>4__this, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7193AssertEx.Equal("System.String <>x.<>m1(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7245AssertEx.Equal("System.String <>x.<>m1(C <>4__this, System.String y, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7297AssertEx.Equal("System.String <>x.<>m1(C <>4__this, System.String value, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7350AssertEx.Equal("System.String <>x.<>m2(C <>4__this, System.String x)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7404AssertEx.Equal("System.String <>x.<>m3(C <>4__this, System.String x, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7458AssertEx.Equal("System.String <>x.<>m3(C <>4__this, System.String x, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7512AssertEx.Equal("System.String <>x.<>m3(C <>4__this, System.String value, ref C.<>c__DisplayClass2_0 value)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7563AssertEx.Equal("System.Int32 <>x.<>m1(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7614AssertEx.Equal("T <>x<T>.<>m1(" + (isStruct ? "ref " : "") + "C<T> <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7664AssertEx.Equal("System.String <>x.<>m1(" + (isStruct ? "ref " : "") + "C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7719AssertEx.Equal("System.String <>x.<>m1(" + (isStruct ? "ref " : "") + "C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7771AssertEx.Equal("System.String <>x.<>m1(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7827AssertEx.Equal("System.String <>x.<>m2(" + (isStruct ? "ref " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 7994AssertEx.Equal("T <>x<T>.<>m1(" + (isStruct ? "out " : "") + "C<T> <>4__this, T y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8043AssertEx.Equal("System.Int32 <>x.<>m1(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8093AssertEx.Equal("System.Int32 <>x.<>m2(C.<>c__DisplayClass0_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8249AssertEx.Equal("System.String <>x.<>m1(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8302AssertEx.Equal("System.String <>x.<>m1(C <>4__this, System.String y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8352AssertEx.Equal("System.String <>x.<>m3(C <>4__this, System.String z)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8406AssertEx.Equal("System.String <>x.<>m4(C <>4__this, System.String z)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8483AssertEx.Equal("System.Int32 <>x.<>m1(C <>4__this, System.Int32 y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8530AssertEx.Equal("C <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8578AssertEx.Equal("C <>x.<>m0(C.<>c__DisplayClass0_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8627AssertEx.Equal("C <>x.<>m0(C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8677AssertEx.Equal("C <>x.<>m0(C.<>c__DisplayClass0_0 <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8760AssertEx.Equal("System.Int32 <>x.<>m1(" + (isStruct ? "out " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8807AssertEx.Equal("System.Byte <>x.<>m1(" + (isStruct ? "out " : "") + "C <>4__this, System.Byte y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8858AssertEx.Equal("System.Int32 <>x.<>m1(" + (isStruct ? "out " : "") + "C <>4__this)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 8906AssertEx.Equal("System.Byte <>x.<>m1(" + (isStruct ? "out " : "") + "C <>4__this, System.Byte y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9013AssertEx.Equal("System.Int32 <>x.<>m1(" + (isStruct ? "out " : "") + "C <>4__this, System.Int32 y)", ((MethodSymbol)methodData.Method).ToTestDisplayString()); 9087AssertEx.Equal("System.Int32 <>x.<>m1(C <>4__this, System.Int32 y)", ((MethodSymbol)methodData.Method).ToTestDisplayString());

185AssertEx.SetEqual(missingAssemblyIdentities, EvaluationContextBase.SystemCoreIdentity);

94AssertEx.SetEqual(missingAssemblyIdentities, EvaluationContextBase.SystemCoreIdentity); 532AssertEx.SetEqual(expectedNames, actualNames);

70AssertEx.Equal(new[] { identityA1 }, missingAssemblyIdentities); 706AssertEx.Equal(missingAssemblyIdentities, ImmutableArray.Create(identityAS2)); 771AssertEx.Equal(missingAssemblyIdentities, ImmutableArray.Create(identityAS2)); 808AssertEx.Equal(expectedIdentities, actualIdentities); 1307AssertEx.Equal(new[] { "mscorlib", "System.Private.Library" }, actualReferences); 1427AssertEx.Equal(new[] { "mscorlib", "System.Private.Library" }, actualReferences);

139AssertEx.SetEqual(new[] { "corlib 2.0", appRef + " 0.0" }, reader.DumpAssemblyReferences()); 141AssertEx.SetEqual(new[] {

904AssertEx.SetEqual(usingAliases.Keys, keyword1, keyword2); 1038AssertEx.SetEqual(usingAliases.Keys, "SXL", "LO"); 1082AssertEx.SetEqual(usingAliases.Keys, "A", "B"); 1123AssertEx.SetEqual(usingAliases.Keys, "A", "B");

269AssertEx.All(dynamicFlags.Select((f, i) => f == DynamicFlagsCustomTypeInfo.GetFlag(customTypeInfo, i)), x => x);

16using AssertEx = PortableTestUtils::Roslyn.Test.Utilities.AssertEx; 37AssertEx.AssertEqualToleratingWhitespaceDifferences(dir.Path + ";C", result.Output); 72AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, result.Output); 74AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 112AssertEx.AssertEqualToleratingWhitespaceDifferences("DataSet", result.Output); 137AssertEx.AssertEqualToleratingWhitespaceDifferences("OK", result.Output); 154AssertEx.AssertEqualToleratingWhitespaceDifferences("OK", result.Output); 155AssertEx.AssertEqualToleratingWhitespaceDifferences($@"

24using AssertEx = PortableTestUtils::Roslyn.Test.Utilities.AssertEx; 176AssertEx.Equal(new[] { 2, 3, 4 }, state.ReturnValue); 505AssertEx.Equal(new[] 541AssertEx.Equal(new[] 548AssertEx.Equal(new[]

124AssertEx.AssertEqualToleratingWhitespaceDifferences( 139AssertEx.AssertEqualToleratingWhitespaceDifferences( 162AssertEx.AssertEqualToleratingWhitespaceDifferences( 197AssertEx.AssertEqualToleratingWhitespaceDifferences( 222AssertEx.AssertEqualToleratingWhitespaceDifferences( 237AssertEx.AssertEqualToleratingWhitespaceDifferences( 328AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Out.ToString()); 329AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Error.ToString()); 352AssertEx.AssertEqualToleratingWhitespaceDifferences( 375AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 392AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 419AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 441AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 460AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 475AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Out.ToString()); 476AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Error.ToString()); 486AssertEx.AssertEqualToleratingWhitespaceDifferences( 499AssertEx.AssertEqualToleratingWhitespaceDifferences(s_compilerVersion, runner.Console.Out.ToString()); 503AssertEx.AssertEqualToleratingWhitespaceDifferences(s_compilerVersion, runner.Console.Out.ToString()); 507AssertEx.AssertEqualToleratingWhitespaceDifferences(s_compilerVersion, runner.Console.Out.ToString()); 511AssertEx.AssertEqualToleratingWhitespaceDifferences(s_compilerVersion, runner.Console.Out.ToString()); 529AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Out.ToString()); 530AssertEx.AssertEqualToleratingWhitespaceDifferences(error, runner.Console.Error.ToString()); 539AssertEx.AssertEqualToleratingWhitespaceDifferences( 547AssertEx.AssertEqualToleratingWhitespaceDifferences( 566AssertEx.AssertEqualToleratingWhitespaceDifferences("3", runner.Console.Out.ToString()); 618AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 655AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 679AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 694AssertEx.AssertEqualToleratingWhitespaceDifferences( 715AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 730AssertEx.AssertEqualToleratingWhitespaceDifferences( 754AssertEx.Equal(new[] 765AssertEx.Equal(new[] 785AssertEx.AssertEqualToleratingWhitespaceDifferences(@" 805AssertEx.AssertEqualToleratingWhitespaceDifferences($@" 814AssertEx.AssertEqualToleratingWhitespaceDifferences( 914AssertEx.AssertEqualToleratingWhitespaceDifferences( 937AssertEx.AssertEqualToleratingWhitespaceDifferences( 950AssertEx.AssertEqualToleratingWhitespaceDifferences( 966AssertEx.AssertEqualToleratingWhitespaceDifferences( 985AssertEx.AssertEqualToleratingWhitespaceDifferences(

899AssertEx.Equal(new[] { "hello", "hello" }, result); 1023AssertEx.Equal(new object[] { 1, 1, null }, result); 1037AssertEx.Equal(new[] { 1, 2, 3, 4 }, result1); 1040AssertEx.Equal(new[] { 1, 2, 3, 4, 5 }, result2); 1043AssertEx.Equal(new[] { 1, 2, 3, 4, 5, 6 }, s1.ReturnValue); 1046AssertEx.Equal(new[] { 1, 2, 3, 4, 5, 6, 7 }, s2.ReturnValue); 1049AssertEx.Equal(new[] { 1, 2, 3, 4, 5, 6, 7, 8 }, s3.ReturnValue); 1674AssertEx.SetEqual(new[] { "<implicit>", "<host>" }, aliases); 1681AssertEx.SetEqual(new[] { "<host>", "global" }, aliases); 1686AssertEx.SetEqual(new[] { "<host>" }, aliases); 1722AssertEx.SetEqual(Array.Empty<string>(), aliases); 1728AssertEx.SetEqual(new[] { "<implicit>", "global" }, aliases); 1736AssertEx.SetEqual(new[] { "<implicit>", "<host>", "global" }, aliases); 1743AssertEx.SetEqual(new[] { "<host>", "global" }, aliases); 1750AssertEx.SetEqual(new[] { "<host>", "global" }, aliases); 1788AssertEx.SetEqual(Array.Empty<string>(), aliases); 1794AssertEx.SetEqual(new[] { "<implicit>", "global" }, aliases); 1802AssertEx.SetEqual(new[] { "<implicit>", "<host>", "global" }, aliases); 1809AssertEx.SetEqual(new[] { "<host>", "global" }, aliases); 1816AssertEx.SetEqual(new[] { "<host>", "global" }, aliases);

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

7678AssertEx.Equal(expectedInfo, variables.Select(v => getVariableInfo(model, v))); 9298AssertEx.Equal(expectedTypes, actualTypes); 9343AssertEx.Equal(expectedTypes, actualTypes); 9392AssertEx.Equal(expectedTypes, actualTypes);

885AssertEx.Equal(expectedOriginalType, typeInfo.Type!.ToTestDisplayString()); 886AssertEx.Equal(expectedConvertedType, typeInfo.ConvertedType!.ToTestDisplayString()); 1642AssertEx.Equal("void C.M1<System.String>(delegate*<System.String, System.Void> param1, delegate*<System.String, System.Void> param2)", 1675AssertEx.Equal("void C.M1<System.Object>(delegate*<delegate*<System.Object, System.Void>, System.Void> param1, delegate*<delegate*<System.Object, System.Void>, System.Void> param2)", 1708AssertEx.Equal("void C.M1<System.String>(delegate*<delegate*<System.String>, System.Void> param1, delegate*<delegate*<System.String>, System.Void> param2)", 1802AssertEx.Equal("void C.M1<System.Object>(delegate*<System.Object> param1, delegate*<System.Object> param2)", 1835AssertEx.Equal("void C.M1<System.String>(delegate*<delegate*<System.String, System.Void>> param1, delegate*<delegate*<System.String, System.Void>> param2)", 1868AssertEx.Equal("void C.M1<System.Object>(delegate*<delegate*<System.Object>> param1, delegate*<delegate*<System.Object>> param2)", 1987AssertEx.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)", 2036AssertEx.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)", 2067AssertEx.Equal("ptr = M(C.Field)", localSyntax.ToString()); 2070AssertEx.Equal("delegate* unmanaged<System.Int32>", local.Type.ToTestDisplayString()); 2073AssertEx.Equal("delegate* unmanaged<System.Int32>", typeInfo.Type.ToTestDisplayString()); 2105AssertEx.Equal("delegate* unmanaged[Stdcall, Cdecl]<System.Int32 modopt(System.Runtime.CompilerServices.CallConvStdcall) modopt(System.Runtime.CompilerServices.CallConvCdecl)>", funcPtrType.ToTestDisplayString()); 2106AssertEx.SetEqual(new[] 2224AssertEx.Equal(expectedTypes, invocationTypes); 2279AssertEx.Equal(expectedTypes, invocationTypes); 2354AssertEx.Equal(expectedTypes, invocationTypes); 2422AssertEx.Equal(expectedTypes, invocationTypes); 2490AssertEx.Equal(expectedTypes, invocationTypes); 2589AssertEx.Equal(expectedTypes, invocationTypes); 2662AssertEx.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));

401AssertEx.SetEqual(members.ToTestDisplayStrings(), 1454AssertEx.Empty(propertyAttributes); 1463AssertEx.Empty(getterAttributes); 1467AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, getterAttributes); 1480AssertEx.Empty(setterAttributes); 1484AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, setterAttributes); 1492AssertEx.Empty(backingFieldAttributes); 1496AssertEx.Equal( 2424AssertEx.SetEqual(members.ToTestDisplayStrings(), new[] { 2535AssertEx.SetEqual(new[] {

4591AssertEx.Equal("System.String System.String.op_Addition(System.String left, System.String right)", semanticInfo.Symbol.ToTestDisplayString()); 6795AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6821AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6853AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6888AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6928AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6963AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7003AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7041AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7081AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7116AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7156AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7191AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7224AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7264AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7304AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7344AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7384AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7419AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7461AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7496AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7538AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7579AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7619AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7687AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7781AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7893AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7959AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7989AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8162AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8222AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8342AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8572AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8697AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8848AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8959AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9026AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9082AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9198AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9314AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9439AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9701AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 9777AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 11835AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute",

3617AssertEx.Equal(expectedAttributes, pairs.Select(p => getAttributesInternal(p.Item1, p.Item2))); 3618AssertEx.Equal(expectedAttributes, pairs.Select(p => getAttributesPublic(p.Item1, p.Item2))); 3889AssertEx.Equal(expectedAttributes, actualAttributes); 6979AssertEx.Equal("System.Action", model.GetTypeInfo(action).Type.ToTestDisplayString());

6967AssertEx.Equal(expectedSymbols, actualSymbols); 7025AssertEx.Equal(expectedSymbols, actualSymbols);

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

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); 6045AssertEx.Equal(expectedOperators, actualOperators); 6104AssertEx.Equal(expectedOperators, actualOperators);

426AssertEx.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);

13500AssertEx.Equal("S?[]", model.GetTypeInfo(returnStatement.Expression).Type.ToTestDisplayString()); 28237AssertEx.Empty(copenAttributes); 28241AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)" }, copenAttributes); 28248AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.MaybeNullAttribute" }, propertyAttributes); 28252AssertEx.Empty(propertyAttributes); 28259AssertEx.Empty(getterAttributes); 28263AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, getterAttributes); 28270AssertEx.Empty(getterReturnAttributes); 28274AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.MaybeNullAttribute" }, getterReturnAttributes); 28281AssertEx.Empty(setterAttributes); 28285AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, setterAttributes.Select(a => a.ToString())); 28290AssertEx.Empty(setterReturnAttributes); 28340AssertEx.Empty(copenAttributes); 28344AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)" }, copenAttributes); 28351AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.MaybeNullAttribute", "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, propertyAttributes); 28355AssertEx.Empty(propertyAttributes); 28362AssertEx.Empty(getterAttributes); 28366AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, getterAttributes); 28373AssertEx.Empty(getterReturnAttributes); 28377AssertEx.Equal(new[] { 28864AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.MaybeNullAttribute" }, fieldAttributes); 28868AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableAttribute(1)", "System.Diagnostics.CodeAnalysis.MaybeNullAttribute" }, fieldAttributes); 38723AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.AllowNullAttribute" }, fieldAttributes); 38727AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableAttribute(1)", "System.Diagnostics.CodeAnalysis.AllowNullAttribute" }, fieldAttributes); 38897AssertEx.Empty(copenAttributes); 38901AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)", "System.Reflection.DefaultMemberAttribute(\"Item\")" }, copenAttributes); 38908AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.AllowNullAttribute" }, propertyAttributes); 38912AssertEx.Empty(propertyAttributes); 38917AssertEx.Empty(setterAttributes); 38923AssertEx.Empty(setterValueAttributes); 38927AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.AllowNullAttribute" }, setterValueAttributes); 38932AssertEx.Empty(setterReturnAttributes); 38958AssertEx.Empty(copenAttributes); 38962AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)", "System.Reflection.DefaultMemberAttribute(\"Item\")" }, copenAttributes); 38969AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.AllowNullAttribute", "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, propertyAttributes); 38973AssertEx.Empty(propertyAttributes); 38978AssertEx.Empty(setterAttributes); 38984AssertEx.Empty(setterValueAttributes); 38988AssertEx.Equal(new[] { 42578AssertEx.Empty(copenAttributes); 42582AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)" }, copenAttributes); 42589AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, propertyAttributes); 42593AssertEx.Empty(propertyAttributes); 42600AssertEx.Empty(setterAttributes); 42604AssertEx.Equal(new[] { "System.Runtime.CompilerServices.CompilerGeneratedAttribute" }, setterAttributes); 42611AssertEx.Empty(setterValueAttributes); 42615AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, setterValueAttributes); 42827AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, fieldAttributes); 42831AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableAttribute(1)", "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" }, fieldAttributes); 45860AssertEx.Empty(copenAttributes); 45864AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableContextAttribute(1)", "System.Runtime.CompilerServices.NullableAttribute(0)", "System.Reflection.DefaultMemberAttribute(\"Item\")" }, copenAttributes); 45871AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, propertyAttributes); 45875AssertEx.Empty(propertyAttributes); 45884AssertEx.Empty(getterReturnAttributes); 45888AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, getterReturnAttributes); 45972AssertEx.Equal(new[] { "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, fieldAttributes); 45976AssertEx.Equal(new[] { "System.Runtime.CompilerServices.NullableAttribute(1)", "System.Diagnostics.CodeAnalysis.NotNullAttribute" }, fieldAttributes); 107986AssertEx.Equal(expectedTypes, constraintTypes.SelectAsArray(t => t.ToTestDisplayString(true))); 108051AssertEx.Equal(expectedConstraintTypes, constraintTypes.SelectAsArray(t => t.ToTestDisplayString(true))); 108104AssertEx.Equal(expectedConstraintTypes, constraintTypes.SelectAsArray(t => t.ToTestDisplayString(true))); 112870AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, actual); 123190AssertEx.Equal<NullableAnnotation>(expected, getResult, (na1, na2) => na1 == na2, na => $"NullableAnnotation.{na}", "{0,-32:G}", size); 123195AssertEx.Equal<NullableFlowState>(expected, getResult, (na1, na2) => na1 == na2, na => $"NullableFlowState.{na}", "{0,-32:G}", size); 153514AssertEx.Equal(new string[] { "I<dynamic>", "I2<object>" }, 153516AssertEx.Equal(new string[] { "I<dynamic>", "I2<object>", "I<object>" }, 153548AssertEx.Equal(new string[] { "I<(int a, int b)>", "I2<(int notA, int notB)>" }, 153550AssertEx.Equal(new string[] { "I<(int a, int b)>", "I2<(int notA, int notB)>", "I<(int notA, int notB)>" }, 153586AssertEx.Equal(new string[] { "I<(object a, object b)>", "I2<(object notA, object notB)>" }, 153588AssertEx.Equal(new string[] { "I<(object a, object b)>", "I2<(object notA, object notB)>", "I<(object notA, object notB)>" }, 153614AssertEx.Equal(new string[] { "I<object>", "I2<object>" }, 153616AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 153646AssertEx.Equal(new string[] { "I<object>", "I2<object>" }, 153648AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 153815AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 153817AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 153856AssertEx.Equal(new string[] { "I<object>", "I2<object>" }, 153858AssertEx.Equal(new string[] { "I<object>", "I2<object>", "I<object!>" }, 153896AssertEx.Equal(new string[] { "I<object>", "I2<object>" }, 153898AssertEx.Equal(new string[] { "I<object>", "I2<object>", "I<object!>" }, 154110AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 154112AssertEx.Equal(new string[] { "I2<object>", "I<object!>", "I<object>" }, 154152AssertEx.Equal(new string[] { "I2<object>", "I<object>" }, 154154AssertEx.Equal(new string[] { "I2<object>", "I<object!>", "I<object>" }, 154233AssertEx.Equal(new string[] { "I<object?>", "I2<object>" }, 154235AssertEx.Equal(new string[] { "I<object?>", "I2<object>", "I<object!>" }, 154265AssertEx.Equal(new string[] { "I<object?>", "I2<object>" }, 154267AssertEx.Equal(new string[] { "I<object?>", "I2<object>", "I<object>" }, 154299AssertEx.Equal(new string[] { "I<object?>", "I2<object!>" }, 154301AssertEx.Equal(new string[] { "I<object?>", "I2<object!>", "I<object!>" },

3216AssertEx.Equal(expected, results);

51AssertEx.EqualOrDiff(expected, results);

2931AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 6219AssertEx.Equal("System.Int32 X", model.GetSymbolInfo(xReference).Symbol.ToTestDisplayString()); 6290AssertEx.SetEqual(new string[] { "A..ctor()" }, 6292AssertEx.SetEqual(new string[] { "B..ctor()" }, 6294AssertEx.SetEqual(new string[] { "C..ctor(System.Int32 x)" }, 6296AssertEx.SetEqual(new string[] { "D..ctor(System.Int32 x)" }, 6318AssertEx.SetEqual(new string[] { "A..ctor()" }, 6320AssertEx.SetEqual(new string[] { "B..ctor()" }, 6322AssertEx.SetEqual(new string[] { "C..ctor(System.Int32 x)", "C..ctor()" }, 6324AssertEx.SetEqual(new string[] { "D..ctor(System.Int32 x)", "D..ctor()" }, 6346AssertEx.SetEqual(new string[] { ".ctor" }, 6348AssertEx.SetEqual(new string[] { ".ctor" }, 6350AssertEx.SetEqual(new string[] { ".ctor" }, 6352AssertEx.SetEqual(new string[] { ".ctor" }, 6374AssertEx.SetEqual(new string[] { ".ctor" }, 6376AssertEx.SetEqual(new string[] { ".ctor" }, 6378AssertEx.SetEqual(new string[] { ".ctor" }, 6380AssertEx.SetEqual(new string[] { ".ctor" },

2918AssertEx.Equal("System.String System.String.op_Addition(System.String left, System.String right)", semanticInfo.Symbol.ToTestDisplayString()); 5077AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5105AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5142AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5182AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5229AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5269AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5316AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5359AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5406AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5446AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5493AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5533AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5580AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5627AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5674AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5714AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5763AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5803AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5852AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5898AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5945AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 5975AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6101AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6170AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6200AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6437AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6499AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6621AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6853AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 6980AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7133AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7246AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7317AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7377AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7495AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7613AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 7741AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8014AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8093AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute", 8520AssertEx.Equal("System.Runtime.CompilerServices.InterpolatedStringHandlerArgumentAttribute",

828AssertEx.Equal(new[] { 1351AssertEx.Equal(expectedMemberNames, comp.GetMember<NamedTypeSymbol>("C").GetPublicSymbol().MemberNames); 1993AssertEx.Equal(expectedMembers, 2016AssertEx.Equal(expectedMemberNames, comp.GetMember<NamedTypeSymbol>("C").GetPublicSymbol().MemberNames); 2066AssertEx.Equal(expectedMembers, actualMembers); 2749AssertEx.Equal(expectedMembers, actualMembers); 2773AssertEx.Equal(expectedMembers, actualMembers); 3217AssertEx.Equal( 3262AssertEx.Equal( 3310AssertEx.Equal( 3361AssertEx.Equal( 3740AssertEx.Equal(new[] { 4122AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 4123AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 4144AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 4145AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 5071AssertEx.SetEqual(new[] { "System.Boolean RecordB.op_Equality(RecordB left, RecordB right)" }, 10503AssertEx.SetEqual(new[] { "B" }, getAttributeStrings(prop1)); 10506AssertEx.SetEqual(new[] { "A" }, getAttributeStrings(field1)); 10509AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 10653AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, SyntaxFactory.TypeDeclaration(SyntaxKind.RecordStructDeclaration, "Point").NormalizeWhitespace().ToString());

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); 1589AssertEx.Equal(expectedMembers, actualMembers); 1640AssertEx.Equal(expectedMembers, actualMembers); 5988AssertEx.Equal(expectedMembers, actualMembers); 6031AssertEx.Equal(expectedMembers, actualMembers); 6072AssertEx.Equal(expectedMembers, actualMembers); 6113AssertEx.Equal(expectedMembers, actualMembers); 9755AssertEx.Equal(expectedMembers, actualMembers); 9782AssertEx.Equal(new[] { "System.Type A.B.EqualityContract { get; }" }, actualMembers); 9805AssertEx.Equal(new[] { "System.Type C1.EqualityContract { get; }" }, GetProperties(comp, "C1").ToTestDisplayStrings()); 9818AssertEx.Equal(new[] { "System.Type C2.EqualityContract { get; }", "System.Object C2.P { get; init; }" }, GetProperties(comp, "C2").ToTestDisplayStrings()); 9870AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 9901AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 9948AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 9982AssertEx.Equal(new[] { "System.Type B1.EqualityContract { get; }", "System.Int32 B1.X { get; init; }" }, GetProperties(comp, "B1").ToTestDisplayStrings()); 9983AssertEx.Equal(new[] { "System.Type B2.EqualityContract { get; }", "System.Int32 B2.X { get; init; }" }, GetProperties(comp, "B2").ToTestDisplayStrings()); 10021AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }", "System.Int32 C.X { get; init; }", "System.Int32 C.Y { get; init; }" }, actualMembers); 10066AssertEx.Equal(expectedMembers, actualMembers); 10088AssertEx.Equal(expectedMemberNames, c.GetPublicSymbol().MemberNames); 10095AssertEx.Equal(expectedCtors, c.GetPublicSymbol().Constructors.ToTestDisplayStrings()); 10189AssertEx.Equal(expectedMembers, actualMembers); 10226AssertEx.Equal(expectedMembers, actualMembers); 10269AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }" }, actualMembers); 10302AssertEx.Equal(expectedMembers, actualMembers); 10348AssertEx.Equal(expectedMembers, actualMembers); 10395AssertEx.Equal(expectedMembers, actualMembers); 10444AssertEx.Equal(expectedMembers, actualMembers); 10496AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 10556AssertEx.Equal(expectedMembers, actualMembers); 10593AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }" }, actualMembers); 10669AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }" }, actualMembers); 10701AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }" }, actualMembers); 10759AssertEx.Equal(expectedMembers, comp.GetMember<NamedTypeSymbol>("B").GetMembers().ToTestDisplayStrings()); 10783AssertEx.Equal(expectedMembers, comp.GetMember<NamedTypeSymbol>("C").GetMembers().ToTestDisplayStrings()); 10827AssertEx.Equal(expectedMembers, actualMembers); 10852AssertEx.Equal(expectedMembers, actualMembers); 10875AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 10881AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }", "System.Object B.P { get; init; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 10905AssertEx.Equal(expectedMembers, actualMembers); 10929AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }", "System.Object B.P { get; init; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 10930AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }", "System.Object C.P { get; init; }", "System.Object C.I.P { get; }" }, GetProperties(comp, "C").ToTestDisplayStrings()); 10992AssertEx.Equal(expectedMembers, actualMembers); 11060AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 11155AssertEx.Equal(expectedMembers, actualMembers); 11207AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 11268AssertEx.Equal(expectedMembers, actualMembers); 11304AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 11345AssertEx.Equal(expectedMembers, actualMembers); 11559AssertEx.Equal(expectedMembers, actualMembers); 11795AssertEx.Equal(expectedMembers, actualMembers); 12108AssertEx.Equal(new[] { "System.Type C.EqualityContract { get; }", }, GetProperties(comp, "C").ToTestDisplayStrings()); 12216AssertEx.Equal(new[] { "System.Type CA.EqualityContract { get; }", "System.Object CA.P { get; init; }" }, GetProperties(comp, "CA").ToTestDisplayStrings()); 12217AssertEx.Equal(new[] { "System.Type CB.EqualityContract { get; }" }, GetProperties(comp, "CB").ToTestDisplayStrings()); 12498AssertEx.Equal(expectedModifiers, returnType.CustomModifiers); 12505AssertEx.Equal(expectedModifiers, parameterType.CustomModifiers); 12588AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, GetProperties(comp, "B").ToTestDisplayStrings()); 12748AssertEx.Equal(expectedMembers, actualMembers); 13478AssertEx.Equal(expectedMembers, actualMembers); 15782AssertEx.Equal(expectedMembers, actualMembers); 15841AssertEx.Equal(expectedMembers, actualMembers); 20718AssertEx.Equal(expectedMembers, actualMembers); 20760AssertEx.Equal(expectedMembers, actualMembers); 20790AssertEx.Equal(new[] { "System.Type B.EqualityContract { get; }" }, actualMembers); 23651AssertEx.Equal(expectedMembers, actualMembers); 23799AssertEx.Equal(expectedMembers, actualMembers); 24032AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24033AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24036AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B?>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24037AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B?>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24087AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24088AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24091AssertEx.Equal(new[] { "System.IEquatable<B>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24092AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24152AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24153AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24156AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24157AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24197AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24198AssertEx.Equal(new[] { "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24201AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24202AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "System.IEquatable<B>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24222AssertEx.Equal(new[] { "System.IEquatable<B1>", "System.IEquatable<B2>", "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24223AssertEx.Equal(new[] { "System.IEquatable<B1>", "System.IEquatable<B2>", "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24226AssertEx.Equal(new[] { "System.IEquatable<B1>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24227AssertEx.Equal(new[] { "System.IEquatable<B2>", "System.IEquatable<A<System.Object>>", "System.IEquatable<B1>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24230AssertEx.Equal(new[] { "System.IEquatable<B2>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24231AssertEx.Equal(new[] { "System.IEquatable<B1>", "System.IEquatable<A<System.Int32>>", "System.IEquatable<B2>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24251AssertEx.Equal(new[] { "I<A<T>>", "System.IEquatable<A<T>>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24252AssertEx.Equal(new[] { "I<A<T>>", "System.IEquatable<A<T>>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24255AssertEx.Equal(new[] { "I<A<System.Object>>", "I<B>", "System.IEquatable<B>" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24256AssertEx.Equal(new[] { "System.IEquatable<A<System.Object>>", "I<A<System.Object>>", "I<B>", "System.IEquatable<B>" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24316AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24317AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24320AssertEx.Equal(new[] { "System.IEquatable<B>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24321AssertEx.Equal(new[] { "System.IEquatable<A<System.Int32>>[missing]", "System.IEquatable<B>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24386AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24387AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24390AssertEx.Equal(new[] { "System.IEquatable<B>", "System.IEquatable<B>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24391AssertEx.Equal(new[] { "System.IEquatable<A<System.Int32>>[missing]", "System.IEquatable<B>", "System.IEquatable<B>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24460AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24461AssertEx.Equal(new[] { "System.IEquatable<A<T>>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24464AssertEx.Equal(new[] { "IEquatable<B>", "System.IEquatable<B>[missing]" }, type.InterfacesNoUseSiteDiagnostics().ToTestDisplayStrings()); 24465AssertEx.Equal(new[] { "System.IEquatable<A<System.Int32>>[missing]", "IEquatable<B>", "System.IEquatable<B>[missing]" }, type.AllInterfacesNoUseSiteDiagnostics.ToTestDisplayStrings()); 24890AssertEx.Equal(expectedMembers, actualMembers); 24935AssertEx.Equal(expectedMembers, actualMembers); 25098AssertEx.SetEqual(new[] { "B" }, getAttributeStrings(prop1)); 25101AssertEx.SetEqual(new[] { "A" }, getAttributeStrings(field1)); 25104AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25158AssertEx.SetEqual(new[] { "B" }, getAttributeStrings(prop1)); 25161AssertEx.SetEqual(new[] { "A" }, getAttributeStrings(field1)); 25164AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25235AssertEx.SetEqual(new[] { "B" }, getAttributeStrings(prop1)); 25238AssertEx.SetEqual(new[] { "A" }, getAttributeStrings(field1)); 25241AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25292AssertEx.SetEqual(new string[] { }, getAttributeStrings(prop1)); 25295AssertEx.SetEqual(new string[] { }, getAttributeStrings(field1)); 25298AssertEx.SetEqual(new string[] { }, getAttributeStrings(param1)); 25373AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25457AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 25527AssertEx.SetEqual(new[] { "C", "D" }, getAttributeStrings(param1)); 28170AssertEx.Equal( 28284AssertEx.Equal( 28576AssertEx.Equal( 28623AssertEx.Equal( 28671AssertEx.Equal( 28719AssertEx.Equal( 28771AssertEx.Equal( 28822AssertEx.Equal( 28880AssertEx.Equal( 28987AssertEx.Equal( 29038AssertEx.Equal( 30165AssertEx.Equal(expectedMembers, actualMembers); 30195AssertEx.Equal(expectedMembers, actualMembers); 30352AssertEx.Equal("System.Int32 X", model.GetSymbolInfo(xReference).Symbol.ToTestDisplayString());

2029AssertEx.Equal(expectedMembers, fieldMembers.ToTestDisplayStrings()); 2037AssertEx.Equal(expectedReferences, fieldReferences.ToTestDisplayStrings()); 2269AssertEx.Equal(actualFields, expectedFields);

420AssertEx.SetEqual(new[] { "<Initialize>", "G", ".ctor", "<Main>" }, methods.Select(m => m.Name)); 426AssertEx.SetEqual(new[] { "F", ".ctor" }, methods.Select(m => m.Name));

719AssertEx.Equal(results.Diagnostics, fullDiagnostics);

1003AssertEx.Equal(expected[index].Item, entry.Item);

2691AssertEx.Equal(Array.Empty<CodeAnalysis.NullableAnnotation>(), GetAnonymousTypeNullableAnnotations(type)); 2704AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.None, CodeAnalysis.NullableAnnotation.None }, GetAnonymousTypeNullableAnnotations(type)); 2710AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.NotAnnotated, CodeAnalysis.NullableAnnotation.Annotated }, GetAnonymousTypeNullableAnnotations(type)); 2746AssertEx.Equal(display, result); 2764AssertEx.Equal(display, result); 2783AssertEx.Equal("int.operator +(int, int)", result); 2942AssertEx.Equal(display, result); 2954AssertEx.Equal(display, result); 2973AssertEx.Equal("int.operator +(int)", result); 3040AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.None, CodeAnalysis.NullableAnnotation.None }, type.TypeArgumentNullableAnnotations); 3041AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.None, CodeAnalysis.NullableAnnotation.None }, type.TypeArgumentNullableAnnotations()); 3048AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.Annotated, CodeAnalysis.NullableAnnotation.NotAnnotated }, type.TypeArgumentNullableAnnotations); 3049AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.Annotated, CodeAnalysis.NullableAnnotation.NotAnnotated }, type.TypeArgumentNullableAnnotations()); 3075AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.None, CodeAnalysis.NullableAnnotation.None }, type.TypeArgumentNullableAnnotations); 3076AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.None, CodeAnalysis.NullableAnnotation.None }, type.TypeArgumentNullableAnnotations()); 3083AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.Annotated, CodeAnalysis.NullableAnnotation.NotAnnotated }, type.TypeArgumentNullableAnnotations); 3084AssertEx.Equal(new[] { CodeAnalysis.NullableAnnotation.Annotated, CodeAnalysis.NullableAnnotation.NotAnnotated }, type.TypeArgumentNullableAnnotations()); 3425AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString()); 3450AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString()); 3474AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString()); 3476AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString()); 3502AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString()); 3531AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString()); 3532AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString()); 3569AssertEx.Equal("N.C<T>", types[0].ToTestDisplayString()); 3571AssertEx.Equal("N.C<T>", types[1].ToTestDisplayString()); 3572AssertEx.Equal("N.C<T>", types[2].ToTestDisplayString()); 3611AssertEx.Equal(types.Select(t => t.ToTestDisplayString()), new[] { "C", "C", "C" });

387AssertEx.SetEqual(new[] { $"{RuntimeCorLibName.Name} {RuntimeCorLibName.Version.ToString(2)}", "RefLibV1 1.0", "Lib 2.0", "X 2.0" }, reader.DumpAssemblyReferences()); 783AssertEx.SetEqual(new[] { "goo", "global" }, c.ExternAliases); 790AssertEx.SetEqual(new[] { "goo", "bar" }, c.ExternAliases); 1739AssertEx.SetEqual(new[] { "mscorlib 4.0" }, reader.DumpAssemblyReferences()); 1797AssertEx.Equal(moduleReferences1, moduleReferences2);

98AssertEx.Equal(expected, used.Skip(1)); 102AssertEx.Equal(expected, used); 283AssertEx.Equal(comp.References.Where(r => r.Properties.Kind == MetadataImageKind.Assembly), comp.GetUsedAssemblyReferences()); 318AssertEx.Equal(result, currentResult);

305AssertEx.All(crefSyntaxes, cref => model.GetSymbolInfo(cref).Symbol == null); 937AssertEx.Equal(expected, actual); 1033AssertEx.Equal(expected, actual); 1132AssertEx.Equal(expected, actual); 1215AssertEx.SetEqual(expectedCandidates.AsEnumerable(), actualCandidates.ToArray()); 1389AssertEx.SetEqual(expectedCandidates, actualCandidates.ToArray()); 1558AssertEx.None(actualTypeParameters, p => p.IsFromCompilation(compilation)); 1559AssertEx.None(actualTypeParameters, p => p.IsImplicitlyDeclared); 1560AssertEx.All(actualTypeParameters, p => p.Variance == VarianceKind.None); 1561AssertEx.All(actualTypeParameters, p => p.Locations.Single() == p.DeclaringSyntaxReferences.Single().GetLocation()); 1562AssertEx.None(actualTypeParameters, p => p.HasValueTypeConstraint); 1563AssertEx.None(actualTypeParameters, p => p.HasReferenceTypeConstraint); 1564AssertEx.None(actualTypeParameters, p => p.HasConstructorConstraint); 1565AssertEx.All(actualTypeParameters, p => p.ContainingSymbol == null); 1566AssertEx.All(actualTypeParameters, p => p.GetConstraintTypes(null).Length == 0); 1567AssertEx.All(actualTypeParameters, p => p.GetInterfaces(null).Length == 0); 1639AssertEx.Equal(expectedOriginalParameterTypes.Select(t => t.Ordinal), actualParameterTypes.Select(t => t.Ordinal)); 1640AssertEx.None(expectedOriginalParameterTypes.Zip(actualParameterTypes, object.Equals), x => x); 1670AssertEx.All(actualWinner.ContainingType.TypeArguments(), typeParam => TypeSymbol.Equals(typeParam, actualParameterType, TypeCompareKind.ConsiderEverything2)); //CONSIDER: Would be different in Dev11. 2012AssertEx.SetEqual(actualCandidates.Select(sym => sym.ContainingAssembly.Name), "Lib1", "Lib2"); 2018AssertEx.SetEqual(info.CandidateSymbols.Select(sym => sym.ContainingAssembly.Name), "Lib1", "Lib2"); 3380AssertEx.SetEqual(model.LookupSymbols(position).Select(SymbolExtensions.ToTestDisplayString), 4629AssertEx.None(GetCrefSyntaxes(compilation), x => true); 5090AssertEx.Equal(expectedSymbols, actualSymbols); 5678AssertEx.None(cref.DescendantTokens(descendIntoTrivia: true), token => token.ValueText == null); 5693AssertEx.None(cref.DescendantTokens(descendIntoTrivia: true), token => token.ValueText == null);

984AssertEx.Equal(expected, actualA); 1034AssertEx.Equal(expected, actualA); 1085AssertEx.Equal(expected, actualA); 1139AssertEx.Equal(expected, actualA); 1187AssertEx.Equal(expected, actualA); 1243AssertEx.Equal(expected, actualA); 1306AssertEx.Equal(expected, actual); 1369AssertEx.Equal(expected, actual); 1432AssertEx.Equal(expected, actual); 1489AssertEx.Equal(expected, actual); 6234AssertEx.None(module.GetReferencedAssemblies(), id => id.Name.Contains("GeneralPia")); 6968AssertEx.Equal(expected, actual); 6997AssertEx.Equal(expected, actual); 7045AssertEx.Equal(expected, actual); 7089AssertEx.Equal(expected, actual); 7129AssertEx.Equal(expected, actual); 7166AssertEx.Equal(expected, actual); 7197AssertEx.Equal(expected, actual); 7241AssertEx.Equal(expected, actual); 7285AssertEx.Equal(expected, actual); 7332AssertEx.Equal(expected, actual);

405AssertEx.All(modes, mode => mode.IsValid());

335AssertEx.SetEqual(parameters, info.CandidateSymbols); 358AssertEx.SetEqual(typeParameters, info.CandidateSymbols); 411AssertEx.SetEqual(model.LookupSymbols(pos1).Select(SymbolExtensions.ToTestDisplayString)); 412AssertEx.SetEqual(model.LookupSymbols(pos2).Select(SymbolExtensions.ToTestDisplayString)); 413AssertEx.SetEqual(model.LookupSymbols(pos3).Select(SymbolExtensions.ToTestDisplayString), "T"); 414AssertEx.SetEqual(model.LookupSymbols(pos4).Select(SymbolExtensions.ToTestDisplayString), "T"); 438AssertEx.SetEqual(model.LookupSymbols(pos1).Select(SymbolExtensions.ToTestDisplayString), "System.Int32 x"); 439AssertEx.SetEqual(model.LookupSymbols(pos2).Select(SymbolExtensions.ToTestDisplayString), "System.Int32 x"); 440AssertEx.SetEqual(model.LookupSymbols(pos3).Select(SymbolExtensions.ToTestDisplayString), "T"); 441AssertEx.SetEqual(model.LookupSymbols(pos4).Select(SymbolExtensions.ToTestDisplayString), "T"); 465AssertEx.SetEqual(model.LookupSymbols(pos1).Select(SymbolExtensions.ToTestDisplayString), "System.Int32 value"); 466AssertEx.SetEqual(model.LookupSymbols(pos2).Select(SymbolExtensions.ToTestDisplayString), "System.Int32 value"); 467AssertEx.SetEqual(model.LookupSymbols(pos3).Select(SymbolExtensions.ToTestDisplayString)); 468AssertEx.SetEqual(model.LookupSymbols(pos4).Select(SymbolExtensions.ToTestDisplayString)); 492AssertEx.SetEqual(model.LookupSymbols(pos1).Select(SymbolExtensions.ToTestDisplayString)); 493AssertEx.SetEqual(model.LookupSymbols(pos2).Select(SymbolExtensions.ToTestDisplayString)); 494AssertEx.SetEqual(model.LookupSymbols(pos3).Select(SymbolExtensions.ToTestDisplayString)); 495AssertEx.SetEqual(model.LookupSymbols(pos4).Select(SymbolExtensions.ToTestDisplayString)); 519AssertEx.SetEqual(model.LookupSymbols(pos1).Select(SymbolExtensions.ToTestDisplayString), "System.Int32 x", "System.Int32 value"); 520AssertEx.SetEqual(model.LookupSymbols(pos2).Select(SymbolExtensions.ToTestDisplayString), "System.Int32 x", "System.Int32 value"); 521AssertEx.SetEqual(model.LookupSymbols(pos3).Select(SymbolExtensions.ToTestDisplayString)); 522AssertEx.SetEqual(model.LookupSymbols(pos4).Select(SymbolExtensions.ToTestDisplayString)); 546AssertEx.SetEqual(model.LookupSymbols(pos1).Select(SymbolExtensions.ToTestDisplayString), "System.Int32 x"); 547AssertEx.SetEqual(model.LookupSymbols(pos2).Select(SymbolExtensions.ToTestDisplayString), "System.Int32 x"); 548AssertEx.SetEqual(model.LookupSymbols(pos3).Select(SymbolExtensions.ToTestDisplayString)); 549AssertEx.SetEqual(model.LookupSymbols(pos4).Select(SymbolExtensions.ToTestDisplayString)); 574AssertEx.SetEqual(model.LookupSymbols(pos1).Select(SymbolExtensions.ToTestDisplayString)); 575AssertEx.SetEqual(model.LookupSymbols(pos2).Select(SymbolExtensions.ToTestDisplayString)); 576AssertEx.SetEqual(model.LookupSymbols(pos3).Select(SymbolExtensions.ToTestDisplayString)); 577AssertEx.SetEqual(model.LookupSymbols(pos4), compilation.GlobalNamespace.GetMember<INamedTypeSymbol>("C").TypeParameters.Single()); 602AssertEx.SetEqual(model.LookupSymbols(pos1).Select(SymbolExtensions.ToTestDisplayString)); 603AssertEx.SetEqual(model.LookupSymbols(pos2).Select(SymbolExtensions.ToTestDisplayString)); 604AssertEx.SetEqual(model.LookupSymbols(pos3).Select(SymbolExtensions.ToTestDisplayString)); 605AssertEx.SetEqual(model.LookupSymbols(pos4), compilation.GlobalNamespace.GetMember<INamedTypeSymbol>("C").TypeParameters.Single());

3321AssertEx.Equal(expectedText, actualParts.ToDisplayString()); 3324AssertEx.Equal(expectedKinds, actualParts.Select(p => p.Kind), itemInspector: p => $" SymbolDisplayPartKind.{p}");

716AssertEx.SetEqual(interface3PropertyOverriddenOrHidden.HiddenMembers, interface1Property, interface2Property); 720AssertEx.SetEqual(interface3GetterOverriddenOrHidden.HiddenMembers, interface1Getter, interface2Getter);

2708AssertEx.Equal(new[]

1732AssertEx.SetEqual(castInfo.CandidateSymbols, conversionSymbols); 1739AssertEx.SetEqual(elementConversion.OriginalUserDefinedConversions.GetPublicSymbols(), conversionSymbols);

2395AssertEx.SetEqual(new[] { "A", "B", ".ctor", "I.A", "Main", ".ctor" }, new[] { reader }.GetStrings(reader.GetMethodDefNames())); 2431AssertEx.SetEqual(new[] { ".ctor", "F", "I.F", "Main" }, new[] { reader }.GetStrings(reader.GetMethodDefNames()));

1563AssertEx.Equal(expectedMessage, ptr.EnsureCSharpSymbolOrNull(nameof(ptr)).GetUseSiteDiagnostic().ToString()); 1645AssertEx.Equal($"delegate* unmanaged{expectedText}<System.String>", ptr.ToTestDisplayString()); 1647AssertEx.Equal($"delegate* unmanaged{expectedText}<ref readonly modreq(System.Runtime.InteropServices.InAttribute) System.String>", ptr.ToTestDisplayString()); 1660AssertEx.Equal("delegate* unmanaged[Cdecl, Stdcall]<System.String modopt(System.Runtime.CompilerServices.CallConvCdecl) modopt(System.Runtime.CompilerServices.CallConvStdcall)>", ptr.ToTestDisplayString()); 1662AssertEx.Equal("delegate* unmanaged[Cdecl, Stdcall]<ref readonly modopt(System.Runtime.CompilerServices.CallConvCdecl) modopt(System.Runtime.CompilerServices.CallConvStdcall) modreq(System.Runtime.InteropServices.InAttribute) System.String>", ptr.ToTestDisplayString()); 1665AssertEx.Equal("delegate* unmanaged[Cdecl]<System.String modopt(System.Runtime.CompilerServices.CallConvCdecl)>", ptr.ToTestDisplayString());

2531AssertEx.Equal(expected, actual, itemInspector: s => string.Format("\"{0}\"", s));

807AssertEx.SetEqual(overriddenOrHidden1.HiddenMembers, baseMethod, baseProperty); 813AssertEx.SetEqual(overriddenOrHidden2.HiddenMembers, baseMethod, baseProperty);

482AssertEx.None(type.GetMembersUnordered(), symbol => symbol.Name.StartsWith("_VtblGap", StringComparison.Ordinal));

588AssertEx.All(events, e => e.HasAssociatedField); 592AssertEx.All(events, e => e.AssociatedField == field);

276AssertEx.SetEqual(derivedInterface1MethodOverriddenOrHidden.HiddenMembers, baseInterface1Method, baseInterface2Method); 280AssertEx.SetEqual(derivedInterface1PropertyOverriddenOrHidden.HiddenMembers, baseInterface1Property, baseInterface2Property); 284AssertEx.SetEqual(derivedInterface2MethodOverriddenOrHidden.HiddenMembers, baseInterface1Method, baseInterface2Method); 288AssertEx.SetEqual(derivedInterface2PropertyOverriddenOrHidden.HiddenMembers, baseInterface1Property, baseInterface2Property); 2920AssertEx.All(properties, p => 2968AssertEx.All(properties, p => 3016AssertEx.All(properties, p => p.DeclaredAccessibility == Accessibility.Public); 3063AssertEx.All(properties, p => p.DeclaredAccessibility == Accessibility.Public); 3110AssertEx.All(properties, p => p.DeclaredAccessibility == Accessibility.Public); 3157AssertEx.All(properties, p => p.DeclaredAccessibility == Accessibility.Public); 3231AssertEx.All(properties, p => p.DeclaredAccessibility == Accessibility.ProtectedOrInternal); 3284AssertEx.All(events, e =>

48AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedAttributeLayout, actualAttributes); 56AssertEx.NotNull(member, $"Member {memberPath} was not found"); 59Assert.All(member.GetAttributes(), attr => AssertEx.NotEqual("System.Runtime.CompilerServices.RequiredMemberAttribute", attr.AttributeClass.ToTestDisplayString())); 3324AssertEx.Equal("AttrAttribute", attr.AttributeClass.ToTestDisplayString()); 3353AssertEx.Equal("AttrAttribute", attr.AttributeClass.ToTestDisplayString()); 3383AssertEx.Equal("AttrAttribute", attr.AttributeClass.ToTestDisplayString()); 3413AssertEx.Equal("AttrAttribute", attr.AttributeClass.ToTestDisplayString()); 5219AssertEx.Equal("System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute..ctor()", 5281AssertEx.Equal("System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute..ctor()", 5441AssertEx.Equal("System.ObsoleteAttribute", attrData.AttributeClass.ToTestDisplayString()); 5444AssertEx.Equal(expectedReason, (string)attrArgs[0].ValueInternal!); 5487AssertEx.Equal("System.ObsoleteAttribute", attrData.AttributeClass.ToTestDisplayString()); 5490AssertEx.Equal(expectedReason, (string)attrArgs[0].ValueInternal!); 5703AssertEx.NotNull(c); 5707AssertEx.NotNull(d);

865AssertEx.Equal("System.ValueTuple<System.Object modopt(System.Runtime.CompilerServices.IsLong), System.Object modopt(System.Runtime.CompilerServices.IsLong)> " + 868AssertEx.Equal("(object a, object b) I.M((object c, object d) x)", 875AssertEx.Equal("System.ValueTuple<System.Object modopt(System.Runtime.CompilerServices.IsLong), System.Object modopt(System.Runtime.CompilerServices.IsLong)> " + 878AssertEx.Equal("(object a, object b) C.M((object c, object d) x)", 900AssertEx.Equal("System.ValueTuple<System.Object modopt(System.Runtime.CompilerServices.IsLong), System.Object modopt(System.Runtime.CompilerServices.IsLong)> " + 924AssertEx.Equal("(object, object) C.M((object c, object d) x)", classMethod3.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)); 941AssertEx.Equal("(object a, object b) C.M((object c, object d) x)", classMethod4.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)); 995AssertEx.Equal("System.ValueTuple<System.Object modopt(System.Runtime.CompilerServices.IsLong), System.Object modopt(System.Runtime.CompilerServices.IsLong)> I.P { get; set; }", 997AssertEx.Equal("(object a, object b) I.P", interfaceProperty1.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)); 998AssertEx.Equal("System.ValueTuple<System.Object modopt(System.Runtime.CompilerServices.IsLong), System.Object modopt(System.Runtime.CompilerServices.IsLong)>", 1001AssertEx.Equal("System.ValueTuple<System.Object modopt(System.Runtime.CompilerServices.IsLong), System.Object modopt(System.Runtime.CompilerServices.IsLong)> C.I.P { get; set; }", 1003AssertEx.Equal("(object a, object b) C.P", classProperty1.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)); 1141AssertEx.Equal("System.ValueTuple<System.Object modopt(System.Runtime.CompilerServices.IsLong), System.Object modopt(System.Runtime.CompilerServices.IsLong)> " + 1144AssertEx.Equal("(object a, object b) Base.M((object c, object d) x)", 1164AssertEx.Equal("(object a, object b) C.M((object c, object d) y)", classMethod1.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)); 1192AssertEx.Equal("(object, object) C.M((object c, object d) y)", classMethod2.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)); 1193AssertEx.Equal("System.ValueTuple<System.Object modopt(System.Runtime.CompilerServices.IsLong), System.Object modopt(System.Runtime.CompilerServices.IsLong)>", 1214AssertEx.Equal("(object a, object b) C.M((object, object) y)", classMethod3.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)); 1215AssertEx.Equal("System.ValueTuple<System.Object modopt(System.Runtime.CompilerServices.IsLong), System.Object modopt(System.Runtime.CompilerServices.IsLong)>",

214AssertEx.Equal("<>FE3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855__C", symbol.MetadataName); 264AssertEx.Equal("<file2>F66382B88D8E28FDD21CEADA0DE847F8B00DA1324042DD28F8FFC58C454BD6188__C", symbol.MetadataName); 511AssertEx.Equal("<MyFile>F5E7157F91336401EED4848664C7CEB8A5E156C0D713F4211A61BDB8932B19EF2__C`1", c.MetadataName); 518AssertEx.Equal("<MyFile>F5E7157F91336401EED4848664C7CEB8A5E156C0D713F4211A61BDB8932B19EF2__C`1", classC.MetadataName); 544AssertEx.Equal(expectedMetadataName, c.MetadataName); 550AssertEx.Equal(expectedMetadataName, expectedSymbol.MetadataName); 575AssertEx.Equal("<MyGeneratedFile_g>F18307E6C553D2E6465CEA162655C06E2BB2896889519559EB1EE5FA53513F0E8__C", c.MetadataName); 581AssertEx.Equal("<MyGeneratedFile_g>F18307E6C553D2E6465CEA162655C06E2BB2896889519559EB1EE5FA53513F0E8__C", expectedSymbol.MetadataName); 615AssertEx.Equal("<file>F620949CDCC480533E3607E5DD92F88E866EC1D65C225D70509A32F831433D9A4__C", classC.MetadataName); 662AssertEx.Equal("<file>F620949CDCC480533E3607E5DD92F88E866EC1D65C225D70509A32F831433D9A4__C", member.MetadataName); 695AssertEx.Equal("<file>F620949CDCC480533E3607E5DD92F88E866EC1D65C225D70509A32F831433D9A4__C`1", classC.MetadataName); 723AssertEx.Equal("<file>F620949CDCC480533E3607E5DD92F88E866EC1D65C225D70509A32F831433D9A4__C", classC.MetadataName); 873AssertEx.Equal("<My_File>FA818559F9E8E4AF40425A1819866C71357DE9017B4B7EFE1D34D9F48C0539B6E__C", c.MetadataName); 933AssertEx.Equal(firstMetadataName, expectedSymbol.MetadataName); 941AssertEx.Equal(secondMetadataName, expectedSymbol.MetadataName); 3659AssertEx.Equal("<file1>F96B1D9CB33A43D51528FE81EDAFE5AE31358FE749929AC76B76C64B60DEF129D__C", sourceMember.MetadataName); 3775AssertEx.Equal(expectedChecksum, identifier.GetValueOrDefault().FilePathChecksumOpt); 3784AssertEx.Equal(expectedChecksum, identifier.GetValueOrDefault().FilePathChecksumOpt); 3793AssertEx.Equal(expectedChecksum, identifier.GetValueOrDefault().FilePathChecksumOpt); 3842AssertEx.Equal(

505AssertEx.Equal(expectedAnnotations, actualAnnotations); 964AssertEx.Equal(expectedAnnotations, actualAnnotations); 1022AssertEx.Equal(expectedAnnotations, actualAnnotations); 1064AssertEx.Equal(expectedNullabilities, members.Select(nullabilityFunc)); 4790AssertEx.Equal(expectedAnnotations, actualAnnotations); 4937AssertEx.Equal("void M()", model.GetDeclaredSymbol(localFunction).ToTestDisplayString()); 4969AssertEx.Equal("(System.Object, System.Int32 a)", operation.Type.ToTestDisplayString()); 5012AssertEx.Equal("(System.String a, System.String b)", model.GetTypeInfo(tupleLiteral).Type.ToTestDisplayString(includeNonNullable: false)); 5058AssertEx.Equal("C..ctor(System.Int32 i)", model.GetSymbolInfo(constructor).CandidateSymbols[0].ToTestDisplayString()); 5061AssertEx.Equal("_ = s", assignmentsInLambda[0].ToString()); 5062AssertEx.Equal("_ = s", assignmentsInLambda[2].ToString()); 5063AssertEx.Equal("System.String?", model.GetTypeInfo(assignmentsInLambda[0].Right).Type.ToTestDisplayString(includeNonNullable: true)); 5064AssertEx.Equal("System.String!", model.GetTypeInfo(assignmentsInLambda[2].Right).Type.ToTestDisplayString(includeNonNullable: true)); 5076AssertEx.Equal("System.String!", model.GetTypeInfo(switchExpressionInput).Type.ToTestDisplayString(includeNonNullable: true)); 5080AssertEx.Equal("System.String!", model.GetTypeInfo(switchExpressionInput).Type.ToTestDisplayString(includeNonNullable: true));

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

1076AssertEx.Equal(new[] {

275AssertEx.Equal(expected, usingAliasType.ToDisplayString(SymbolDisplayFormat.TestFormat));

254AssertEx.Equal("System.String C1<System.Int32 modopt(C2<G>)>.Method()", method.ToTestDisplayString());

2451AssertEx.Equal(CreateCompilation(tree).GetDiagnostics(), CreateCompilation(tree).GetDiagnostics());

50AssertEx.Equal(expectedLineMappings, actualLineMappings); 62AssertEx.Equal(expectedTextSpans, actualTextSpans); 96AssertEx.Equal(expectedLineMappings, actualLineMappings); 114AssertEx.Equal(expectedTextSpans, actualTextSpans); 156AssertEx.Equal(expectedLineMappings, actualLineMappings); 195AssertEx.Equal(expectedLineMappings, actualLineMappings); 207AssertEx.Equal(expectedTextSpans, actualTextSpans); 246AssertEx.Equal(expectedLineMappings, actualLineMappings); 265AssertEx.Equal(expectedVisibility, actualVisibility); 277AssertEx.Equal(expectedTextSpans, actualTextSpans); 314AssertEx.Equal(expectedLineMappings, actualLineMappings); 323AssertEx.Equal(expectedTextSpans, actualTextSpans); 366AssertEx.Equal(expectedLineMappings, actualLineMappings); 378AssertEx.Equal(expectedTextSpans, actualTextSpans); 427AssertEx.Equal(expectedLineMappings, actualLineMappings); 440AssertEx.Equal(expectedTextSpans, actualTextSpans); 583AssertEx.Equal(expectedLineMappings, actualLineMappings);

156AssertEx.Equal(new[] 220AssertEx.Equal(new[] 253AssertEx.Equal(new[] 267AssertEx.Equal(new[] 287AssertEx.Equal(new[]

2414AssertEx.AreEqual(@"System.Console.WriteLine(false) 2445AssertEx.Equal(@"System.Console.WriteLine(true) 2473AssertEx.Equal(@"if (false)

51AssertEx.Fail("Unmatched expected: " + expectedEnumerator.Current); 56AssertEx.Fail("Unmatched actual: " + expectedEnumerator.Current);

113AssertEx.Fail("Should have thrown - can't create an IdentifierName token"); 139AssertEx.Fail("Should have thrown"); 150AssertEx.Fail("Should have thrown"); 161AssertEx.Fail("Should have thrown");

63AssertEx.SetEqual(symbols.Select(s => s.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)), descriptions); 482AssertEx.Equal(expectedTypes, actualTypes, message: method.ToTestDisplayString());

1300AssertEx.Equal(resolvedReferences, used); 1350AssertEx.Equal(expectedUsesOfNullable, symbols, itemInspector: s => $"\"{s}\"");

126AssertEx.SetEqual(expectedEntries, actualEntries, itemInspector: entry => $@"

143AssertEx.Equal(expectedSyntax, syntax.ToString()); 155AssertEx.Equal(expectedType, semanticInfo.Type.ToTestDisplayString(includeNonNullable: false)); 164AssertEx.Equal(expectedConvertedType, semanticInfo.ConvertedType.ToTestDisplayString(includeNonNullable: false)); 196AssertEx.Equal(expectedSymbolCandidates, semanticInfo.MemberGroup.Select(s => s.ToTestDisplayString(includeNonNullable: false))); 217AssertEx.Equal(expectedSymbol, semanticInfo.Symbol.ToTestDisplayString(includeNonNullable: false)); 224AssertEx.Equal(expectedSymbolCandidates, semanticInfo.CandidateSymbols.Select(s => s.ToTestDisplayString(includeNonNullable: false)));

98AssertEx.Equal(new byte[] { 0x12, (byte)'M', (byte)'i', (byte)'c', (byte)'r', (byte)'o' }, pdbStream.GetBuffer().Take(6).ToArray()); 99AssertEx.Equal(new byte[] { 0x12, (byte)'M', (byte)'Z' }, peStream.GetBuffer().Take(3).ToArray());

53AssertEx.Equal(expectedText, normalized);

65AssertEx.Equal(expected, actual);

488AssertEx.Fail(BuildFailureMessage(expectedSpans, WellKnownDiagnosticTags.Unnecessary, markupKey, initialMarkupWithoutSpans, diagnostics)); 617AssertEx.EqualOrDiff(expectedText, actualText); 686AssertEx.Fail($"Could not find document with name '{doc.Name}'");

118AssertEx.Equal(expectedFolders, addedDocument.Folders);

244AssertEx.Empty(analyzerExceptionDiagnostics, "Found analyzer exception diagnostics");

94AssertEx.EqualOrDiff(result, session.SubjectBuffer.CurrentSnapshot.GetText());

46AssertEx.Fail($"Unexpected brace pair: {bracePair}");

72AssertEx.Equal(expected, actualFormatted);

44AssertEx.Fail("Unexpected actual classification: {0}", GetText(actualClassificationList[i])); 48AssertEx.Fail("Missing classification for: {0}", GetText(expectedClassificationList[i]));

82AssertEx.Equal(expectedSpans, textView.Selection.SelectedSpans.Select(snapshotSpan => TextSpan.FromBounds(snapshotSpan.Start, snapshotSpan.End)));

181AssertEx.None( 198AssertEx.Any(items, Predicate); 517AssertEx.EqualOrDiff(actualExpectedCode, actualCodeAfterCommit); 822AssertEx.Any(completionList.ItemsList, c => CompareItems(c.DisplayText, expectedItem)); 840AssertEx.None(completionList.ItemsList, c => CompareItems(c.DisplayText, expectedItem));

206AssertEx.Equal( 215AssertEx.Equal( 238AssertEx.Empty(duplicateNonPartial, "Duplicate non-partial symbols"); 260AssertEx.SetEqual(expected, actual, message: message, itemSeparator: ",\r\n"); 279AssertEx.Equal( 418AssertEx.Equal( 476=> AssertEx.Equal(expected, actual.Edits.Select(e => e.GetDebuggerDisplay()), itemSeparator: ",\r\n", itemInspector: s => $"\"{s}\"");

43=> AssertEx.Equal(this, actual, itemSeparator: ",\r\n");

43AssertEx.EqualOrDiff(expected, actual.ToString());

235AssertEx.EqualOrDiff(expected, actual);

52AssertEx.Fail(errorMessage.ToString());

57AssertEx.EqualOrDiff(renderedExpected, renderedActual);

98AssertEx.SetEqual(endDocument.DocumentFolders, updatedDocument.Folders); 101AssertEx.EqualOrDiff(endDocument.Text, (await updatedDocument.GetTextAsync()).ToString());

272AssertEx.Fail("Expected signature help items must be provided for EditorBrowsable tests. If there are no expected items, provide an empty IEnumerable rather than null."); 410AssertEx.NotNull(items, "Signature help provider returned null for items. Did you forget $$ in the test or is the test otherwise malformed, e.g. quotes not escaped?");

54AssertEx.Equal(expected, buffer.CurrentSnapshot.GetText());

833AssertEx.Fail($"The document attributes on file {fileName} conflicted");

19Roslyn.Test.Utilities.AssertEx.Fail("Wrong token count. Expected '{0}', Actual '{1}', Expected Text: '{2}', Actual Text: '{3}'",

754AssertEx.SetEqual(expectedChanges, edits.TextChanges); 776AssertEx.Equal(expectedSelectedSpans, textView.Selection.SelectedSpans.Select(snapshotSpan => snapshotSpan.Span));

19AssertEx.Equal(

388AssertEx.Fail("shouldn't reach here"); 447AssertEx.Equal(new[] 1213AssertEx.Fail("shouldn't reach here");

119AssertEx.Equal(new[] 169AssertEx.Empty(oldSpans); 225AssertEx.Equal(new[]

78AssertEx.Equal(new[] { documentId, designTimeDocumentId }, actualDesignTimeDocumentIds);

90AssertEx.Equal(new[] { "Offset=0 Ordinal=0 Kind=LambdaDisplayClass", "Offset=33 Ordinal=0 Kind=UserDefined" }, debugInfo.InspectLocalSlots()); 91AssertEx.Equal(new[] { "Offset=43 Id=0#0 Closure=0" }, debugInfo.InspectLambdas()); 92AssertEx.Equal(new[] { "Offset=0 Id=0#0" }, debugInfo.InspectClosures());

206AssertEx.Equal(documentsWithRudeEdits.NullToEmpty(), documentsToReanalyze); 215AssertEx.Equal(documentsWithRudeEdits.NullToEmpty(), documentsToReanalyze); 223AssertEx.Equal(documentsWithRudeEdits.NullToEmpty(), documentsToReanalyze); 229AssertEx.Equal(documentsWithRudeEdits.NullToEmpty(), documentsToReanalyze); 235AssertEx.Equal(documentsWithRudeEdits.NullToEmpty(), documentsToReanalyze); 424AssertEx.Equal(expectedRows, reader.GetEditAndContinueLogEntries(), itemInspector: EncLogRowToString); 589AssertEx.Equal(new[] 604AssertEx.Equal(new[] { $"{projectPId}: Warning ENC1005: {string.Format(FeaturesResources.DocumentIsOutOfSyncWithDebuggee, sourceFileB.Path)}" }, InspectDiagnostics(emitDiagnostics)); 670AssertEx.Equal(new[] 739AssertEx.Equal(new[] 931AssertEx.Equal(new[] { $"{document2.Project.Id}: Error ENC1001: {string.Format(FeaturesResources.ErrorReadingFile, moduleFile.Path, expectedErrorMessage)}" }, InspectDiagnostics(emitDiagnostics)); 951AssertEx.Equal(new[] 960AssertEx.Equal(new[] 1012AssertEx.Equal(new[] { $"{project.Id}: Warning ENC1006: {string.Format(FeaturesResources.UnableToReadSourceFileOrPdb, sourceFile.Path)}" }, InspectDiagnostics(emitDiagnostics)); 1016AssertEx.Equal(new[] 1059AssertEx.Equal(new[] { $"{project.Id}: Warning ENC1006: {string.Format(FeaturesResources.UnableToReadSourceFileOrPdb, sourceFile.Path)}" }, InspectDiagnostics(emitDiagnostics)); 1072AssertEx.Equal(new[] 1131AssertEx.Equal(new[] 1139AssertEx.Equal(new[] 1296AssertEx.Empty(diagnostics1); 1302AssertEx.Equal(new[] { $"{document2.FilePath}: (5,0)-(5,32): Error ENC2016: {string.Format(FeaturesResources.EditAndContinueDisallowedByProject, document2.Project.Name, "*message*")}" }, InspectDiagnostics(emitDiagnostics)); 1306AssertEx.SetEqual(new[] { moduleId }, debuggingSession.GetTestAccessor().GetModulesPreparedForUpdate()); 1308AssertEx.Equal(new[] 1404AssertEx.Equal(new[] { "ENC0021: " + string.Format(FeaturesResources.Adding_0_requires_restarting_the_application, FeaturesResources.type_parameter) }, 1423AssertEx.SetEqual(new[] { moduleId }, debuggingSession.GetTestAccessor().GetModulesPreparedForUpdate()); 1427AssertEx.Equal(new[] 1436AssertEx.Equal(new[] 1475AssertEx.Equal(new[] { "ENC0001: " + string.Format(FeaturesResources.Updating_an_active_statement_requires_restarting_the_application) }, 1482AssertEx.Empty(diagnostics); 1489AssertEx.Equal(new[] { "ENC0001: " + string.Format(FeaturesResources.Updating_an_active_statement_requires_restarting_the_application) }, 1507AssertEx.Empty(diagnostics); 1542AssertEx.Equal(new[] { "ENC0021: " + string.Format(FeaturesResources.Adding_0_requires_restarting_the_application, FeaturesResources.type_parameter) }, 1601AssertEx.Equal(new[] { $"{project.Id}: Warning ENC1005: {string.Format(FeaturesResources.DocumentIsOutOfSyncWithDebuggee, sourceFile.Path)}" }, InspectDiagnostics(emitDiagnostics)); 1618AssertEx.Equal(new[] 1640AssertEx.SetEqual(new[] { moduleId }, debuggingSession.GetTestAccessor().GetModulesPreparedForUpdate()); 1644AssertEx.Equal(new[] 1654AssertEx.Equal(new[] 1695AssertEx.Equal( 1739AssertEx.Equal( 1753AssertEx.Equal( 1786AssertEx.Empty(diagnostics1); 1796AssertEx.SetEqual(new[] { moduleId }, debuggingSession.GetTestAccessor().GetModulesPreparedForUpdate()); 1798AssertEx.Equal(new[] 1826AssertEx.Empty(diagnostics1); 1837AssertEx.Equal(new[] { $"{document2.FilePath}: (0,30)-(0,32): Error CS0266: {string.Format(CSharpResources.ERR_NoImplicitConvCast, "long", "int")}" }, InspectDiagnostics(emitDiagnostics)); 1841AssertEx.SetEqual(new[] { moduleId }, debuggingSession.GetTestAccessor().GetModulesPreparedForUpdate()); 1843AssertEx.Equal(new[] 1987AssertEx.Equal(new[] { generatedDocumentId }, 1991AssertEx.Equal(documentKind == DocumentKind.Source ? new[] { documentId, generatedDocumentId } : new[] { generatedDocumentId }, changedOrAddedDocuments.Select(d => d.Id)); 2015AssertEx.Equal(documentKind == DocumentKind.Source ? new[] { documentId } : Array.Empty<DocumentId>(), 2039AssertEx.Equal(documentKind == DocumentKind.Source ? new[] { documentId, generatedDocumentId } : new[] { generatedDocumentId }, 2043AssertEx.Equal(documentKind == DocumentKind.Source ? new[] { documentId, generatedDocumentId } : new[] { generatedDocumentId }, changedOrAddedDocuments.Select(d => d.Id)); 2065AssertEx.Equal(new[] { generatedDocumentId }, 2069AssertEx.Equal(new[] { generatedDocumentId }, changedOrAddedDocuments.Select(d => d.Id)); 2125AssertEx.Equal(new[] 2187AssertEx.Empty(diagnostics); 2195AssertEx.Empty(diagnostics); 2215AssertEx.Equal(new[] { "ENC0101: " + string.Format(FeaturesResources.Updating_the_attributes_of_0_requires_restarting_the_application_because_it_is_not_supported_by_the_runtime, FeaturesResources.class_) }, 2224AssertEx.Equal(new[] { "ENC0101: " + string.Format(FeaturesResources.Updating_the_attributes_of_0_requires_restarting_the_application_because_it_is_not_supported_by_the_runtime, FeaturesResources.class_) }, 2240AssertEx.Empty(diagnostics); 2249AssertEx.Equal(new[] 2337AssertEx.Empty(diagnostics); 2341AssertEx.Equal(new[] { $"{document2.Project.Id}: Error ENC1007: {FeaturesResources.ChangesRequiredSynthesizedType}" }, InspectDiagnostics(emitDiagnostics)); 2369AssertEx.Empty(diagnostics1); 2373AssertEx.Equal(new[] { $"{document2.FilePath}: (0,0)-(0,54): Error CS8055: {string.Format(CSharpResources.ERR_EncodinglessSyntaxTree)}" }, InspectDiagnostics(emitDiagnostics)); 2390AssertEx.Equal(new[] { $"{document2.FilePath}: (0,0)-(0,54): Error CS8055: {string.Format(CSharpResources.ERR_EncodinglessSyntaxTree)}" }, InspectDiagnostics(emitDiagnostics)); 2394AssertEx.Equal(new[] 2441AssertEx.Equal(requiredChecksum, CreateText(source1).GetChecksum()); 2540AssertEx.Empty(diagnostics); 2545AssertEx.Equal(new[] { $"{project.Id}: Warning ENC1005: {string.Format(FeaturesResources.DocumentIsOutOfSyncWithDebuggee, sourceFile.Path)}" }, InspectDiagnostics(emitDiagnostics)); 2618AssertEx.Empty(diagnostics); 2629AssertEx.Empty(emitDiagnostics); 2712AssertEx.Empty(diagnostics1); 2737AssertEx.Equal(updates.Updates, pendingUpdate.Deltas); 2795AssertEx.SetEqual(new[] { moduleId }, debuggingSession.GetTestAccessor().GetModulesPreparedForUpdate()); 2799AssertEx.Equal(new[] 2807AssertEx.Equal(new[] 2979AssertEx.SetEqual(new[] { 0x02000002, 0x02000003, 0x02000004, 0x02000005 }, delta.UpdatedTypes, itemInspector: t => "0x" + t.ToString("X")); 3026AssertEx.Equal(new[] { 0x02000002, 0x02000003 }, delta.UpdatedTypes, itemInspector: t => "0x" + t.ToString("X")); 3084AssertEx.Equal(new[] { "3 -> 4" }, lineUpdate.LineUpdates.Select(edit => $"{edit.OldLine} -> {edit.NewLine}")); 3299AssertEx.Empty(diagnostics); 3303AssertEx.Equal(new[] { $"{document2.Project.Id}: Error ENC1007: {FeaturesResources.ChangesRequiredSynthesizedType}" }, InspectDiagnostics(emitDiagnostics)); 3438AssertEx.Equal(readers, baselineReaders); 3448AssertEx.Equal(readers, baselineReaders); 3487AssertEx.Equal(new[] { $"{document1.Project.Id}: Error ENC1001: {string.Format(FeaturesResources.ErrorReadingFile, "test-pdb", new FileNotFoundException().Message)}" }, InspectDiagnostics(emitDiagnostics)); 3520AssertEx.Equal(new[] { $"{document.Project.Id}: Error ENC1001: {string.Format(FeaturesResources.ErrorReadingFile, "test-assembly", "*message*")}" }, InspectDiagnostics(emitDiagnostics)); 3525AssertEx.Equal(new[] 3589AssertEx.Equal(new[] 3598AssertEx.Equal(trackedActiveSpans1, currentSpans); 3616AssertEx.Equal(new[] { adjustedActiveLineSpan1, adjustedActiveLineSpan2 }, currentSpans.Select(s => s.LineSpan)); 3675AssertEx.Equal(new[] 3687AssertEx.Equal(new[] { activeLineSpan11, activeLineSpan12 }, currentSpans.Select(s => s.LineSpan)); 3809AssertEx.Equal(new[] 3815AssertEx.Equal(new[] 3837AssertEx.Equal(new[] 3913AssertEx.Equal(new[] 3927AssertEx.Equal(new[] { $"(9,18)-(9,22)" }, baseSpans.Single().Select(s => s.LineSpan.ToString())); 3937AssertEx.Equal(new[] { $"(10,12)-(10,16)" }, baseSpans.Single().Select(s => s.LineSpan.ToString())); 4018AssertEx.Equal(new[] 4088AssertEx.Equal(new[] { "ENC0063: " + string.Format(FeaturesResources.Updating_a_0_around_an_active_statement_requires_restarting_the_application, CSharpFeaturesResources.catch_clause) }, 4180AssertEx.Equal(new[] 4201AssertEx.Equal(new[] 4221AssertEx.Equal(new[] 4237AssertEx.Equal(new[] 4327AssertEx.Equal(new[] 4343AssertEx.Equal(new[] 4362AssertEx.Equal(new[] 4449AssertEx.Equal(new[] 4577AssertEx.Equal(new[] 4588AssertEx.Equal(new[] { 0x02000002 }, result.updates[0].UpdatedTypes); 4594AssertEx.Equal( 4644AssertEx.Equal(new[] 4660AssertEx.Equal(

191AssertEx.Equal(new[] 206AssertEx.Equal(new[] 212AssertEx.Equal(new[] 219AssertEx.Equal(new[] 224AssertEx.Equal(new[] 234AssertEx.Equal(new[] 241AssertEx.Equal(new[] 276AssertEx.Equal(new[] 285AssertEx.Equal(new[] 291AssertEx.Equal(new[] 350AssertEx.Equal(new[] 362AssertEx.Equal(new[] 391AssertEx.Equal(new[] 398AssertEx.Equal(new[] 403AssertEx.Equal(new[] 533AssertEx.Equal(new[] 547AssertEx.Equal(new[] 585AssertEx.Equal(new[] 598AssertEx.Equal(new[] 607AssertEx.Equal(new[] 667AssertEx.Equal(new[] 692AssertEx.Equal(new[]

96AssertEx.Equal(new[]

101AssertEx.Equal(documentIds, mockDiagnosticService.DocumentsToReanalyze); 151AssertEx.Equal(new[] { documentId }, captureMatchingDocuments); 204AssertEx.Equal(activeSpans1, activeStatementSpanProvider(documentId, "test.cs", CancellationToken.None).AsTask().Result); 232AssertEx.Equal($"[{projectId}] Error ENC1001: test.cs(0, 1, 0, 2): {string.Format(FeaturesResources.ErrorReadingFile, "doc", "syntax error")}", Inspect(syntaxErrorData!)); 241AssertEx.Equal(new[] 251AssertEx.Equal(new byte[] { 1, 2 }, delta.ILDelta); 252AssertEx.Equal(new byte[] { 3, 4 }, delta.MetadataDelta); 253AssertEx.Equal(new byte[] { 5, 6 }, delta.PdbDelta); 254AssertEx.Equal(new[] { 0x06000001 }, delta.UpdatedMethods); 255AssertEx.Equal(new[] { 0x02000001 }, delta.UpdatedTypes); 259AssertEx.Equal(new[] { new SourceLineUpdate(1, 2) }, lineEdit.LineUpdates); 290AssertEx.Equal(activeSpans1, activeStatementSpanProvider(documentId, "test.cs", CancellationToken.None).AsTask().Result); 316AssertEx.Equal(new[] { documentId, inProcOnlyDocumentId }, documentIds); 328AssertEx.Equal(activeSpans1, activeStatementSpanProvider(documentId, "test.cs", CancellationToken.None).AsTask().Result);

118AssertEx.Equal(allKinds, allKinds.Distinct());

29AssertEx.Equal(new[]

39AssertEx.NotNull(tree); 89AssertEx.EqualOrDiff(originalText, tree.Root.ToFullString());

124AssertEx.NotNull(current);

151AssertEx.EqualOrDiff(expected, actual);

180AssertEx.NotNull(diffView);

408AssertEx.EqualOrDiff("quux$0", lspSnippetString); 419AssertEx.EqualOrDiff("bar quux$0", lspSnippetString); 501AssertEx.EqualOrDiff(output, lspSnippetString);

30AssertEx.NotNull(stackFrame); 37AssertEx.NotNull(reparsedFrame); 43AssertEx.NotNull(definition); 54AssertEx.NotNull(expectedSymbol); 60AssertEx.SetEqual(expectedDefinition.NameDisplayParts, definition.NameDisplayParts); 61AssertEx.SetEqual(expectedDefinition.OriginationParts, definition.OriginationParts); 62AssertEx.SetEqual(expectedDefinition.Properties, definition.Properties); 63AssertEx.SetEqual(expectedDefinition.SourceSpans, definition.SourceSpans); 64AssertEx.SetEqual(expectedDefinition.Tags, definition.Tags); 805AssertEx.SetEqual(result.ParsedFrames, ignoredFrames); 856AssertEx.NotNull(frame); 861AssertEx.NotNull(definition);

24AssertEx.SetEqual(attributes.Select(a => a.Priority), SuggestedActionsSourceProvider.Orderings);

492AssertEx.SetEqual(immediateDerived.Select(d => d.Name), 500AssertEx.SetEqual(transitiveDerived.Select(d => d.Name), 545AssertEx.SetEqual(immediateImpls.Select(d => d.Name), 552AssertEx.SetEqual(transitiveImpls.Select(d => d.Name),

119=> Roslyn.Test.Utilities.AssertEx.Equal(parts, BreakIntoWordParts(original)); 122=> Roslyn.Test.Utilities.AssertEx.Equal(parts, BreakIntoCharacterParts(original));

42AssertEx.NotNull(actual);

225AssertEx.Equal(

80AssertEx.SetEqual(glyphTags, codeAction.Tags) 122AssertEx.Equal(expected, actual)

280AssertEx.Equal(expectedDiagnostics, actualDiagnostics, New Comparer()) 282AssertEx.SetEqual(expectedDiagnostics, actualDiagnostics, New Comparer())

939AssertEx.Equal( 945AssertEx.Equal(

60AssertEx.SetEqual(testDocument.AnnotatedSpans("Reference"),

44AssertEx.SetEqual(references.Select(Function(r) r.Definition.ContainingAssembly.Name), {"CSProj1", "CSProj2"}) 78AssertEx.SetEqual(references.Select(Function(r) r.Definition.ContainingAssembly.Name), {"VBProj1", "VBProj2"}) 120AssertEx.SetEqual(references.Select(Function(r) r.Definition.ContainingAssembly.Name), {"VBProj1", "VBProj2"}) 133AssertEx.SetEqual(references.Select(Function(r) r.Definition.ContainingAssembly.Name), {"VBProj1"}) 311AssertEx.SetEqual(sourceReferences.Select(Function(r) r.Definition.ContainingAssembly.Name), {"CSProj1", "CSProj2"}) 354AssertEx.SetEqual(sourceReferences.Select(Function(r) r.Definition.ContainingAssembly.Name), {"CSProj1", "CSProj2"}) 397AssertEx.SetEqual(sourceReferences.Select(Function(r) r.Definition.ContainingAssembly.Name), {"CSProj1", "CSProj2"}) 440AssertEx.SetEqual(sourceReferences.Select(Function(r) r.Definition.ContainingAssembly.Name), {"CSProj1", "CSProj2"})

337AssertEx.Equal(expectedSpans, actualSpans,

72AssertEx.Equal(metadataDefinitions, actualDefintionsWithoutSpans)

57AssertEx.Equal(expectedTags, producedTags) 72AssertEx.Equal(expectedText.ToString(), newText)

58AssertEx.Equal(expectedTags, producedTags)

269AssertEx.Fail("The test is missing a $$ in the workspace.") 449AssertEx.NotNull(document, "Peek didn't navigate to a document in source. Navigated to " + documentResult.FilePath + " instead.")

69AssertEx.Equal(expectedTags, producedTags)

50AssertEx.Equal(

213Sub() AssertEx.Fail("Space should not have been passed to the editor."), 255Sub() AssertEx.Fail("Tab should not have been passed to the editor."), 336Sub() AssertEx.Fail("Command should not have been passed to the editor."), 349Sub() AssertEx.Fail("Command should not have been passed to the editor."), 392Sub() AssertEx.Fail("Home should not have been passed to the editor."), 409Sub() AssertEx.Fail("Shift+Home should not have been passed to the editor."), 425Sub() AssertEx.Fail("End should not have been passed to the editor."), 442Sub() AssertEx.Fail("Shift+End should not have been passed to the editor."),

80AssertEx.Fail("The test must have a single $$ marking the symbol being renamed.") 90AssertEx.Fail("The symbol touching the $$ could not be found.") 211AssertEx.Fail(String.Format("The label '{0}' was not mentioned in the test.", label)) 264AssertEx.Fail(

1615AssertEx.Equal(validExpectedSpans, validTaggedSpans) 1616AssertEx.Equal(conflictExpectedSpans, conflictTaggedSpans) 1648AssertEx.Equal(validExpectedSpans, validTaggedSpans) 1649AssertEx.Equal(conflictExpectedSpans, conflictTaggedSpans)

417AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: true, expectedValueSourcePath: expectedValueSourcePath, expectedValueSourceLine: expectedValueSourceLine); 526AssertEx.AssertEqualToleratingWhitespaceDifferences( 546AssertEx.Equal(expected, actual); 564AssertEx.Equal(expectedIds, actualIds);

19AssertEx.Equal(expected, actual.Select(r => $"{r.Alias} = '{r.TargetAssembly}'")); 24AssertEx.AssertEqualToleratingWhitespaceDifferences(expected,

31AssertEx.Equal(expectedSignatures, actualSignatures);

105AssertEx.Equal(

38AssertEx.SetEqual(actualKeywordKinds, expectedKeywordKinds);

33AssertEx.Equal(internalValues, externalValues); 34AssertEx.Equal(internalNames, externalNames);

32AssertEx.NotNull(actualCodeLenses); 42AssertEx.NotNull(resolvedCodeLens?.Command);

96AssertEx.NotNull(diagnostics); 132AssertEx.NotNull(returnedResult); 250AssertEx.NotNull(diagnostics);

41AssertEx.Equal(new[]

1297AssertEx.NotNull(results); 1311AssertEx.NotNull(results); 1368AssertEx.NotNull(results); 1386AssertEx.NotNull(results); 1437AssertEx.NotNull(results); 1453AssertEx.NotNull(results); 1500AssertEx.NotNull(results); 1516AssertEx.NotNull(results); 1555AssertEx.NotNull(results); 1571AssertEx.NotNull(results); 1611AssertEx.NotNull(results); 1627AssertEx.NotNull(results);

88AssertEx.NotNull(document); 206AssertEx.NotNull(document); 280AssertEx.NotNull(document); 318AssertEx.NotNull(document);

280AssertEx.NotNull(result); 284AssertEx.NotNull(item.Range);

411AssertEx.NotNull(result);

82AssertEx.Equal(ConvertToReadableFormat(expectedResults.Data), ConvertToReadableFormat(results)); 115AssertEx.Equal(ConvertToReadableFormat(expectedResults.Data), ConvertToReadableFormat(results)); 152AssertEx.Equal(ConvertToReadableFormat(expectedResults.Data), ConvertToReadableFormat(results)); 185AssertEx.Equal(ConvertToReadableFormat(expectedResults.Data), ConvertToReadableFormat(results.Data)); 238AssertEx.Equal(ConvertToReadableFormat(expectedResults.Data), ConvertToReadableFormat(results)); 304AssertEx.Equal(ConvertToReadableFormat(expectedResults.Data), ConvertToReadableFormat(results)); 377AssertEx.Equal(ConvertToReadableFormat(expectedResults.Data), ConvertToReadableFormat(results));

574AssertEx.NotNull(spans); 595AssertEx.NotNull(spans);

157AssertEx.NotNull(context.Document);

38AssertEx.NotNull(lspDocument); 44AssertEx.NotNull(lspDocument); 78AssertEx.NotNull(firstDocumentWithChange); 79AssertEx.NotNull(secondDocumentUnchanged); 112AssertEx.NotNull(openedDocument); 117AssertEx.NotNull(secondDocument); 140AssertEx.NotNull(openedDocument); 164AssertEx.NotNull(openedDocument); 189AssertEx.NotNull(lspDocument); 212AssertEx.NotNull(miscDocument); 219AssertEx.NotNull(miscDocument); 228AssertEx.NotNull(document); 275AssertEx.NotNull(hostSolution); 338AssertEx.NotNull(firstDocument); 343AssertEx.NotNull(secondDocument); 352AssertEx.NotNull(changedFirstDocument); 393AssertEx.NotNull(firstDocument); 398AssertEx.NotNull(secondDocument); 408AssertEx.NotNull(secondDocumentChangedProject); 448AssertEx.NotNull(documentServerTwo); 458AssertEx.NotNull(documentServerOne); 461AssertEx.NotNull(documentServerTwo); 478AssertEx.NotNull(lspDocument); 490AssertEx.NotNull(lspDocument);

27AssertEx.EqualOrDiff( 58AssertEx.EqualOrDiff(

239AssertEx.SetEqual(implementationRanges, definitionRangesForImplementingMethods)

35AssertEx.NotNull(originalPdbReader);

96AssertEx.NotNull(compilation);

110AssertEx.NotNull(compilation);

103AssertEx.Equal(new[] 128AssertEx.Equal(new[] 136AssertEx.Equal(new[]

152AssertEx.SetEqual(new[] { "MultiModule.dll", "mod2.netmodule", "mod3.netmodule" }, scFiles.Select(p => Path.GetFileName(p)));

38AssertEx.SetEqual(actualReferences.SelectAsArray(r => r.FilePath), assembly1.Path, assembly2.Path); 44AssertEx.SetEqual(actualReferences.SelectAsArray(r => r.FilePath), assembly2.Path); 59AssertEx.SetEqual(actualReferences.SelectAsArray(r => r.FilePath), assembly2.Path);

114AssertEx.Equal(new[] { "", "blah.", "b\0lah", ".blah", "b\0lah", ".blah" }, options.Imports);

848AssertEx.Equal(

102if (AssertEx.TryGenerateExpectedSourceFileAndGetDiffLink(actualString, expectedString.Count(c => c == '\n') + 1, expectedValueSourcePath, expectedValueSourceLine, out var link))

66AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: false, expectedValueSourcePath: callerPath, expectedValueSourceLine: callerLine); 77AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, actualSignature, escapeQuotes: true, expectedValueSourcePath: callerPath, expectedValueSourceLine: callerLine); 100AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: false, expectedValueSourcePath: callerPath, expectedValueSourceLine: callerLine); 138AssertEx.SetEqual(expectedSynthesizedTypesAndMemberCounts, actual, itemSeparator: ",\r\n", itemInspector: s => $"\"{s}\""); 144AssertEx.SetEqual(expectedSynthesizedTypesAndMemberCounts, actual, itemSeparator: "\r\n"); 149AssertEx.Equal(

177AssertEx.Equal(expectedAssembliesAndAliases, actual, itemInspector: s => '"' + s + '"'); 185AssertEx.Equal(expectedAssembliesAndAliases, actual, itemInspector: s => '"' + s + '"'); 413AssertEx.Equal(positions, getPositionsFromEnd(separatedList)); 422AssertEx.Equal(positions, getPositionsFromStart(new SeparatedWithManyChildren(green, null, separatedList.Position))); 425AssertEx.Equal(positions, getPositionsFromEnd(new SeparatedWithManyChildren(green, null, separatedList.Position)));

40AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, escapeQuotes: false, expectedValueSourcePath: expectedValueSourcePath, expectedValueSourceLine: expectedValueSourceLine);

71AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedOperationTree, actual);

122AssertEx.Equal(operation.Operations, operation.ChildOperations); 128AssertEx.Equal(operation.Declarations, operation.ChildOperations); 143AssertEx.Equal(children, operation.ChildOperations); 157AssertEx.Equal(children, operation.ChildOperations); 165AssertEx.Equal(new[] { operation.Value }.Concat(operation.Cases), operation.ChildOperations); 172AssertEx.Equal(operation.Clauses.Concat(operation.Body), operation.ChildOperations); 217AssertEx.Equal(new[] { operation.Value }, operation.ChildOperations); 232AssertEx.Equal(new[] { operation.Value }, operation.ChildOperations); 285AssertEx.Equal(children, operation.ChildOperations); 305AssertEx.Equal(children, operation.ChildOperations); 326AssertEx.Equal(children, operation.ChildOperations); 335AssertEx.Equal(children, operation.ChildOperations); 422AssertEx.Equal(new[] { operation.LockedValue, operation.Body }, operation.ChildOperations); 436AssertEx.Equal(children, operation.ChildOperations); 457AssertEx.Equal(children, operation.ChildOperations); 464AssertEx.Equal(new[] { operation.Resources, operation.Body }, operation.ChildOperations); 484AssertEx.Equal(new[] { operation.Variables, operation.Body }, operation.ChildOperations); 490AssertEx.Equal(new[] { operation.Group, operation.Aggregation }, operation.ChildOperations); 502AssertEx.Equal(new[] { operation.Value, operation.Body }, operation.ChildOperations); 539AssertEx.Equal(children, operation.ChildOperations); 561AssertEx.Equal(children, operation.ChildOperations); 589AssertEx.Equal(new[] { operation.ArrayReference }.Concat(operation.Indices), operation.ChildOperations); 595AssertEx.Equal(new[] { operation.Instance, operation.Argument }, operation.ChildOperations); 658AssertEx.Equal(children, operation.ChildOperations); 705AssertEx.Equal(new[] { operation.EventReference, operation.HandlerValue }, operation.ChildOperations); 712AssertEx.Equal(new[] { operation.Operation, operation.WhenNotNull }, operation.ChildOperations); 772AssertEx.Equal(new[] { operation.LeftOperand, operation.RightOperand }, operation.ChildOperations); 803AssertEx.Fail($"Unexpected parameter count for built in method: {method.ToDisplayString()}"); 817AssertEx.Equal(new[] { operation.LeftOperand, operation.RightOperand }, operation.ChildOperations); 875AssertEx.Equal(new[] { operation.Condition, operation.WhenTrue, operation.WhenFalse }, operation.ChildOperations); 879AssertEx.Equal(new[] { operation.Condition, operation.WhenTrue }, operation.ChildOperations); 886AssertEx.Equal(new[] { operation.Value, operation.WhenNull }, operation.ChildOperations); 893AssertEx.Equal(new[] { operation.Target, operation.Value }, operation.ChildOperations); 1024AssertEx.Equal(children, operation.ChildOperations); 1030AssertEx.Equal(operation.Initializers, operation.ChildOperations); 1051AssertEx.Equal(children, operation.ChildOperations); 1057AssertEx.Equal(new[] { operation.Operation }.Concat(operation.Arguments), operation.ChildOperations); 1063AssertEx.Equal(new[] { operation.Operation }.Concat(operation.Arguments), operation.ChildOperations); 1069AssertEx.Equal(operation.Initializers, operation.ChildOperations); 1075AssertEx.Equal(new[] { operation.InitializedMember, operation.Initializer }, operation.ChildOperations); 1128AssertEx.Equal(children, operation.ChildOperations); 1135AssertEx.Equal(operation.ElementValues, operation.ChildOperations); 1140AssertEx.Equal(new[] { operation.Target, operation.Value }, operation.ChildOperations); 1260AssertEx.Equal(operation.Elements, operation.ChildOperations); 1266AssertEx.Equal(operation.Parts, operation.ChildOperations); 1297AssertEx.Equal(children, operation.ChildOperations); 1304AssertEx.Equal(children, operation.ChildOperations); 1314AssertEx.Equal(new[] { operation.Left, operation.Right }, operation.ChildOperations); 1456AssertEx.Equal(children, operation.ChildOperations); 1500AssertEx.Equal(children, operation.ChildOperations); 1507AssertEx.Equal(children, operation.ChildOperations); 1536AssertEx.Equal(children, operation.ChildOperations); 1550AssertEx.Equal(children, operation.ChildOperations); 1556AssertEx.Equal(new[] { operation.Value, operation.Pattern }, operation.ChildOperations); 1567AssertEx.Equal(new[] { operation.Pattern, operation.Guard }, operation.ChildOperations); 1602AssertEx.Equal(new IOperation[] { operation.EventReference }.Concat(operation.Arguments), operation.ChildOperations); 1609AssertEx.Equal(new[] { operation.MinimumValue, operation.MaximumValue }, operation.ChildOperations); 1635AssertEx.Equal(builder, operation.ChildOperations); 1648AssertEx.Equal(new[] { operation.BlockBody, operation.ExpressionBody }, operation.ChildOperations); 1767AssertEx.Equal(operation.Clauses, operation.ChildOperations); 1774AssertEx.Equal(SpecializedCollections.SingletonEnumerable(operation.Operand).Concat(operation.DimensionSizes), operation.ChildOperations); 1780AssertEx.Equal(SpecializedCollections.SingletonEnumerable(operation.DeclarationGroup), operation.ChildOperations); 1803AssertEx.Equal(children, operation.ChildOperations);

188VerifyTypeIL(typeName, output => AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, output, escapeQuotes: false)); 354AssertEx.AssertEqualToleratingWhitespaceDifferences(verification.ILVerifyMessage, actualMessage); 514actual.Add(AssertEx.NormalizeWhitespace(VisualizeIL(qualifiedName))); 515expected.Add(AssertEx.NormalizeWhitespace(qualifiedMethodNamesAndExpectedIL[i++])); 522builder.AppendLine(AssertEx.GetAssertMessage(expected[i], actual[i], prefix: names[i], escapeQuotes: true)); 546AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedSignature, actualSignature, escapeQuotes: true, expectedValueSourcePath: callerPath, expectedValueSourceLine: callerLine); 564AssertEx.AssertEqualToleratingWhitespaceDifferences(expectedIL, actualIL, message: null, escapeQuotes, callerPath, callerLine); 715AssertEx.SetEqual(expectedFields, members);

76AssertEx.Fail(output.ToStringAndFree()); 211AssertEx.Fail(output.ToStringAndFree()); 338AssertEx.Equal(expectedSnippets, actualSnippets, new SnippetComparer(), $"Validation of method {method} failed.");

470AssertEx.SetEqual(metadataReader.TypeDefinitions.Select(t => metadataReader.Dump(t)), types); 471AssertEx.SetEqual(metadataReader.MethodDefinitions.Select(t => metadataReader.Dump(t)), methods); 473AssertEx.SetEqual( 511AssertEx.Equal(ThrowNull, il); 522AssertEx.NotEqual(ThrowNull, il);

95AssertEx.Equal(expectedBlob, actualBlob); 126AssertEx.Equal(expectedBlob, actualBlob); 192AssertEx.AssertResultsEqual(mdw1.ToString(), mdw2.ToString());