202Assert.Contains(s, headers);

139Assert.Contains(expectedEvent, frebEvent);

139Assert.Contains(expectedEvent, frebEvent);

85Assert.All(new[] { "connectionId", "remoteEndPoint", "localEndPoint" }, p => Assert.Contains(p, connectionStart.PayloadNames)); 93Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, firstRequestStart.PayloadNames)); 102Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, firstRequestStop.PayloadNames)); 111Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, secondRequestStart.PayloadNames)); 120Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, secondRequestStop.PayloadNames)); 129Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionStop.PayloadNames)); 210Assert.All(new[] { "connectionId", "remoteEndPoint", "localEndPoint" }, p => Assert.Contains(p, connectionStart.PayloadNames)); 218Assert.All(new[] { "connectionId", "sslProtocols" }, p => Assert.Contains(p, tlsHandshakeStart.PayloadNames)); 226Assert.All(new[] { "connectionId", "sslProtocols", "applicationProtocol", "hostName" }, p => Assert.Contains(p, tlsHandshakeStop.PayloadNames)); 237Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, requestStart.PayloadNames)); 246Assert.All(new[] { "connectionId", "requestId" }, p => Assert.Contains(p, requestStop.PayloadNames)); 256Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionStop.PayloadNames)); 314Assert.All(new[] { "connectionId", "remoteEndPoint", "localEndPoint" }, p => Assert.Contains(p, connectionStart.PayloadNames)); 322Assert.All(new[] { "connectionId", "sslProtocols" }, p => Assert.Contains(p, tlsHandshakeStart.PayloadNames)); 330Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, tlsHandshakeFailed.PayloadNames)); 338Assert.All(new[] { "connectionId", "sslProtocols", "applicationProtocol", "hostName" }, p => Assert.Contains(p, tlsHandshakeStop.PayloadNames)); 346Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionStop.PayloadNames)); 395Assert.All(new[] { "connectionId", "remoteEndPoint", "localEndPoint" }, p => Assert.Contains(p, connectionStart.PayloadNames)); 403Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionRejected.PayloadNames)); 411Assert.All(new[] { "connectionId" }, p => Assert.Contains(p, connectionStop.PayloadNames));

838Assert.Contains(clientChain[0], chain.ChainPolicy.ExtraStore);

76Assert.Contains(actual.Id, ids);

544Assert.Contains("given_name", options.Scope); 545Assert.Contains("birthdate", options.Scope);

38Assert.Contains("dupe", combined.AuthenticationSchemes); 39Assert.Contains("roles", combined.AuthenticationSchemes); 88Assert.Contains("dupe", combined.AuthenticationSchemes); 89Assert.Contains("default", combined.AuthenticationSchemes);

54Assert.Contains("Parameter", parameters.Keys); 74Assert.Contains("Parameter", parameters.Keys); 116Assert.Contains("First", firstParameters.Keys); 124Assert.Contains("Second", secondParameters.Keys); 146Assert.Contains("First", firstParameters.Keys); 334Assert.Contains("First", firstParameters.Keys);

89Assert.Contains("/_blazor/negotiate", buildersAffected); 90Assert.Contains("/_blazor", buildersAffected); 91Assert.Contains("Blazor disconnect", buildersAffected); 92Assert.Contains("Blazor initializers", buildersAffected);

748Assert.Contains("RegularParameter", nestedComponent.LatestParameterView.Keys); 749Assert.Contains("CascadingParameter", nestedComponent.LatestParameterView.Keys); 750Assert.Contains("SingleDeliveryCascadingParameter", nestedComponent.LatestParameterView.Keys); 773Assert.Contains("RegularParameter", nestedComponent.LatestParameterView.Keys); 774Assert.Contains("CascadingParameter", nestedComponent.LatestParameterView.Keys);

346Assert.Contains(3, executionSequence); 347Assert.Contains(2, executionSequence); 348Assert.Contains(1, executionSequence); 349Assert.Contains(4, executionSequence);

2302Assert.Contains(exception1, aex.InnerExceptions); 2303Assert.Contains(exception2, aex.InnerExceptions); 3792Assert.Contains(exception1, renderer.HandledExceptions); 3793Assert.Contains(exception2, renderer.HandledExceptions); 3846Assert.Contains(exception1, renderer.HandledExceptions); 3847Assert.Contains(exception2, renderer.HandledExceptions); 4258Assert.Contains(exception1, aex.InnerExceptions); 4259Assert.Contains(exception2, aex.InnerExceptions); 4771Assert.Contains(errorThrowingComponentId, renderer.Batches.Last().DisposedComponentIDs);

31Assert.Contains("The Date property field must be a date.", validationMessages);

46Assert.Contains("The Some number field must be a number.", validationMessages);

189Assert.Contains("The Some number field is not valid.", validationMessages);

32Assert.Contains(HeaderNames.ContentEncoding, varyHeader.ToArray()); 75Assert.Contains(HeaderNames.ContentEncoding, varyHeader.ToArray()); 98Assert.Contains(HeaderNames.ContentEncoding, varyHeader.ToArray()); 121Assert.Contains(HeaderNames.ContentEncoding, varyHeader.ToArray()); 144Assert.Contains(HeaderNames.ContentEncoding, varyHeader.ToArray()); 167Assert.Contains(HeaderNames.ContentEncoding, varyHeader.ToArray()); 210Assert.Contains(HeaderNames.ContentEncoding, varyHeader.ToArray());

274Assert.Contains("extension", consentCookie.Extensions);

405Assert.Contains("extension", cookie.Extensions); 458Assert.Contains("ext", cookie.Extensions); 465Assert.Contains("ext", cookie.Extensions); 472Assert.Contains("ext", cookie.Extensions);

46Assert.Contains("in", CapturedHeaders.Keys); 89Assert.Contains("in", CapturedHeaders.Keys); 91Assert.Contains("another", CapturedHeaders.Keys); 134Assert.Contains("in", CapturedHeaders.Keys); 152Assert.Contains("in", CapturedHeaders.Keys); 195Assert.Contains("in", CapturedHeaders.Keys);

63Assert.Contains("simple", options.Extensions); 64Assert.Contains("key=value", options.Extensions); 70Assert.Contains("simple", cookie.Extensions); 71Assert.Contains("key=value", cookie.Extensions);

60Assert.Contains(value, copy.Extensions);

68Assert.Contains(expectedLog, testlogger.LogMessages);

67Assert.Contains($"User is currently locked out.", logger.LogMessages); 111Assert.Contains($"User is currently locked out.", logger.LogMessages); 840Assert.Contains("RefreshSignInAsync prevented because the user is not currently authenticated. Use SignInAsync instead for initial sign in.", logger.LogMessages); 877Assert.Contains("RefreshSignInAsync prevented because currently authenticated user has a different UserId. Use SignInAsync instead to change users.", logger.LogMessages); 1179Assert.Contains($"User failed to provide the correct password.", logger.LogMessages); 1302Assert.Contains(message, logger.LogMessages); 1356Assert.Contains(message, logger.LogMessages);

447Assert.Contains(route.Attribute, model.Attributes); 450Assert.Contains(route.Attribute, model.Attributes); 469Assert.Contains(route.Attribute, model.Attributes); 472Assert.Contains(route.Attribute, model.Attributes); 780Assert.Contains("PUT", methodConstraint.HttpMethods); 781Assert.Contains("PATCH", methodConstraint.HttpMethods); 804Assert.Contains("DELETE", methodConstraint.HttpMethods); 805Assert.Contains("HEAD", methodConstraint.HttpMethods); 829Assert.Contains("GET", methodConstraint.HttpMethods); 830Assert.Contains("POST", methodConstraint.HttpMethods); 831Assert.Contains("HEAD", methodConstraint.HttpMethods); 852Assert.Contains("GET", methodConstraint.HttpMethods); 853Assert.Contains("PUT", methodConstraint.HttpMethods); 854Assert.Contains("POST", methodConstraint.HttpMethods); 1218Assert.Contains(selectorModel.AttributeRouteModel.Attribute, actions.Attributes); 1221Assert.Contains(selectorModel.AttributeRouteModel.Attribute, actions.Attributes); 1240Assert.Contains(selectorModel.AttributeRouteModel.Attribute, action.Attributes); 1243Assert.Contains(selectorModel.AttributeRouteModel.Attribute, action.Attributes);

898Assert.Contains("test-parameter", arguments.Keys);

21Assert.Contains("application/json; charset=utf-16", collection);

365Assert.Contains(bindingContext.Result.Model, bindingContext.ValidationState.Keys);

25Assert.Contains(attribute1, metadata.ValidatorMetadata); // Copied by provider 26Assert.Contains(attribute2, metadata.ValidatorMetadata); // Copied by provider 34Assert.Contains(validators1[0], validators2); // Cached 35Assert.Contains(validators1[1], validators2); // Cached 52Assert.Contains(validator1.Attribute, metadata.ValidatorMetadata); // Copied by provider 53Assert.Contains(validator2.Attribute, metadata.ValidatorMetadata); // Copied by provider 82Assert.Contains(validator1.Attribute, parameter.ValidatorMetadata); // Copied by provider 83Assert.Contains(validator2.Attribute, parameter.ValidatorMetadata); // Copied by provider 102Assert.Contains(validator1.Attribute, property.ValidatorMetadata); // Copied by provider 103Assert.Contains(validator2.Attribute, property.ValidatorMetadata); // Copied by provider

317Assert.Contains(ValidationAttributeUtil.GetStringLengthErrorMessage(null, 5, "Street"), errorMessages); 318Assert.Contains(ValidationAttributeUtil.GetRegExErrorMessage("hehehe", "Street"), errorMessages); 349Assert.Contains(ValidationAttributeUtil.GetStringLengthErrorMessage(null, 5, "Street"), errorMessages); 350Assert.Contains(ValidationAttributeUtil.GetRegExErrorMessage("hehehe", "Street"), errorMessages);

25Assert.Contains(attribute1, metadata.ValidatorMetadata); // Copied by provider 26Assert.Contains(attribute2, metadata.ValidatorMetadata); // Copied by provider 34Assert.Contains(validators1[0], validators2); // Cached 35Assert.Contains(validators1[1], validators2); // Cached 52Assert.Contains(validator1.Attribute, metadata.ValidatorMetadata); // Copied by provider 53Assert.Contains(validator2.Attribute, metadata.ValidatorMetadata); // Copied by provider 62Assert.Contains(requiredValidator, validators1); // cached

116Assert.Contains("application/xml", formatter.SupportedMediaTypes 118Assert.Contains("text/xml", formatter.SupportedMediaTypes

313Assert.Contains("application/xml", formatter.SupportedMediaTypes 315Assert.Contains("text/xml", formatter.SupportedMediaTypes

24Assert.Contains("/PageRoute/Attribute/pagevalue", result.ExpectedUrls); 28Assert.Contains(

269Assert.Contains("/Home/Index", result.ExpectedUrls); 293Assert.Contains("/", result.ExpectedUrls); 327Assert.Contains("/Travel/Flight/Index", result.ExpectedUrls); 379Assert.Contains("/Store/Shop/Products", result.ExpectedUrls); 383Assert.Contains( 387Assert.Contains( 412Assert.Contains(url, result.ExpectedUrls); 416Assert.Contains( 420Assert.Contains( 426Assert.Contains( 640Assert.Contains("/Home/About", result.ExpectedUrls); 657Assert.Contains("/Blog/Edit/5", result.ExpectedUrls); 661Assert.Contains( 665Assert.Contains( 669Assert.Contains( 687Assert.Contains("/api/Employee", result.ExpectedUrls); 714Assert.Contains("/Store/Shop/Orders", result.ExpectedUrls); 739Assert.Contains("/api/Employee/5/Salary", result.ExpectedUrls); 759Assert.Contains("/Store/Shop/Orders", result.ExpectedUrls); 782Assert.Contains("/api/Employee", result.ExpectedUrls); 804Assert.Contains("/api/Employee/Manager", result.ExpectedUrls); 849Assert.Contains("/api/Employee/5", result.ExpectedUrls); 872Assert.Contains("/api/Employee/5/Administrator", result.ExpectedUrls); 876Assert.Contains( 893Assert.Contains("/Manager/5", result.ExpectedUrls); 897Assert.Contains( 914Assert.Contains("/Team/5", result.ExpectedUrls); 918Assert.Contains( 935Assert.Contains("/Teams", result.ExpectedUrls); 1497Assert.Contains(path, result.ExpectedUrls); 1549Assert.Contains(path, result.ExpectedUrls);

48Assert.Contains("/PageRoute/Attribute/pagevalue", result.ExpectedUrls); 52Assert.Contains(

56Assert.Contains("api/addresses", result.ExpectedUrls); 80Assert.Contains("/api/addresses/all?version=" + version, result.ExpectedUrls); 163Assert.Contains( 239Assert.Contains(

22Assert.Contains(assembly.Location, references); 23Assert.Contains(

140Assert.Contains("SOME_TEST_DEFINE", parseOptions.PreprocessorSymbolNames); 269Assert.Contains(define, syntaxTree.Options.PreprocessorSymbolNames);

148Assert.Contains(typeof(RouteAttribute), item.Item.Metadata.Select(m => m.GetType())); // Verify we pick up new attributes

441Assert.Contains(attribute, expectedTagHelperOutput.Attributes);

400Assert.Contains(page.Buffer, scope.ReturnedBuffers); // Buffer was returned

94Assert.Contains("controller", attribute.RouteData.Keys); 112Assert.Contains("action", attribute.RouteData.Keys); 131Assert.Contains("action", attribute.RouteData.Keys); 132Assert.Contains("controller", attribute.RouteData.Keys);

53Assert.Contains(schema.Discriminator.PropertyName, triangleSchema.Properties.Keys);

416Assert.Contains("application/x-www-form-urlencoded", content.Keys); 417Assert.Contains("multipart/form-data", content.Keys); 473Assert.Contains("application/x-www-form-urlencoded", content.Keys); 520Assert.Contains("application/x-www-form-urlencoded", content.Keys); 575Assert.Contains("application/x-www-form-urlencoded", content.Keys); 576Assert.Contains("multipart/form-data", content.Keys); 641Assert.Contains("application/x-www-form-urlencoded", content.Keys); 709Assert.Contains("application/x-www-form-urlencoded", content.Keys); 749Assert.Contains("application/x-www-form-urlencoded", content.Keys);

49Assert.Contains(expectedUri, servers.Select(s => s.Url)); 73Assert.Contains("http://localhost:5000", servers.Select(s => s.Url)); 97Assert.Contains("http://localhost:5000", servers.Select(s => s.Url)); 98Assert.Contains("http://localhost:5002", servers.Select(s => s.Url));

39Assert.Contains(schema.Discriminator.PropertyName, triangleSchema.Properties.Keys); 78Assert.Contains(schema.Discriminator.PropertyName, citySchema.Properties.Keys); 82Assert.Contains(schema.Discriminator.PropertyName, timeSeriesSchema.Properties.Keys); 86Assert.Contains(schema.Discriminator.PropertyName, newsSchema.Properties.Keys); 121Assert.Contains(schema.Discriminator.PropertyName, citySchema.Properties.Keys); 125Assert.Contains(schema.Discriminator.PropertyName, timeSeriesSchema.Properties.Keys); 157Assert.Contains("$type", paintSchema.Properties.Keys); 161Assert.Contains("$type", fabricSchema.Properties.Keys); 209Assert.Contains(schema.Discriminator.PropertyName, dogSchema.Properties.Keys); 213Assert.Contains(schema.Discriminator.PropertyName, catSchema.Properties.Keys); 217Assert.Contains(schema.Discriminator.PropertyName, petSchema.Properties.Keys);

222Assert.Contains("IdParameter", document.Components.Schemas.Keys); 223Assert.Contains("LimitParameter", document.Components.Schemas.Keys);

85Assert.Contains("HeaderA", (IEnumerable<string>)context.CacheVaryByRules.HeaderNames); 86Assert.Contains("HeaderC", (IEnumerable<string>)context.CacheVaryByRules.HeaderNames); 100Assert.Contains("QueryA", (IEnumerable<string>)context.CacheVaryByRules.QueryKeys); 101Assert.Contains("QueryC", (IEnumerable<string>)context.CacheVaryByRules.QueryKeys); 119Assert.Contains("RouteA", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames); 120Assert.Contains("RouteC", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames); 132Assert.Contains("Tag1", (IEnumerable<string>)context.Tags); 133Assert.Contains("Tag2", (IEnumerable<string>)context.Tags);

295Assert.Contains(new KeyValuePair<string, string>(key, value), context.CacheVaryByRules.VaryByValues);

115Assert.Contains("HeaderA", (IEnumerable<string>)context.CacheVaryByRules.HeaderNames); 116Assert.Contains("HeaderC", (IEnumerable<string>)context.CacheVaryByRules.HeaderNames); 131Assert.Contains("QueryA", (IEnumerable<string>)context.CacheVaryByRules.QueryKeys); 132Assert.Contains("QueryC", (IEnumerable<string>)context.CacheVaryByRules.QueryKeys); 151Assert.Contains("RouteA", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames); 152Assert.Contains("RouteC", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames); 171Assert.Contains("RouteA", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames); 172Assert.Contains("RouteC", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames); 191Assert.Contains("RouteA", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames); 192Assert.Contains("RouteC", (IEnumerable<string>)context.CacheVaryByRules.RouteValueNames);

28Assert.Contains(FallbackMetadata.Instance, endpoint.Metadata); 44Assert.Contains(FallbackMetadata.Instance, endpoint.Metadata);

768Assert.Contains(FallbackMetadata.Instance, routeEndpointBuilder.Metadata);

192Assert.Contains("test-metadata", metadata); 193Assert.Contains("found-previous-metadata", metadata);

40Assert.Contains(endpoint1, dataSource.Endpoints); 41Assert.Contains(endpoint2, dataSource.Endpoints); 84Assert.Contains(endpoint1, dataSource.Endpoints); 85Assert.Contains(endpoint2, dataSource.Endpoints);

257Assert.Contains(endpoint1, foundEndpoints);

190Assert.Contains(customHeader, requestHeaders.Keys); 191Assert.Contains(requestHeaders[customHeader].First(), requestHeaders.Keys); 192Assert.Contains(HeaderNames.Host, requestHeaders.Keys); 217Assert.Contains("X-UnknownHeader-0", requestHeaders.Keys); 218Assert.Contains("My-UnknownHeader-1", requestHeaders.Keys); 219Assert.Contains("X-UnknownHeader-2", requestHeaders.Keys); 220Assert.Contains(HeaderNames.Host, requestHeaders.Keys);

35Assert.Contains(HeaderNames.Host, requestHeaders.Keys); 36Assert.Contains(HeaderNames.ContentType, requestHeaders.Keys); 56Assert.Contains(HeaderNames.Host, requestHeaders.Keys); 57Assert.Contains(HeaderNames.ContentType, requestHeaders.Keys); 76Assert.Contains(CustomHeader1, requestHeaders.Keys); 77Assert.Contains(CustomHeader2, requestHeaders.Keys); 97Assert.Contains(CustomHeader1, requestHeaders.Keys); 98Assert.Contains(CustomHeader2, requestHeaders.Keys); 156Assert.Contains(HeaderNames.Host, requestHeaders.Keys); 157Assert.Contains(HeaderNames.ContentType, requestHeaders.Keys); 158Assert.Contains(CustomHeader1, requestHeaders.Keys); 159Assert.Contains(CustomHeader2, requestHeaders.Keys); 180Assert.Contains(HeaderNames.Host, requestHeaders.Keys); 181Assert.Contains(HeaderNames.ContentType, requestHeaders.Keys); 182Assert.Contains(CustomHeader1, requestHeaders.Keys); 183Assert.Contains(CustomHeader2, requestHeaders.Keys); 243Assert.Contains(CustomHeader1, requestHeaders.Keys); 244Assert.Contains(CustomHeader2, requestHeaders.Keys); 268Assert.Contains(CustomHeader2, requestHeaders.Keys); 328Assert.Contains(HeaderNames.Host, requestHeaders.Keys); 329Assert.Contains(HeaderNames.ContentType, requestHeaders.Keys); 353Assert.Contains(HeaderNames.From, requestHeaders.Keys);

1366Assert.Contains("*", options.AllowedHosts); 1378Assert.Contains("NewHost", options.AllowedHosts); 1992Assert.Contains("One", displayNames); 1993Assert.Contains("Two", displayNames); 1994Assert.Contains("Three", displayNames); 1995Assert.Contains("Four", displayNames); 1996Assert.Contains("Five", displayNames);

42Assert.Contains("*", options.AllowedHosts); 54Assert.Contains("NewHost", options.AllowedHosts);

895Assert.Contains("RoslynComponent", caps);

1896Assert.Contains("GOO", parsedArgs.ParseOptions.PreprocessorSymbolNames); 1901Assert.Contains("GOO", parsedArgs.ParseOptions.PreprocessorSymbolNames); 1902Assert.Contains("BAR", parsedArgs.ParseOptions.PreprocessorSymbolNames); 1903Assert.Contains("ZIP", parsedArgs.ParseOptions.PreprocessorSymbolNames); 1908Assert.Contains("GOO", parsedArgs.ParseOptions.PreprocessorSymbolNames);

81Assert.Contains(orderedCSharpArgumentProviders[i].Metadata.Name, orderedCSharpArgumentProviders[i - 1].Metadata.BeforeTyped);

113Assert.Contains(orderedCSharpCompletionProviders[i].Metadata.Name, orderedCSharpCompletionProviders[i - 1].Metadata.BeforeTyped);

22777Assert.Contains("ValueTuple`2, System, AssemblyReference:System.ValueTuple", reader.DumpTypeReferences()); 22786Assert.Contains("ValueTuple`2, System, AssemblyReference:System.ValueTuple", reader.DumpTypeReferences()); 22817Assert.Contains("ReferencedType, , AssemblyReference:lib", reader.DumpTypeReferences()); 22826Assert.Contains("ReferencedType, , AssemblyReference:lib", reader.DumpTypeReferences());

1464Assert.Contains(new SynthesizedDelegateKey("<>F{00000008}`3"), synthesizedDelegates0.Keys); 1465Assert.Contains(new SynthesizedDelegateKey("<>A{00000003}`2"), synthesizedDelegates0.Keys); 1466Assert.Contains(new SynthesizedDelegateKey("<>A{00000000,100000000}`33"), synthesizedDelegates0.Keys);

721Assert.Contains("CompilerGeneratedAttribute", attributeNames); 778Assert.Contains("CompilerGeneratedAttribute", attributeNames); 860Assert.Contains("CompilerGeneratedAttribute", attributeNames); 924Assert.Contains("CompilerGeneratedAttribute", attributeNames);

455Assert.Contains(enabledDiag, effectiveDiags); 466Assert.Contains(disabledDiag, effectiveDiags);

4996Assert.Contains("M", extensions.MemberNames); 5007Assert.Contains("M", extensions.MemberNames); 5331Assert.Contains(comp1MetadataReference, refs); 5360Assert.Contains(comp1MetadataReference, refs);

32744Assert.Contains(symbol, symbols); 32751Assert.Contains(decl.Identifier().ValueText, names); 32771Assert.Contains(symbol, referenceInfo.CandidateSymbols); 32773Assert.Contains(symbol, symbols);

12768Assert.Contains(comp1Ref, comp2.GetUsedAssemblyReferences()); 12776Assert.Contains(comp1Ref, comp4.GetUsedAssemblyReferences());

255Assert.Contains(symbol, symbols); 262Assert.Contains(designation.Identifier.ValueText, names); 306Assert.Contains(symbol, referenceInfo.CandidateSymbols); 308Assert.Contains(symbol, symbols);

1015Assert.Contains("X", model.LookupNames(x.SpanStart)); 1082Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1083Assert.Contains("X", model.LookupNames(x.SpanStart)); 1309Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1310Assert.Contains("X", model.LookupNames(x.SpanStart)); 1322Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "y")); 1323Assert.Contains("y", model.LookupNames(x.SpanStart)); 1332Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "Test")); 1333Assert.Contains("Test", model.LookupNames(x.SpanStart)); 1538Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1539Assert.Contains("X", model.LookupNames(x.SpanStart)); 1627Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1628Assert.Contains("X", model.LookupNames(x.SpanStart)); 1905Assert.Contains("X", model.LookupNames(x.SpanStart)); 1976Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 1977Assert.Contains("X", model.LookupNames(x.SpanStart)); 2650Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2651Assert.Contains("X", model.LookupNames(x.SpanStart)); 2688Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2689Assert.Contains("X", model.LookupNames(x.SpanStart)); 2725Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2726Assert.Contains("X", model.LookupNames(x.SpanStart)); 2761Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2762Assert.Contains("X", model.LookupNames(x.SpanStart)); 6863Assert.Contains("System.Int32 y", model.LookupSymbols(mCall.SpanStart).Select(s => s.ToTestDisplayString())); 7835Assert.Contains("p1", model.LookupNames(p1.SpanStart)); 8765Assert.Contains("p1", model.LookupNames(p1.SpanStart)); 8766Assert.Contains(symbol, model.LookupSymbols(p1.SpanStart, name: "p1")); 9171Assert.Contains("p1", model.LookupNames(p1.SpanStart)); 9172Assert.Contains(symbol, model.LookupSymbols(p1.SpanStart, name: "p1"));

21258Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21259Assert.Contains("X", model.LookupNames(x.SpanStart)); 21487Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21488Assert.Contains("X", model.LookupNames(x.SpanStart)); 21500Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "y")); 21501Assert.Contains("y", model.LookupNames(x.SpanStart)); 21510Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "Test")); 21511Assert.Contains("Test", model.LookupNames(x.SpanStart)); 21716Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21717Assert.Contains("X", model.LookupNames(x.SpanStart)); 21805Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 21806Assert.Contains("X", model.LookupNames(x.SpanStart)); 22077Assert.Contains("X", model.LookupNames(x.SpanStart)); 22192Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 22193Assert.Contains("X", model.LookupNames(x.SpanStart)); 24756Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24757Assert.Contains("X", model.LookupNames(x.SpanStart)); 24791Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24792Assert.Contains("X", model.LookupNames(x.SpanStart)); 24825Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24826Assert.Contains("X", model.LookupNames(x.SpanStart)); 24860Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 24861Assert.Contains("X", model.LookupNames(x.SpanStart)); 30504Assert.Contains("System.Int32 y", model.LookupSymbols(mCall.SpanStart).Select(s => s.ToTestDisplayString()));

17505Assert.Contains("MyEmbeddedType", module.TypeNames);

540Assert.Contains("P1", model.LookupNames(tree.GetRoot().DescendantNodes().OfType<ConstructorDeclarationSyntax>().Single().Body.Position)); 580Assert.Contains("P1", model.LookupNames(tree.GetRoot().DescendantNodes().OfType<DestructorDeclarationSyntax>().Single().Body.Position));

759Assert.Contains("System.Collections.Generic.KeyValuePair<TKey, TValue>..ctor(TKey key, TValue value)", symbolInfo.CandidateSymbols.Select(c => c.ToTestDisplayString()));

7640Assert.Contains(a, dataFlow.ReadInside); 8223Assert.Contains("C", names); 8224Assert.Contains("x", names); 8225Assert.Contains("y", names); 8226Assert.Contains("N1", names); 8227Assert.Contains("N2", names); 8228Assert.Contains("T1", names); 8229Assert.Contains("T2", names); 8230Assert.Contains("M1", names); 8231Assert.Contains("M2", names); 8232Assert.Contains("lam", names);

7673Assert.Contains(lookupFinds, lookupResults); 8706Assert.Contains($"System.Int32 {parameterName}", lookupResults);

222Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 223Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 224Assert.Contains(expected_in_lookupNames[1], actual_lookupNames); 225Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 325Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 326Assert.Contains(expected_in_lookupNames[1], actual_lookupNames); 328Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 329Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 379Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 380Assert.Contains(expected_in_lookupNames[1], actual_lookupNames); 381Assert.Contains(expected_in_lookupNames[2], actual_lookupNames); 383Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 384Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 385Assert.Contains(expected_in_lookupSymbols[2], actual_lookupSymbols_as_string); 457Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 458Assert.Contains(expected_in_lookupNames[1], actual_lookupNames); 459Assert.Contains(expected_in_lookupNames[2], actual_lookupNames); 460Assert.Contains(expected_in_lookupNames[3], actual_lookupNames); 461Assert.Contains(expected_in_lookupNames[4], actual_lookupNames); 462Assert.Contains(expected_in_lookupNames[5], actual_lookupNames); 464Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 465Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 466Assert.Contains(expected_in_lookupSymbols[2], actual_lookupSymbols_as_string); 467Assert.Contains(expected_in_lookupSymbols[3], actual_lookupSymbols_as_string); 468Assert.Contains(expected_in_lookupSymbols[4], actual_lookupSymbols_as_string); 469Assert.Contains(expected_in_lookupSymbols[5], actual_lookupSymbols_as_string); 527Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 530Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 531Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 596Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 599Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 600Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 601Assert.Contains(expected_in_lookupSymbols[2], actual_lookupSymbols_as_string); 602Assert.Contains(expected_in_lookupSymbols[3], actual_lookupSymbols_as_string); 735Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 736Assert.Contains(expected_in_lookupNames[1], actual_lookupNames); 737Assert.Contains(expected_in_lookupNames[2], actual_lookupNames); 739Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 740Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 741Assert.Contains(expected_in_lookupSymbols[2], actual_lookupSymbols_as_string); 786Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 787Assert.Contains(expected_in_lookupNames[1], actual_lookupNames); 790Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 791Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 835Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 836Assert.Contains(expected_in_lookupNames[1], actual_lookupNames); 837Assert.Contains(expected_in_lookupNames[2], actual_lookupNames); 839Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 840Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 841Assert.Contains(expected_in_lookupSymbols[2], actual_lookupSymbols_as_string); 952Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 953Assert.Contains(expected_in_lookupNames[1], actual_lookupNames); 955Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 956Assert.Contains(expected_in_lookupSymbols[1], actual_lookupSymbols_as_string); 995Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 996Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 1032Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 1033Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 1061Assert.Contains("w", lookupNames); 1062Assert.Contains("y", lookupNames); 1063Assert.Contains("System.Int32 Program.w", lookupSymbols); 1064Assert.Contains("System.Int32 y", lookupSymbols); 1091Assert.Contains("w", lookupNames); 1092Assert.Contains("y", lookupNames); 1093Assert.Contains("System.Int32 Program.w", lookupSymbols); 1094Assert.Contains("System.Int32 y", lookupSymbols); 1120Assert.Contains("w", lookupNames); 1121Assert.Contains("y", lookupNames); 1122Assert.Contains("System.Int32 Program.w", lookupSymbols); 1123Assert.Contains("System.Int32 y", lookupSymbols); 1158Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 1159Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 1196Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 1197Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 1231Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 1232Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 1355Assert.Contains(expected_in_lookupNames[0], actual_lookupNames); 1356Assert.Contains(expected_in_lookupSymbols[0], actual_lookupSymbols_as_string); 1539Assert.Contains(aliasY, actual_lookupSymbols); 2138Assert.Contains("C", names); 2139Assert.Contains("Attr1", names);

476Assert.Contains(member.Name, memberNames); 495Assert.Contains(member, allMembers); 521Assert.Contains(member.Name, memberNames); 536Assert.Contains(member, allMembers);

2674Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2675Assert.Contains("X", model.LookupNames(x.SpanStart)); 2709Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2710Assert.Contains("X", model.LookupNames(x.SpanStart)); 2743Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2744Assert.Contains("X", model.LookupNames(x.SpanStart)); 2778Assert.Contains(symbol, model.LookupSymbols(x.SpanStart, name: "X")); 2779Assert.Contains("X", model.LookupNames(x.SpanStart));

198Assert.Contains(refSymbol.Name, model1.LookupNames(localRef.SpanStart)); 199Assert.Contains(refSymbol, model1.LookupSymbols(localRef.SpanStart)); 241Assert.Contains(declSymbol.Name, model1.LookupNames(localDecl.SpanStart)); 242Assert.Contains(declSymbol, model1.LookupSymbols(localDecl.SpanStart)); 364Assert.Contains(declSymbol.Name, model2.LookupNames(localDecl.SpanStart)); 365Assert.Contains(declSymbol, model2.LookupSymbols(localDecl.SpanStart)); 485Assert.Contains(declSymbol.Name, model1.LookupNames(localDecl.SpanStart)); 486Assert.Contains(declSymbol, model1.LookupSymbols(localDecl.SpanStart)); 494Assert.Contains(declSymbol.Name, model1.LookupNames(localFuncRef.SpanStart)); 495Assert.Contains(declSymbol, model1.LookupSymbols(localFuncRef.SpanStart)); 537Assert.Contains(declSymbol.Name, model1.LookupNames(localDecl.SpanStart)); 538Assert.Contains(declSymbol, model1.LookupSymbols(localDecl.SpanStart)); 548Assert.Contains(declSymbol.Name, model1.LookupNames(localRef.SpanStart)); 549Assert.Contains(declSymbol, model1.LookupSymbols(localRef.SpanStart)); 577Assert.Contains(declSymbol.Name, model1.LookupNames(localDecl.SpanStart)); 578Assert.Contains(declSymbol, model1.LookupSymbols(localDecl.SpanStart)); 586Assert.Contains(declSymbol.Name, model1.LookupNames(localFuncRef.SpanStart)); 587Assert.Contains(declSymbol, model1.LookupSymbols(localFuncRef.SpanStart)); 590Assert.Contains(declSymbol, model1.AnalyzeDataFlow(localDecl.Ancestors().OfType<StatementSyntax>().First()).DataFlowsOut); 595Assert.Contains(refSymbol.Name, model1.LookupNames(localRef.SpanStart)); 596Assert.Contains(refSymbol, model1.LookupSymbols(localRef.SpanStart)); 1690Assert.Contains(getHashCode.Name, names); 1692Assert.Contains(getHashCode, symbols); 1695Assert.Contains("Test", names); 1697Assert.Contains(declSymbol, symbols); 1701Assert.Contains(testType, symbols); 1723Assert.Contains("Test", names); 1729Assert.Contains(testType, symbols); 1763Assert.Contains("Test", names); 1767Assert.Contains(declSymbol, symbols); 1771Assert.Contains(testType, symbols); 1863Assert.Contains(getHashCode.Name, names); 1865Assert.Contains(getHashCode, symbols); 1868Assert.Contains("Test", names); 1870Assert.Contains(declSymbol, symbols); 1874Assert.Contains(testType, symbols); 1891Assert.Contains("Test", names); 1897Assert.Contains(testType, symbols); 1931Assert.Contains("Test", names); 1935Assert.Contains(declSymbol, symbols); 1939Assert.Contains(testType, symbols); 2091Assert.Contains("Test", names); 2093Assert.Contains(declSymbol, symbols); 2097Assert.Contains(testType, symbols); 2108Assert.Contains("Test", names); 2112Assert.Contains(testType, symbols); 2144Assert.Contains("Test", names); 2148Assert.Contains(declSymbol, symbols); 2152Assert.Contains(testType, symbols); 2255Assert.Contains("Test", names); 2257Assert.Contains(declSymbol, symbols); 2261Assert.Contains(testType, symbols); 2274Assert.Contains("Test", names); 2278Assert.Contains(testType, symbols); 2310Assert.Contains("Test", names); 2314Assert.Contains(declSymbol, symbols); 2318Assert.Contains(testType, symbols); 2434Assert.Contains("Test", names); 2435Assert.Contains(testType, symbols); 2440Assert.Contains(testType, symbols); 2454Assert.Contains("Test", names); 2458Assert.Contains(testType, symbols); 2469Assert.Contains("Test", names); 2473Assert.Contains(testType, symbols); 2507Assert.Contains("Test", names); 2510Assert.Contains(testType, symbols); 2515Assert.Contains(testType, symbols); 3949Assert.Contains("args", names); 3952Assert.Contains(testType, symbols); 3963Assert.Contains("args", names); 3967Assert.Contains(parameter, symbols); 3971Assert.Contains(testType, symbols); 4003Assert.Contains("args", names); 4006Assert.Contains(testType, symbols); 4011Assert.Contains(testType, symbols); 4098Assert.Contains("args", names); 4101Assert.Contains(testType, symbols); 4133Assert.Contains("args", names); 4136Assert.Contains(testType, symbols); 4141Assert.Contains(testType, symbols); 6042Assert.Contains(declSymbol.Name, model1.LookupNames(localRef.SpanStart)); 6043Assert.Contains(declSymbol, model1.LookupSymbols(localRef.SpanStart));

3294Assert.Contains(WellKnownGeneratorInputs.Compilation, runResult.TrackedSteps.Keys); 3295Assert.Contains(WellKnownGeneratorInputs.AnalyzerConfigOptions, runResult.TrackedSteps.Keys); 3296Assert.Contains(WellKnownGeneratorInputs.ParseOptions, runResult.TrackedSteps.Keys); 3297Assert.Contains(WellKnownGeneratorInputs.AdditionalTexts, runResult.TrackedSteps.Keys); 3298Assert.Contains(WellKnownGeneratorInputs.MetadataReferences, runResult.TrackedSteps.Keys); 3301Assert.Contains("Syntax", runResult.TrackedSteps.Keys); 3304Assert.Contains(WellKnownGeneratorOutputs.SourceOutput, runResult.TrackedSteps.Keys); 3305Assert.Contains(WellKnownGeneratorOutputs.ImplementationSourceOutput, runResult.TrackedSteps.Keys); 3307Assert.Contains(WellKnownGeneratorOutputs.SourceOutput, runResult.TrackedOutputSteps.Keys); 3308Assert.Contains(WellKnownGeneratorOutputs.ImplementationSourceOutput, runResult.TrackedOutputSteps.Keys); 3340result => Assert.Contains(WellKnownGeneratorInputs.AdditionalTexts, result.TrackedSteps.Keys));

803Assert.Contains(t1, comp.SyntaxTrees);

4689Assert.Contains("Goo", model.LookupNames(position, paramType0)); 4690Assert.Contains("Goo", model.LookupNames(position, paramType1)); 4734Assert.Contains("Goo", model.LookupNames(position, paramType0)); 4735Assert.Contains("Goo", model.LookupNames(position, paramType1));

1777Assert.Contains(assemblyMetadata.GetAssembly().Identity, moduleReferences1);

3853Assert.Contains(extensionMethod.ReduceExtensionMethod().ISymbol, memberGroup);

1217Assert.Contains("A", namesInC); 1218Assert.Contains("B", namesInC); 1219Assert.Contains("C", namesInC); 1220Assert.Contains("System", namesInC); 1221Assert.Contains("Microsoft", namesInC); 1252Assert.Contains("X", namesInA); 1253Assert.Contains("Y", namesInA); 1254Assert.Contains("ToString", namesInA); 1286Assert.Contains("A", namesInC); 1287Assert.Contains("B", namesInC); 1288Assert.Contains("C", namesInC); 1289Assert.Contains("AM", namesInC); 1290Assert.Contains("BX", namesInC); 1291Assert.Contains("CM", namesInC); 1292Assert.Contains("System", namesInC); 1293Assert.Contains("Microsoft", namesInC); 1337Assert.Contains("M", names); 1338Assert.Contains("ToString", names); 1339Assert.Contains("ReferenceEquals", names); 1340Assert.Contains("GetHashCode", names); 1341Assert.Contains("GetType", names); 1342Assert.Contains("Equals", names); 1343Assert.Contains("MB", names); 1349Assert.Contains("ToString", names); 1350Assert.Contains("ReferenceEquals", names); 1351Assert.Contains("GetHashCode", names); 1352Assert.Contains("GetType", names); 1353Assert.Contains("Equals", names);

2010Assert.Contains(actualWinner, actualCandidates);

422Assert.Contains(destructor, lookupSymbols);

3785Assert.Contains("GetEnumerableDisposable2", symbols); 3786Assert.Contains("GetEnumerableDisposable1", symbols); 3873Assert.Contains(setMember, model.LookupSymbols(instance.Position, baseClass, includeReducedExtensionMethods: true)); 3965Assert.Contains(setMember, model.LookupSymbols(instance.Position, baseClass, includeReducedExtensionMethods: true));

756Assert.Contains(baseIndexers[0], hiddenMembers); 757Assert.Contains(baseIndexers[1], hiddenMembers); 827Assert.Contains(baseIndexers[0], overriddenMembers); 828Assert.Contains(baseIndexers[1], overriddenMembers);

304Assert.Contains(defInterface, classInterfacesConstructedFrom); 305Assert.Contains(refInterface, classInterfacesConstructedFrom); 593Assert.Contains(field.AssociatedSymbol, events);

589Assert.Contains(defInterface, classInterfacesConstructedFrom); 590Assert.Contains(refInterface, classInterfacesConstructedFrom);

138Assert.Contains(defInterface, classInterfacesConstructedFrom); 139Assert.Contains(refInterface, classInterfacesConstructedFrom);

3656Assert.Contains(classC, symbols); 3666Assert.Contains(classC, symbols); 3787Assert.Contains(classC, symbols);

449Assert.Contains("O", names); 468Assert.Contains("O", names);

8449Assert.Contains("void I1.M01()", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 8451Assert.Contains("void I1.M01()", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 8454Assert.Contains("void I1.M01()", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 8456Assert.Contains("void I1.M01()", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 8458Assert.Contains("M01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 13176Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13177Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13181Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13182Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13184Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 13262Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13263Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13267Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13268Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13270Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 13384Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13385Assert.Contains("System.Int32 I1.P01 { get; set; }", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 13389Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13390Assert.Contains("System.Int32 I1.P01 { get; set; }", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 13392Assert.Contains("P01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol())); 14094Assert.Contains("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupSymbols(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 14095Assert.Contains("event System.Action I1.E01", ((CSharpSemanticModel)model).LookupStaticMembers(node.SpanStart, m02.TypeParameters[0]).ToTestDisplayStrings()); 14099Assert.Contains("event System.Action I1.E01", model.LookupSymbols(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 14100Assert.Contains("event System.Action I1.E01", model.LookupStaticMembers(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()).ToTestDisplayStrings()); 14102Assert.Contains("E01", model.LookupNames(node.SpanStart, m02.TypeParameters[0].GetPublicSymbol()));

549Assert.Contains(error, nullableUnrelatedWarnings);

408Assert.Contains(i, actual); // no order

4920Assert.Contains(SyntaxKind.ExtensionKeyword, SyntaxFacts.GetContextualKeywordKinds());

1871Assert.Contains(reference, resolvedReferences);

570Assert.Contains(accessor, propertyOrEvent.ContainingType.GetMembers(accessor.Name));

42Assert.Contains(expectedGlyph, qi.Tags.GetGlyphs());

856Assert.Contains(fixer1.Title, txtDocumentCodeFixTitles); 857Assert.Contains(fixer2.Title, txtDocumentCodeFixTitles);

177Assert.Contains(refactoring1.Title, txtRefactoringTitles); 178Assert.Contains(refactoring2.Title, txtRefactoringTitles); 216Assert.Contains(refactoring1.Title, editorConfigRefactoringTitles); 217Assert.Contains(refactoring2.Title, editorConfigRefactoringTitles);

67Assert.Contains(unusedReference, unusedReferences); 102Assert.Contains(transitivelyUsedReference, unusedReferences); 147Assert.Contains(changeUpdate, appliedUpdates); 159Assert.Contains(changeUpdate, appliedUpdates);

111Assert.Contains(expectedSpan.Start, placeholderPositions);

918Assert.Contains(item, ReturnedItems);

1018Assert.Contains(VSDiagnosticTags.BuildError, results[0].Diagnostics!.Single().Tags!);

177Assert.Contains(documentPath, testLspServer.GetCurrentSolution().Projects.Single().Documents.Select(d => d.FilePath));

101Assert.Contains("(", testLspServer.GetServerCapabilities().SignatureHelpProvider!.TriggerCharacters!); 102Assert.Contains("<", testLspServer.GetServerCapabilities().SignatureHelpProvider!.TriggerCharacters!); 103Assert.Contains("{", testLspServer.GetServerCapabilities().SignatureHelpProvider!.TriggerCharacters!);

408Assert.Contains(operation.Kind, new[] { OperationKind.Return, OperationKind.YieldReturn, OperationKind.YieldBreak }); 580Assert.Contains(operation.ArgumentKind, new[] { ArgumentKind.DefaultValue, ArgumentKind.Explicit, ArgumentKind.ParamArray, ArgumentKind.ParamCollection }); 1200Assert.Contains(operation.Kind, new[] { OperationKind.Increment, OperationKind.Decrement });

128Assert.Contains("TestAnalyzer", analyzerNames); 129Assert.Contains("TestAnalyzerCS", analyzerNames); 130Assert.Contains("TestAnalyzerCSVB", analyzerNames); 131Assert.Contains("NestedAnalyzer", analyzerNames); 136Assert.Contains("TestAnalyzerVB", analyzerNames); 137Assert.Contains("TestAnalyzerCSVB", analyzerNames); 138Assert.Contains("TestAnalyzer", analyzerNames); 139Assert.Contains("NestedAnalyzer", analyzerNames); 157Assert.Contains("Microsoft.CodeAnalysis.UnitTests.AbstractAnalyzer", failedTypes); 158Assert.Contains("Microsoft.CodeAnalysis.UnitTests.OpenGenericAnalyzer`1", failedTypes);

95Assert.Contains(item, l2); 100Assert.Contains(item, l1);

49Assert.Contains(value, actual);

410Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 412Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 414Assert.Contains("CA1014", ruleSet.SpecificDiagnosticOptions.Keys); 416Assert.Contains("CA1015", ruleSet.SpecificDiagnosticOptions.Keys); 418Assert.Contains("CA1016", ruleSet.SpecificDiagnosticOptions.Keys); 477Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 502Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 504Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 530Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 532Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 558Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 560Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 587Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 589Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 625Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 627Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 663Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 665Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 667Assert.Contains("CA1014", ruleSet.SpecificDiagnosticOptions.Keys); 693Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 729Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 763Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 766Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 790Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 814Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 816Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 886Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 888Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys); 911Assert.Contains("CA1012", ruleSet.SpecificDiagnosticOptions.Keys); 913Assert.Contains("CA1013", ruleSet.SpecificDiagnosticOptions.Keys);

534Assert.Contains("LibraryHelperClass = Library.MyHelperClass", option.GlobalImports.Select(i => i.Name));

1644Assert.Contains("TRACE", options.PreprocessorSymbolNames); 1930Assert.Contains("EnableMyAttribute", options.PreprocessorSymbolNames);

118Assert.Contains(new ModifierKind(ModifierKindEnum.IsAsync), symbolSpec.RequiredModifierList); 227Assert.Contains(Accessibility.Private, symbolSpec.ApplicableAccessibilityList);

59Assert.Contains<string>(actualResult, expectedResults);

4393Assert.Contains(await frozenDocument.GetSyntaxTreeAsync(), (await frozenDocument.Project.GetCompilationAsync()).SyntaxTrees); 4427Assert.Contains(tree, (await frozen.Project.GetCompilationAsync()).SyntaxTrees);

273Assert.Contains(regularDocumentSyntaxTree, compilation.SyntaxTrees); 606Assert.Contains(generatedTree, compilation.SyntaxTrees); 653Assert.Contains(generatedTree, compilation.SyntaxTrees); 684Assert.Contains(generatedTree, compilationReference.Compilation.SyntaxTrees);

61Assert.Contains(value.ToLower(), items); 74Assert.Contains(value.ToLower(), items); 88Assert.Contains(value.ToLower(), items); 102Assert.Contains(value.ToLower(), items);

88Assert.Contains(i * 10 + j, values);

174Assert.Contains(item, T2); 178Assert.Contains(item, T1);

283 Assert.Throws<ArgumentNullException>("collection", () => Assert.Contains(14, default(IEnumerable<int>)!)); 291 Assert.Contains(null, list); 299 Assert.Contains(42, list); 307 var ex = Record.Exception(() => Assert.Contains(42, list)); 323 Assert.Contains("Hi there", list); 331 Assert.Contains("HI THERE", set); 340 Assert.Contains("HI THERE", set);

43Assert.Contains("truth_reason_incorrect_information", rating.TruthReasons); 44Assert.Contains("truth_reason_outdated_information", rating.TruthReasons); 45Assert.Contains("truth_reason_misleading_incorrectforintent", rating.TruthReasons); 47Assert.Contains("completeness_reason_no_solution", rating.CompletenessReasons); 48Assert.Contains("completeness_reason_genericsolution_missingcode", rating.CompletenessReasons); 121Assert.Contains("truth_reason_misleading_incorrectforintent", rating.TruthReasons); 123Assert.Contains("completeness_reason_no_solution", rating.CompletenessReasons); 276Assert.Contains("truth_reason_incorrect_information", rating.TruthReasons); 277Assert.Contains("truth_reason_outdated_information", rating.TruthReasons); 278Assert.Contains("truth_reason_misleading_incorrectforintent", rating.TruthReasons); 280Assert.Contains("completeness_reason_no_solution", rating.CompletenessReasons); 281Assert.Contains("completeness_reason_genericsolution_missingcode", rating.CompletenessReasons); 315Assert.Contains("truth_reason_incorrect_information", rating.TruthReasons); 316Assert.Contains("truth_reason_outdated_information", rating.TruthReasons); 317Assert.Contains("truth_reason_misleading_incorrectforintent", rating.TruthReasons); 319Assert.Contains("completeness_reason_no_solution", rating.CompletenessReasons); 320Assert.Contains("completeness_reason_genericsolution_missingcode", rating.CompletenessReasons);

124Assert.Contains(expectedDocumentPath, documentNames);

225entry => { Assert.Contains(entry.EventId, new[] { DefaultHealthCheckEventIds.HealthCheckBegin, DefaultHealthCheckEventIds.HealthCheckEnd }); }, 226entry => { Assert.Contains(entry.EventId, new[] { DefaultHealthCheckEventIds.HealthCheckBegin, DefaultHealthCheckEventIds.HealthCheckEnd }); }, 387Assert.Contains("CheckDefault", entries); 388Assert.Contains("CheckDelay1Period18", entries); 389Assert.Contains("CheckDelay1Period9", entries); 390Assert.Contains("CheckDelay1Period9_1", entries); 490entry => { Assert.Contains(entry.EventId, new[] { DefaultHealthCheckEventIds.HealthCheckBegin, DefaultHealthCheckEventIds.HealthCheckEnd }); }, 491entry => { Assert.Contains(entry.EventId, new[] { DefaultHealthCheckEventIds.HealthCheckBegin, DefaultHealthCheckEventIds.HealthCheckEnd }); }, 643Assert.Contains("CheckDelay1Period9", entries); 644Assert.Contains("CheckDelay1Period9_1", entries); 659Assert.Contains("CheckDelay1Period9", entries); 660Assert.Contains("CheckDelay1Period9_1", entries); 696entry => { Assert.Contains(entry.EventId, new[] { DefaultHealthCheckEventIds.HealthCheckBegin, DefaultHealthCheckEventIds.HealthCheckEnd }); }, 697entry => { Assert.Contains(entry.EventId, new[] { DefaultHealthCheckEventIds.HealthCheckBegin, DefaultHealthCheckEventIds.HealthCheckEnd }); },

199Assert.Contains(pooled, instances);

92Assert.Contains("Date must be between 2023-01-01 and 2025-12-31", error.Value); 97Assert.Contains("Amount must be between 0.1 and 100.5", error.Value); 102Assert.Contains("The TimeOnlyWithRequiredValue field is required.", error.Value); 107Assert.Contains("Hours must be between 0 and 12", error.Value); 112Assert.Contains("The field Url must be a valid URL.", error.Value); 117Assert.Contains("Must be a valid version number (e.g. 1.0.0)", error.Value);

441Assert.Contains("Password must be at least 8 characters.", context.ValidationErrors["Password"]); 442Assert.Contains("Password must contain at least one number and one special character.", context.ValidationErrors["Password"]);

37Assert.Contains(("Foo", (object?)"FooValue"), receiver.Received); 38Assert.Contains(("Bar", (object?)"BarValue"), receiver.Received);

37Assert.Contains(("Foo", (object?)"FooValue"), receiver.Received); 38Assert.Contains(("Bar", (object?)"BarValue"), receiver.Received);

70Assert.Contains("receiver.Receive(nameof(Foo), Foo);", statements); 71Assert.Contains("receiver.Receive(nameof(Bar), Bar);", statements);

66Assert.Contains("Label", columnNames); 67Assert.Contains("SamplingKey", columnNames); 68Assert.Contains("UserId", columnNames); 69Assert.Contains("MovieId", columnNames); 70Assert.Contains("GroupId", columnNames); 71Assert.Contains("Cat1", columnNames); 72Assert.Contains("Cat2", columnNames); 73Assert.Contains("Num", columnNames);

121Assert.Contains("Score", columnNames);

458Assert.Contains(1, ids); 459Assert.Contains(5, ids); 462Assert.Contains(4, ids); 463Assert.Contains(5, ids); 466Assert.Contains(0, ids); 467Assert.Contains(4, ids); 470Assert.Contains(5, ids); 471Assert.Contains(6, ids); 474Assert.Contains(4, ids); 475Assert.Contains(7, ids); 478Assert.Contains(1, ids); 479Assert.Contains(2, ids); 484Assert.Contains(1, ids); 485Assert.Contains(5, ids);

753Assert.Contains("SentimentText", outputSchema.Select(col => col.Name)); 754Assert.Contains("Label", outputSchema.Select(col => col.Name)); 755Assert.Contains("Features", outputSchema.Select(col => col.Name)); 756Assert.Contains("PredictedLabel", outputSchema.Select(col => col.Name)); 757Assert.Contains("Score", outputSchema.Select(col => col.Name));

275Assert.Contains(configName, optionsWithoutStorage);

656Assert.Contains("HandlerName", messageNames1.DocumentMessageHandlers); 657Assert.Contains("HandlerName", messageNames2.DocumentMessageHandlers);

41Assert.Contains(nameof(options.Name), results[0].MemberNames); 55Assert.Contains(nameof(options.Address), results[0].MemberNames); 62Assert.Contains(nameof(options.Address), results[0].MemberNames); 97Assert.Contains(nameof(options.Name), results[0].MemberNames); 111Assert.Contains(nameof(options.Address), results[0].MemberNames); 119Assert.Contains(nameof(options.Address), results[0].MemberNames); 170Assert.Contains(nameof(options.Names), results[0].MemberNames); 188Assert.Contains(nameof(options.Addresses), results[0].MemberNames); 224Assert.Contains(nameof(options.Names), results[0].MemberNames); 236Assert.Contains(nameof(options.Addresses), results[0].MemberNames); 277Assert.Contains(nameof(options.Names), results[0].MemberNames); 295Assert.Contains(nameof(options.Addresses), results[0].MemberNames);

39Assert.Contains(nameof(options.Time), results[0].MemberNames); 46Assert.Contains(nameof(options.Time), results[0].MemberNames); 64Assert.Contains(nameof(options.Time2), results[0].MemberNames); 104Assert.Contains(nameof(options.Time), results[0].MemberNames); 111Assert.Contains(nameof(options.Time), results[0].MemberNames); 125Assert.Contains(nameof(options.Time2), results[0].MemberNames); 132Assert.Contains(nameof(options.Time2), results[0].MemberNames); 167Assert.Contains(nameof(options.Time), results[0].MemberNames); 174Assert.Contains(nameof(options.Time), results[0].MemberNames); 192Assert.Contains(nameof(options.Time2), results[0].MemberNames);

103Assert.Contains(relativePath, expectedFiles);

115 Contains(expected, AssertHelper.ToEnumerable(collection));