13670 references to False
Analyzer.Utilities.UnitTests (1)
Options\SymbolNamesWithValueOptionTests.cs (1)
298Assert.False(contained);
Contract.Message.IntegrationTests (2)
MessageTests.4.0.0.cs (2)
41Assert.False(replyMessage.IsFault); 42Assert.False(replyMessage.IsEmpty);
Diagnostics.EFCore.FunctionalTests (1)
MigrationsEndPointMiddlewareTest.cs (1)
118Assert.False(databaseCreator.Exists());
dotnet-svcutil.xmlserializer.IntegrationTests (1)
SvcutilTests.cs (1)
22Assert.False(File.Exists(outputFile));
IIS.FunctionalTests (13)
Http2TrailersResetTests.cs (1)
264Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection));
src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (1)
99Assert.False(response.IsSuccessStatusCode);
src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (3)
182Assert.False(dataFrame.DataEndStream); 251Assert.False(dataFrame.DataEndStream); 296Assert.False(dataFrame.DataEndStream);
src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (1)
212Assert.False(response.IsSuccessStatusCode);
src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (2)
518Assert.False(response.Headers.TryGetValues("EmptyHeader", out var headerValues)); 805Assert.False(bytes0.IsEmpty);
src\Servers\IIS\IIS\test\IIS.Shared.FunctionalTests\StdOutRedirectionTests.cs (5)
45Assert.False(response.IsSuccessStatusCode); 69Assert.False(response.IsSuccessStatusCode); 99Assert.False(response.IsSuccessStatusCode); 126Assert.False(response.IsSuccessStatusCode); 152Assert.False(response.IsSuccessStatusCode);
IIS.LongTests (9)
src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (9)
178Assert.False(response.IsSuccessStatusCode); 214Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 748Assert.False(request.IsCompleted); 773Assert.False(result.IsSuccessStatusCode); 797Assert.False(result.IsSuccessStatusCode); 820Assert.False(result.IsSuccessStatusCode); 845Assert.False(result.IsSuccessStatusCode); 867Assert.False(result.IsSuccessStatusCode); 1061Assert.False(response.IsSuccessStatusCode);
IIS.NewHandler.FunctionalTests (9)
src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (9)
178Assert.False(response.IsSuccessStatusCode); 214Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 748Assert.False(request.IsCompleted); 773Assert.False(result.IsSuccessStatusCode); 797Assert.False(result.IsSuccessStatusCode); 820Assert.False(result.IsSuccessStatusCode); 845Assert.False(result.IsSuccessStatusCode); 867Assert.False(result.IsSuccessStatusCode); 1061Assert.False(response.IsSuccessStatusCode);
IIS.NewShim.FunctionalTests (9)
src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (9)
178Assert.False(response.IsSuccessStatusCode); 214Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 748Assert.False(request.IsCompleted); 773Assert.False(result.IsSuccessStatusCode); 797Assert.False(result.IsSuccessStatusCode); 820Assert.False(result.IsSuccessStatusCode); 845Assert.False(result.IsSuccessStatusCode); 867Assert.False(result.IsSuccessStatusCode); 1061Assert.False(response.IsSuccessStatusCode);
IIS.ShadowCopy.Tests (2)
ShadowCopyTests.cs (2)
306Assert.False(Directory.Exists(Path.Combine(deploymentResult.ContentRoot, "ShadowCopy", "0", "ShadowCopy"))); 336Assert.False(Directory.Exists(Path.Combine(deploymentResult.ContentRoot, "ShadowCopy", "0", "ShadowCopy")));
IIS.Tests (1)
HttpBodyControlFeatureTests.cs (1)
25Assert.False(bodyControl.AllowSynchronousIO);
IISExpress.FunctionalTests (16)
src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (1)
99Assert.False(response.IsSuccessStatusCode);
src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (3)
182Assert.False(dataFrame.DataEndStream); 251Assert.False(dataFrame.DataEndStream); 296Assert.False(dataFrame.DataEndStream);
src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (1)
212Assert.False(response.IsSuccessStatusCode);
src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (2)
518Assert.False(response.Headers.TryGetValues("EmptyHeader", out var headerValues)); 805Assert.False(bytes0.IsEmpty);
src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (9)
178Assert.False(response.IsSuccessStatusCode); 214Assert.False(File.Exists(Path.Combine(deploymentResult.ContentRoot, "hostfxr.dll"))); 748Assert.False(request.IsCompleted); 773Assert.False(result.IsSuccessStatusCode); 797Assert.False(result.IsSuccessStatusCode); 820Assert.False(result.IsSuccessStatusCode); 845Assert.False(result.IsSuccessStatusCode); 867Assert.False(result.IsSuccessStatusCode); 1061Assert.False(response.IsSuccessStatusCode);
InMemory.FunctionalTests (102)
BadHttpRequestTests.cs (3)
434Assert.False(badRequestEventListener.EventFired); 503Assert.False(badRequestEventListener.EventFired); 561Assert.False(badRequestEventListener.EventFired);
CertificateLoaderTests.cs (1)
54Assert.False(CertificateLoader.IsCertificateAllowedForServerAuth(cert));
ChunkedRequestTests.cs (2)
266Assert.False(request.Headers.ContainsKey("X-Trailer-Header")); 397Assert.False(request.Headers.ContainsKey("X-Trailer-Header"));
Http2\Http2ConnectionTests.cs (17)
2249Assert.False(_receivedHeaders.ContainsKey(header.Key)); 3273Assert.False(writeTasks[1].IsCompleted); 3305Assert.False(writeTasks[3].IsCompleted); 3376Assert.False(writeTasks[streamId].IsCompleted); 3385Assert.False(writeTasks[3].IsCompleted); 3386Assert.False(writeTasks[5].IsCompleted); 3390Assert.False(writeTasks[5].IsCompleted); 4044Assert.False(integerDecoder.BeginTryDecode((byte)(headerFrame.Payload.Span[0] & ~DynamicTableSizeUpdateMask), prefixLength: 5, out _)); 4045Assert.False(integerDecoder.TryDecode(headerFrame.Payload.Span[1], out _)); 4046Assert.False(integerDecoder.TryDecode(headerFrame.Payload.Span[2], out _)); 4164Assert.False(lifetime.ConnectionClosedRequested.IsCancellationRequested); 4295Assert.False(writeTasks[1].IsCompleted); 4383Assert.False(writeTasks[streamId].IsCompleted); 4611Assert.False(lastWriteTask.IsCompleted); 4880Assert.False(_receivedHeaders.ContainsKey("trailer-1")); 4881Assert.False(_receivedHeaders.ContainsKey("trailer-2")); 5194Assert.False(result.IsCompleted);
Http2\Http2StreamTests.cs (21)
188Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 239Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 480Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Scheme)); 1108Assert.False(requestDelegateCalled); 2051Assert.False(context.Features.Get<IHttpMaxRequestBodySizeFeature>().IsReadOnly); 2111Assert.False(context.Features.Get<IHttpMaxRequestBodySizeFeature>().IsReadOnly); 2311Assert.False(trailers.IsReadOnly); 3012Assert.False(dataTask.IsCompletedSuccessfully); 3456Assert.False(thrownExTask.IsCompleted); 3797Assert.False(context.Response.HasStarted); 4338Assert.False(goodResult.IsCanceled); 4871Assert.False(context.Response.Headers.IsReadOnly); 4872Assert.False(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5159Assert.False(startingTcs.Task.IsCompletedSuccessfully); // OnStarting did not get called. 5160Assert.False(context.Response.Headers.IsReadOnly); 5318Assert.False(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5389Assert.False(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 5464Assert.False(context.RequestAborted.CanBeCanceled); 5551Assert.False(context.RequestAborted.CanBeCanceled); 5638Assert.False(context.RequestAborted.CanBeCanceled); 5727Assert.False(context.RequestAborted.CanBeCanceled);
Http2\Http2TestBase.cs (3)
355Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Method)); 363Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Authority)); 371Assert.False(context.Request.Headers.ContainsKey(InternalHeaderNames.Path));
Http2\Http2WebSocketTests.cs (4)
26Assert.False(context.Request.Headers.TryGetValue(":protocol", out var _)); 82Assert.False(requestBodyDetectionFeature.CanHaveBody); 88Assert.False(context.Request.Headers.TryGetValue(":protocol", out var _)); 164Assert.False(context.Request.Headers.TryGetValue(":protocol", out var _));
Http3\Http3ConnectionTests.cs (2)
65Assert.False(requestStream.Disposed); 328Assert.False(lifetime.ConnectionClosedRequested.IsCancellationRequested);
Http3\Http3StreamTests.cs (15)
705Assert.False(requestDelegateCalled); 806Assert.False(goodResult.IsCanceled); 1248Assert.False(context.Response.Headers.IsReadOnly); 1249Assert.False(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 1488Assert.False(startingTcs.Task.IsCompletedSuccessfully); // OnStarting did not get called. 1489Assert.False(context.Response.Headers.IsReadOnly); 1609Assert.False(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 1667Assert.False(context.Features.Get<IHttpResponseTrailersFeature>().Trailers.IsReadOnly); 1725Assert.False(context.RequestAborted.CanBeCanceled); 1786Assert.False(context.RequestAborted.CanBeCanceled); 1848Assert.False(context.RequestAborted.CanBeCanceled); 1913Assert.False(context.RequestAborted.CanBeCanceled); 2681Assert.False(context.Features.Get<IHttpMaxRequestBodySizeFeature>().IsReadOnly); 2733Assert.False(context.Features.Get<IHttpMaxRequestBodySizeFeature>().IsReadOnly); 3094Assert.False(sendTask.IsCompleted);
Http3\WebTransport\WebTransportSessionTests.cs (2)
27Assert.False(streamDirectionFeature.CanRead); 58Assert.False(streamDirectionFeature2.CanWrite);
Http3\WebTransport\WebTransportStreamTests.cs (2)
30Assert.False(streamDirectionFeature.CanRead); 31Assert.False(streamDirectionFeature.CanWrite);
HttpsConnectionMiddlewareTests.cs (1)
1365Assert.False(CertificateLoader.DoesCertificateHaveASubjectAlternativeName(cert));
HttpsTests.cs (8)
58Assert.False(serverOptions.IsDevelopmentCertificateLoaded); 72Assert.False(serverOptions.IsDevelopmentCertificateLoaded); 131Assert.False(serverOptions.IsDevelopmentCertificateLoaded); 164Assert.False(serverOptions.IsDevelopmentCertificateLoaded); 268Assert.False(loggerProvider.ErrorLogger.ObjectDisposedExceptionLogged); 338Assert.False(loggerProvider.ErrorLogger.ObjectDisposedExceptionLogged); 542Assert.False(bindCalled); 577Assert.False(bindCalled);
KestrelMetricsTests.cs (1)
386Assert.False(m.Tags.ContainsKey("test"));
RequestTests.cs (7)
51Assert.False(requestBodyPersisted); 52Assert.False(responseBodyPersisted); 75Assert.False(responseBodyPersisted); 271Assert.False((await queryTcs.Task).ContainsKey("q")); 1689Assert.False(bodyControlFeature.AllowSynchronousIO); 1740Assert.False(bodyControlFeature.AllowSynchronousIO); 1788Assert.False(bodyControlFeature.AllowSynchronousIO);
ResponseTests.cs (9)
69Assert.False(onStartingCalled); 255Assert.False(goodResult.IsCanceled); 2651Assert.False(onStartingCalled); 2710Assert.False(callback1Called); 3335Assert.False(res); 3447Assert.False(httpContext.Response.HasStarted); 3607Assert.False(bodyControlFeature.AllowSynchronousIO); 3637Assert.False(bodyControlFeature.AllowSynchronousIO); 3703Assert.False(bodyControlFeature.AllowSynchronousIO);
TlsListenerTests.cs (1)
106Assert.False(tlsClientHelloCallbackInvoked);
UpgradeTests.cs (3)
167Assert.False(feature.IsUpgradableRequest); 238Assert.False(feature.IsUpgradableRequest); 274Assert.False(feature.IsUpgradableRequest);
InProcessWebSite (6)
Startup.cs (5)
1186Assert.False(ctx.Request.Headers.ContainsKey("Content-Length")); 1209Assert.False(context.Response.SupportsTrailers()); 1624Assert.False(feature?.IsUpgradableRequest ?? false); 1627Assert.False(httpContext.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 1638Assert.False(httpContext.Request.Headers.ContainsKey(HeaderNames.TransferEncoding));
Startup.WebSockets.cs (1)
30Assert.False(upgradeFeature.IsUpgradableRequest);
InteractiveHost.UnitTests (3)
InteractiveHostDesktopTests.cs (3)
304Assert.False(await Execute("new System.Data.DataSet()")); 312Assert.False(await Execute("new System.Data.DataSet()")); 332Assert.False(await Execute("new System.Data.DataSet()"));
Interop.FunctionalTests (4)
Http3\Http3RequestTests.cs (1)
1076Assert.False(request1Headers.ContainsKey("alt-used"));
Http3\Http3TlsTests.cs (2)
472Assert.False(ranConfigureKestrelAction); 473Assert.False(ranUseHttpsAction);
HttpClientHttp2InteropTests.cs (1)
571Assert.False(response.TrailingHeaders.TryGetValues("TestTrailer", out var none));
Microsoft.Analyzers.Local.Tests (35)
Json\JsonArrayTest.cs (2)
108Assert.False(obj.Contains("b")); 110Assert.False(obj.Contains(JsonValue.Null));
Json\JsonObjectTest.cs (4)
33Assert.False(obj.Remove("x")); 48Assert.False(obj.ContainsKey("x")); 91Assert.False(obj.ContainsKey("z")); 94Assert.False(obj.ContainsKey("x"));
Json\JsonParseExceptionTest.cs (1)
18Assert.False(string.IsNullOrEmpty(ex.Message));
Json\JsonValueTest.cs (28)
21Assert.False(new JsonValue(false).AsBoolean); 23Assert.False(new JsonValue(default(bool?)).IsBoolean); 24Assert.False(new JsonValue(default(bool?)).AsBoolean); 30Assert.False(new JsonValue(default(double?)).IsNumber); 38Assert.False(new JsonValue(default(string)).IsString); 45Assert.False(new JsonValue(default(JsonObject)).IsJsonObject); 52Assert.False(new JsonValue(default(JsonArray)).IsJsonArray); 62Assert.False(new JsonValue(false).IsInteger); 64Assert.False(new JsonValue(1.1).IsInteger); 65Assert.False(new JsonValue(double.PositiveInfinity).IsInteger); 71Assert.False(new JsonValue(false).IsDateTime); 72Assert.False(new JsonValue("Some text").IsDateTime); 79Assert.False(new JsonValue(false).AsBoolean); 80Assert.False(new JsonValue(0.0).AsBoolean); 81Assert.False(new JsonValue(string.Empty).AsBoolean); 82Assert.False(new JsonValue(default(JsonObject)).AsBoolean); 231Assert.False((bool)new JsonValue(false)); 232Assert.False((bool)new JsonValue(0.0)); 233Assert.False((bool)new JsonValue(string.Empty)); 234Assert.False((bool)new JsonValue(default(JsonObject))); 237Assert.False((bool)new JsonValue(1.0)); 238Assert.False((bool)new JsonValue("text")); 239Assert.False((bool)new JsonValue(new JsonObject())); 240Assert.False((bool)new JsonValue(new JsonArray())); 311Assert.False(JsonValue.Null != default); 323Assert.False(new JsonValue(true).Equals(new JsonValue(false))); 325Assert.False(JsonValue.Null.Equals(1)); 326Assert.False(JsonValue.Null.Equals(new InvalidOperationException()));
Microsoft.AspNetCore.Analyzers.Test (11)
MinimalStartupTest.cs (5)
180Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); 215Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); 269Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); 544Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); 600Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));
StartupAnalyzerTest.cs (3)
292Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); 340Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); 409Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));
StartupFactsTest.cs (3)
152Assert.False(result); 197Assert.False(result); 233Assert.False(result);
Microsoft.AspNetCore.Antiforgery.Test (24)
AntiforgeryApplicationBuilderExtensionsTest.cs (3)
21Assert.False(builder.Properties.ContainsKey("__AntiforgeryMiddlewareSet")); 40Assert.False(builder.Properties.ContainsKey("__AntiforgeryMiddlewareSet")); 42Assert.False(builder.Properties.ContainsKey("__AntiforgeryMiddlewareSet"));
AntiforgeryTokenTest.cs (2)
52Assert.False(token.IsCookieToken); 60Assert.False(token.IsCookieToken);
DefaultAntiforgeryTest.cs (5)
387Assert.False(hasWarningMessage); 441Assert.False(hasWarningMessage); 620Assert.False(result); 1303Assert.False(hasWarningMessage); 1376Assert.False(hasWarningMessage);
DefaultAntiforgeryTokenGeneratorTest.cs (14)
37Assert.False(httpContext.User.Identity.IsAuthenticated); 57Assert.False(httpContext.User.Identity.IsAuthenticated); 69Assert.False(fieldToken.IsCookieToken); 134Assert.False(fieldToken.IsCookieToken); 169Assert.False(fieldToken.IsCookieToken); 202Assert.False(fieldToken.IsCookieToken); 225Assert.False(isValid); 241Assert.False(isValid); 329Assert.False(result); 356Assert.False(result); 381Assert.False(result); 421Assert.False(result); 459Assert.False(result); 496Assert.False(result);
Microsoft.AspNetCore.App.Analyzers.Test (2)
Infrastructure\AmbiguousRoutePatternComparerTests.cs (1)
74Assert.False(result);
RouteEmbeddedLanguage\RoutePatternCompletionProviderTests.cs (1)
38Assert.False(result.ShouldTriggerCompletion);
Microsoft.AspNetCore.AsyncState.Tests (1)
AsyncContextHttpContextOfTTests.cs (1)
61Assert.False(_context.TryGet(out Thing? stored));
Microsoft.AspNetCore.Authentication.Core.Test (12)
AuthenticationPropertiesTests.cs (6)
106Assert.False(props.Items.ContainsKey("doesntexist")); 169Assert.False(props.IsPersistent); 176Assert.False(props.IsPersistent); 248Assert.False(props.Items.ContainsKey("foo")); 251Assert.False(props.Items.ContainsKey("doesnotexist")); 283Assert.False(props.Items.ContainsKey("foo"));
AuthenticationSchemeProviderTests.cs (3)
168Assert.False(o.TryAddScheme(new AuthenticationScheme("signin", "whatever", typeof(Handler)))); 170Assert.False(o.TryAddScheme(new AuthenticationScheme("signin2", "whatever", typeof(Handler)))); 215Assert.False(provider.TryAddScheme(scheme1));
AuthenticationTicketTests.cs (1)
42Assert.False(copy.Principal.HasClaim("name", "value"));
TokenExtensionTests.cs (2)
114Assert.False(props.UpdateTokenValue("ONE", ".11")); 115Assert.False(props.UpdateTokenValue("Jigglypuff", ".11"));
Microsoft.AspNetCore.Authentication.Negotiate.Test (5)
EventTests.cs (2)
33Assert.False(context.Response.Headers.ContainsKey(HeaderNames.WWWAuthenticate)); 294Assert.False(result.Response.Headers.ContainsKey(HeaderNames.WWWAuthenticate));
NegotiateHandlerTests.cs (2)
172Assert.False(result.Response.Headers.ContainsKey(HeaderNames.WWWAuthenticate)); 297Assert.False(result.Response.Headers.ContainsKey(HeaderNames.WWWAuthenticate));
ServerDeferralTests.cs (1)
21Assert.False(options.DeferToServer);
Microsoft.AspNetCore.Authentication.Test (43)
AuthenticationMetricsTest.cs (3)
40Assert.False(measurement.Tags.ContainsKey("error.type")); 96Assert.False(measurement.Tags.ContainsKey("error.type")); 125Assert.False(measurement.Tags.ContainsKey("aspnetcore.authentication.result"));
AuthenticationMiddlewareTests.cs (5)
171Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); 172Assert.False(app.Properties.ContainsKey("__AuthorizationMiddlewareSet")); 191Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); 192Assert.False(app.Properties.ContainsKey("__AuthorizationMiddlewareSet")); 197Assert.False(app.Properties.ContainsKey("__AuthorizationMiddlewareSet"));
FacebookTests.cs (2)
408Assert.False(string.IsNullOrEmpty(entries["code_verifier"])); 446Assert.False(string.IsNullOrEmpty(queryParams["code_challenge"]));
GoogleTests.cs (7)
76Assert.False(queryParams.ContainsKey("access_type")); 77Assert.False(queryParams.ContainsKey("prompt")); 78Assert.False(queryParams.ContainsKey("approval_prompt")); 79Assert.False(queryParams.ContainsKey("login_hint")); 80Assert.False(queryParams.ContainsKey("include_granted_scopes")); 1047Assert.False(string.IsNullOrEmpty(entries["code_verifier"])); 1079Assert.False(string.IsNullOrEmpty(queryParams["code_challenge"]));
JwtBearerTests.cs (4)
139Assert.False(jwtHandler.MapInboundClaims); 140Assert.False(tokenHandler.MapInboundClaims); 148Assert.False(options.MapInboundClaims); 153Assert.False(jwtHandler.MapInboundClaims);
JwtBearerTests_Handler.cs (7)
130Assert.False(jwtHandler.MapInboundClaims); 131Assert.False(tokenHandler.MapInboundClaims); 139Assert.False(options.MapInboundClaims); 144Assert.False(jwtHandler.MapInboundClaims); 985Assert.False(jwtBearerOptions.RequireHttpsMetadata); 1091Assert.False(jwtBearerOptions.TokenValidationParameters.ValidateIssuer); 1092Assert.False(jwtBearerOptions.TokenValidationParameters.ValidateAudience);
MicrosoftAccountTests.cs (2)
314Assert.False(string.IsNullOrEmpty(entries["code_verifier"])); 346Assert.False(string.IsNullOrEmpty(queryParams["code_challenge"]));
OpenIdConnect\OpenIdConnectChallengeTests.cs (2)
245Assert.False(actualProperties.Items.ContainsKey(OpenIdConnectDefaults.UserstatePropertiesKey)); 453Assert.False(StringSegment.IsNullOrEmpty(correlationCookie.Value));
OpenIdConnect\OpenIdConnectEventTests.cs (2)
1041Assert.False(response.Headers.TryGetValues(HeaderNames.SetCookie, out var values)); 1067Assert.False(response.Headers.TryGetValues(HeaderNames.SetCookie, out var values));
OpenIdConnect\OpenIdConnectEventTests_Handler.cs (2)
1041Assert.False(response.Headers.TryGetValues(HeaderNames.SetCookie, out var values)); 1067Assert.False(response.Headers.TryGetValues(HeaderNames.SetCookie, out var values));
OpenIdConnect\OpenIdConnectTests.cs (5)
396Assert.False(options.MapInboundClaims); 401Assert.False(jwtHandler.MapInboundClaims); 453Assert.False(options.RequireHttpsMetadata); 454Assert.False(options.GetClaimsFromUserInfoEndpoint); // Assert default values are respected 485Assert.False(options.CorrelationCookie.IsEssential);
TokenExtensionTests.cs (2)
110Assert.False(props.UpdateTokenValue("ONE", ".11")); 111Assert.False(props.UpdateTokenValue("Jigglypuff", ".11"));
Microsoft.AspNetCore.Authorization.Test (63)
AuthorizationMetricsTest.cs (10)
60Assert.False((bool)measurement.Tags["aspnetcore.user.is_authenticated"]); 85Assert.False((bool)measurement.Tags["aspnetcore.user.is_authenticated"]); 86Assert.False(measurement.Tags.ContainsKey("aspnetcore.authorization.result")); 113Assert.False((bool)measurement.Tags["aspnetcore.user.is_authenticated"]); 114Assert.False(measurement.Tags.ContainsKey("aspnetcore.authorization.policy")); 138Assert.False((bool)measurement.Tags["aspnetcore.user.is_authenticated"]); 139Assert.False(measurement.Tags.ContainsKey("aspnetcore.authorization.policy")); 167Assert.False((bool)measurement.Tags["aspnetcore.user.is_authenticated"]); 168Assert.False(measurement.Tags.ContainsKey("aspnetcore.authorization.policy")); 169Assert.False(measurement.Tags.ContainsKey("aspnetcore.authorization.result"));
AuthorizationMiddlewareTests.cs (16)
59Assert.False(next.Called); 99Assert.False(next.Called); 142Assert.False(next.Called); 164Assert.False(next.Called); 186Assert.False(next.Called); 580Assert.False(authenticationService.ChallengeCalled); 601Assert.False(authenticationService.ChallengeCalled); 622Assert.False(next.Called); 718Assert.False(next.Called); 719Assert.False(authenticationService.ChallengeCalled); 740Assert.False(next.Called); 763Assert.False(next.Called); 764Assert.False(authenticationService.ChallengeCalled); 985Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); 986Assert.False(app.Properties.ContainsKey("__AuthorizationMiddlewareSet")); 990Assert.False(app.Properties.ContainsKey("__AuthenticationMiddlewareSet"));
DefaultAuthorizationServiceTests.cs (26)
110Assert.False(allowed.Succeeded); 137Assert.False(allowed.Succeeded); 188Assert.False(allowed.Succeeded); 217Assert.False(allowed.Succeeded); 239Assert.False(allowed.Succeeded); 260Assert.False(allowed.Succeeded); 279Assert.False(allowed.Succeeded); 293Assert.False(allowed.Succeeded); 308Assert.False(allowed.Succeeded); 456Assert.False(allowed.Succeeded); 476Assert.False(allowed.Succeeded); 504Assert.False(allowed.Succeeded); 619Assert.False(allowed.Succeeded); 652Assert.False(allowed.Succeeded); 769Assert.False(allowed.Succeeded); 796Assert.False(allowed.Succeeded); 900Assert.False((await authorizationService.AuthorizeAsync(user, 1, Operations.Edit)).Succeeded); 922Assert.False((await authorizationService.AuthorizeAsync(user, 1, Operations.Edit)).Succeeded); 938Assert.False((await authorizationService.AuthorizeAsync(user, new ExpenseReport(), Operations.Delete)).Succeeded); 939Assert.False((await authorizationService.AuthorizeAsync(user, new ExpenseReport(), Operations.Create)).Succeeded); 954Assert.False((await authorizationService.AuthorizeAsync(user, null, Operations.Edit)).Succeeded); 1031Assert.False(allowed.Succeeded); 1068Assert.False((await authorizationService.AuthorizeAsync(user, "0")).Succeeded); 1071Assert.False((await authorizationService.AuthorizeAsync(user, "3")).Succeeded); 1128Assert.False((await authorizationService.AuthorizeAsync(null, "Success")).Succeeded); 1147Assert.False((await authorizationService.AuthorizeAsync(null, "Success")).Succeeded);
PassThroughAuthorizationHandlerTests.cs (1)
44Assert.False(allowed.Succeeded);
PolicyEvaluatorTests.cs (10)
27Assert.False(result.Succeeded); 81Assert.False(result.Challenged); 82Assert.False(result.Forbidden); 99Assert.False(result.Succeeded); 115Assert.False(result.Succeeded); 117Assert.False(result.Forbidden); 132Assert.False(result.Succeeded); 133Assert.False(result.Challenged); 152Assert.False(result.Succeeded); 153Assert.False(result.Challenged);
Microsoft.AspNetCore.Components.Authorization.Tests (2)
AuthorizeRouteViewTest.cs (2)
220Assert.False(firstRenderTask.IsCompleted); 264Assert.False(firstRenderTask.IsCompleted);
Microsoft.AspNetCore.Components.Endpoints.Tests (38)
Binding\FormDataMetadataFactoryTests.cs (6)
56Assert.False(metadata.IsRecursive); 66Assert.False(property.PropertyMetadata.IsRecursive); 94Assert.False(property.PropertyMetadata.IsRecursive); 439Assert.False(property.PropertyMetadata.IsRecursive); 476Assert.False(property.PropertyMetadata.IsRecursive); 496Assert.False(metadata.IsRecursive);
Binding\PrefixResolverTests.cs (4)
31Assert.False(result); 79Assert.False(result); 113Assert.False(result); 154Assert.False(result);
Buffering\BufferedTextWriterTest.cs (4)
42Assert.False(flushAsyncTask1.IsCompleted); 49Assert.False(flushAsyncTask2.IsCompleted); 56Assert.False(flushAsyncTask3.IsCompleted); 63Assert.False(flushAsyncTask2.IsCompleted);
Buffering\TextChunkPageTest.cs (1)
25Assert.False(page.TryAdd(new TextChunk("Item4")));
EndpointHtmlRendererTest.cs (6)
751Assert.False(state.OnAfterRenderRan); 1018Assert.False(isBadRequest); 1093Assert.False(result.QuiescenceTask.IsCompleted); 1101Assert.False(isBadRequest); 1136Assert.False(isBadRequest); 1178Assert.False(isBadRequest);
FormMapping\Converters\NullableConverterTests.cs (5)
55Assert.False(returnValue); 74Assert.False(found); 148Assert.False(returnValue); 196Assert.False(result.Value.WasEmptyOrNull); 212Assert.False(returnValue);
HotReloadServiceTests.cs (1)
35Assert.False(invoked);
RazorComponentResultTest.cs (4)
112Assert.False(completionTask.IsCompleted); 198Assert.False(completionTask.IsCompleted); 346Assert.False(initialOutputTask.IsCompleted); 379Assert.False(initialOutputTask.IsCompleted);
WebRootComponentParametersTest.cs (7)
21Assert.False(result); 35Assert.False(result); 49Assert.False(result); 63Assert.False(result); 113Assert.False(result); 127Assert.False(result); 155Assert.False(result);
Microsoft.AspNetCore.Components.Forms.Tests (22)
EditContextDataAnnotationsExtensionsTest.cs (4)
43Assert.False(isValid); 70Assert.False(editContext.Validate()); 89Assert.False(editContext.Validate()); 174Assert.False(editContext.Validate());
EditContextTest.cs (15)
40Assert.False(editContext.IsModified()); 59Assert.False(editContext.IsModified(fieldOnThisModel2)); 80Assert.False(editContext.IsModified(fieldThatWasModified)); 82Assert.False(editContext.IsModified(fieldThatWasNeverModified)); 99Assert.False(editContext.IsModified()); 100Assert.False(editContext.IsModified(field1)); 101Assert.False(editContext.IsModified(field2)); 210Assert.False(isValid); 232Assert.False(isValid); 249Assert.False(editContext.Validate()); 250Assert.False(editContext.IsValid(fieldOnThisModel1)); 305Assert.False(editContext.Properties.TryGetValue(key1, out _)); 316Assert.False(editContext.Properties.TryGetValue(key3, out _)); 334Assert.False(resultForNonExistingKey); 335Assert.False(editContext.Properties.TryGetValue(key, out _));
FieldIdentifierTest.cs (3)
62Assert.False(fieldIdentifier1.Equals(fieldIdentifier2)); 75Assert.False(fieldIdentifier1.Equals(fieldIdentifier2)); 130Assert.False(fieldIdentifierLower.Equals(fieldIdentifierPascal));
Microsoft.AspNetCore.Components.QuickGrid.Tests (1)
GridRaceConditionTest.cs (1)
91Assert.False(testJsRuntime.JsModuleDisposed);
Microsoft.AspNetCore.Components.Server.Tests (45)
Circuits\CircuitActivitySourceTest.cs (1)
58Assert.False(activity.IsStopped);
Circuits\CircuitHostTest.cs (6)
287Assert.False(reportedErrors.Single().IsTerminating); 390Assert.False(asyncLocal1.Value); 391Assert.False(asyncLocal3.Value); 472Assert.False(result); 499Assert.False(result); 520Assert.False(await circuitHost.SendPersistedStateToClient(rootComponents, applicationState, cancellationToken));
Circuits\CircuitRegistryTest.cs (10)
83Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId, out _)); 268Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out _)); 324Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out _)); 376Assert.False(circuitPersistenceProvider.PersistCalled); 377Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out _)); 407Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out _)); 434Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out var _)); 465Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out var _)); 484Assert.False(persistenceProvider.PersistCalled); 561Assert.False(persistenceProvider.PersistCalled);
Circuits\ComponentHubTest.cs (1)
176Assert.False(lastCircuit.HasPendingPersistedCircuitState);
Circuits\RemoteJSDataStreamTest.cs (9)
41Assert.False(success); 110Assert.False(success); 238Assert.False(success); 287Assert.False(success); 301Assert.False(linkedCts.HasLinkedCancellationTokenSource); 302Assert.False(linkedCts.Token.IsCancellationRequested); 316Assert.False(linkedCts.HasLinkedCancellationTokenSource); 317Assert.False(linkedCts.Token.IsCancellationRequested); 331Assert.False(linkedCts.Token.IsCancellationRequested);
Circuits\RevalidatingServerAuthenticationStateProviderTest.cs (5)
50Assert.False(didNotifyAuthenticationStateChanged); 71Assert.False(newAuthState.User.Identity.IsAuthenticated); 95Assert.False(newAuthState.User.Identity.IsAuthenticated); 159Assert.False(firstRevalidationCall.CancellationToken.IsCancellationRequested); 212Assert.False(newAuthState.User.Identity.IsAuthenticated);
Circuits\ServerComponentDeserializerTest.cs (12)
163Assert.False(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors)); 177Assert.False(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors)); 189Assert.False(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors)); 205Assert.False(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors)); 220Assert.False(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors)); 235Assert.False(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors)); 270Assert.False(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors)); 287Assert.False(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors)); 302Assert.False(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors)); 376Assert.False(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(markers[0], out _)); 391Assert.False(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(firstInvocationMarkers[0], out _)); 422Assert.False(result);
ProtectedBrowserStorageTest.cs (1)
160Assert.False(result.Success);
Microsoft.AspNetCore.Components.Tests (94)
BindConverterTest.cs (2)
326Assert.False(successfullyConverted); 368Assert.False(successfullyConverted);
CascadingParameterStateTest.cs (1)
374Assert.False(hasSingleDeliveryParameters);
ComponentBaseTest.cs (3)
245Assert.False(renderTask.IsCompleted); 289Assert.False(firstRender); 336Assert.False(firstRender);
ComponentFactoryTest.cs (1)
133Assert.False(renderer.ResolverWasCalled);
ComponentsActivitySourceTest.cs (2)
64Assert.False(activity.IsStopped); 101Assert.False(activity.IsStopped);
EventCallbackFactoryTest.cs (18)
24Assert.False(callback.RequiresExplicitReceiver); 40Assert.False(callback.RequiresExplicitReceiver); 58Assert.False(callback.RequiresExplicitReceiver); 107Assert.False(callback.RequiresExplicitReceiver); 125Assert.False(callback.RequiresExplicitReceiver); 174Assert.False(callback.RequiresExplicitReceiver); 192Assert.False(callback.RequiresExplicitReceiver); 226Assert.False(callback.RequiresExplicitReceiver); 259Assert.False(callback.RequiresExplicitReceiver); 311Assert.False(callback.RequiresExplicitReceiver); 327Assert.False(callback.RequiresExplicitReceiver); 345Assert.False(callback.RequiresExplicitReceiver); 394Assert.False(callback.RequiresExplicitReceiver); 412Assert.False(callback.RequiresExplicitReceiver); 461Assert.False(callback.RequiresExplicitReceiver); 479Assert.False(callback.RequiresExplicitReceiver); 528Assert.False(callback.RequiresExplicitReceiver); 546Assert.False(callback.RequiresExplicitReceiver);
NavigationManagerTest.cs (17)
283Assert.False(navigation1.IsCompleted); 341Assert.False(navigation1.Result); 372Assert.False(navigation1.Result); 408Assert.False(navigation1.Result); 412Assert.False(isHandlerCompleted); 447Assert.False(navigation1.Result); 451Assert.False(isFirstHandlerCompleted); 452Assert.False(isSecondHandlerCompleted); 457Assert.False(isSecondHandlerCompleted); 489Assert.False(navigation1Result); 524Assert.False(navigation1.Result); 580Assert.False(navigation1.Result); 641Assert.False(navigation1.Result); 644Assert.False(navigation2.Result); 699Assert.False(navigation1Result); 849Assert.False(currentContext.CancellationToken.IsCancellationRequested); 858Assert.False(navigation1Result);
OwningComponentBaseTest.cs (1)
47Assert.False(component1.IsDisposedPublic);
ParameterViewTest.cs (4)
123Assert.False(didFind); 422Assert.False(hasRemovedDirectParameters); 443Assert.False(hasRemovedDirectParameters); 568Assert.False(hasRemovedDirectParameters);
PersistentState\PersistentComponentStateTest.cs (4)
78Assert.False(applicationState.TryTakeFromJson<byte[]>("MyState", out var gone)); 170Assert.False(applicationState.TryTakeFromJson<byte[]>("MyState", out _)); 188Assert.False(applicationState.TryTakeFromJson<byte[]>("MyState", out _)); 226Assert.False(callbackInvoked);
PersistentState\RestoreContextTest.cs (3)
27Assert.False(result); 63Assert.False(result); 90Assert.False(result);
RendererTest.cs (25)
188Assert.False(renderTask.IsCompleted); 325Assert.False(renderTask1.IsCompleted); 334Assert.False(renderTask1.IsCompleted); 335Assert.False(renderTask2.IsCompleted); 343Assert.False(renderTask1.IsCompleted); 344Assert.False(renderTask2.IsCompleted); 382Assert.False(renderTask.IsCompleted); 2066Assert.False(batch.DiffsByComponentId.ContainsKey(nestedComponentFrame.ComponentId)); 2211Assert.False(renderer.Batches[1].DiffsByComponentId.ContainsKey(childComponentId)); 2300Assert.False(component.Disposed); 2336Assert.False(component.Disposed); 2370Assert.False(component.Disposed); 2410Assert.False(component.Disposed); 2415Assert.False(semaphore.WaitOne(10)); 2454Assert.False(component.Disposed); 2494Assert.False(component.Disposed); 2532Assert.False(component.Disposed); 2602Assert.False(component.Disposed); 3675Assert.False(renderTask.IsCompleted); 3787Assert.False(renderTask.IsCompleted); 4310Assert.False(disposed); 4311Assert.False(disposal.IsCompleted); 4888Assert.False(nestedComponent.Disposed); 5000Assert.False(hotReloadManager.IsSubscribedTo); 5027Assert.False(hotReloadManager.IsSubscribedTo);
Rendering\RendererSynchronizationContextTest.cs (7)
96Assert.False(e2.IsSet); 150Assert.False(e2.IsSet); 192Assert.False(e2.IsSet); 451Assert.False(e2.IsSet); 540Assert.False(e2.IsSet); 633Assert.False(e2.IsSet); 722Assert.False(e2.IsSet);
Rendering\RenderTreeBuilderTest.cs (1)
2161Assert.False(frame.ComponentFrameFlags.HasFlag(ComponentFrameFlags.HasCallerSpecifiedRenderMode));
ResourceAssetCollectionTest.cs (1)
88Assert.False(isContentSpecificUrl1);
Routing\RouteKeyTest.cs (4)
41Assert.False(key1.Equals(key2)); 53Assert.False(key1.Equals(key2)); 89Assert.False(key1.Equals(key2)); 101Assert.False(key1.Equals(key2));
Microsoft.AspNetCore.Components.Web.Tests (2)
Forms\InputBaseTest.cs (1)
190Assert.False(rootComponent.EditContext.IsModified(() => model.StringProperty));
HtmlRendering\HtmlRendererTest.cs (1)
874Assert.False(quiescenceTask.IsCompleted);
Microsoft.AspNetCore.Components.WebAssembly.Server.Tests (4)
ContentEncodingNegotiatorTests.cs (4)
51Assert.False(httpContext.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var selectedEncoding)); 52Assert.False(httpContext.Response.Headers.TryGetValue(HeaderNames.Vary, out var varyHeader)); 186Assert.False(httpContext.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var selectedEncoding)); 187Assert.False(httpContext.Response.Headers.TryGetValue(HeaderNames.Vary, out var varyHeader));
Microsoft.AspNetCore.ConcurrencyLimiter.Tests (20)
MiddlewareTests.cs (4)
72Assert.False(task1.IsCompleted); 76Assert.False(task2.IsCompleted); 94Assert.False(task1.IsCompleted); 222Assert.False(_getResultCalled);
PolicyTests\QueuePolicyTests.cs (4)
22Assert.False(t3.IsCompleted); 32Assert.False(waitingTask.IsCompleted); 53Assert.False(t3.IsCompleted); 57Assert.False(t4.Result);
PolicyTests\StackPolicyTests.cs (12)
26Assert.False(task2.IsCompleted); 48Assert.False(task2.IsCompleted); 50Assert.False(task3.IsCompleted); 52Assert.False(task4.IsCompleted); 55Assert.False(task5.IsCompleted); 58Assert.False(await task2); 60Assert.False(task3.IsCompleted); 61Assert.False(task4.IsCompleted); 80Assert.False(task3.IsCompleted); 96Assert.False(task2.IsCompleted); 120Assert.False(task1.IsCompleted); 126Assert.False(task2.IsCompleted);
Microsoft.AspNetCore.CookiePolicy.Test (41)
CookieConsentTests.cs (41)
24Assert.False(feature.IsConsentNeeded); 25Assert.False(feature.HasConsent); 44Assert.False(feature.HasConsent); 45Assert.False(feature.CanTrack); 63Assert.False(feature.HasConsent); 64Assert.False(feature.CanTrack); 80Assert.False(context.HasConsent); 81Assert.False(context.IssueCookie); 89Assert.False(feature.HasConsent); 90Assert.False(feature.CanTrack); 108Assert.False(feature.HasConsent); 109Assert.False(feature.CanTrack); 184Assert.False(feature.HasConsent); 185Assert.False(feature.CanTrack); 204Assert.False(feature.HasConsent); 205Assert.False(feature.CanTrack); 255Assert.False(feature.HasConsent); 256Assert.False(feature.CanTrack); 320Assert.False(feature.HasConsent); 321Assert.False(feature.CanTrack); 353Assert.False(feature.HasConsent); 354Assert.False(feature.CanTrack); 359Assert.False(feature.HasConsent); 360Assert.False(feature.CanTrack); 391Assert.False(feature.HasConsent); 392Assert.False(feature.CanTrack); 439Assert.False(feature.HasConsent); 440Assert.False(feature.CanTrack); 478Assert.False(feature.HasConsent); 479Assert.False(feature.CanTrack); 504Assert.False(feature.HasConsent); 505Assert.False(feature.CanTrack); 528Assert.False(context.HasConsent); 538Assert.False(feature.HasConsent); 539Assert.False(feature.CanTrack); 559Assert.False(feature.HasConsent); 560Assert.False(feature.CanTrack); 612Assert.False(feature.HasConsent); 613Assert.False(feature.CanTrack); 657Assert.False(feature.HasConsent); 658Assert.False(feature.CanTrack);
Microsoft.AspNetCore.Cors.Test (36)
CorsPolicyBuilderTests.cs (19)
28Assert.False(corsPolicy.AllowAnyHeader); 29Assert.False(corsPolicy.AllowAnyMethod); 30Assert.False(corsPolicy.AllowAnyOrigin); 58Assert.False(corsPolicy.AllowAnyHeader); 59Assert.False(corsPolicy.AllowAnyMethod); 60Assert.False(corsPolicy.AllowAnyOrigin); 76Assert.False(corsPolicy.AllowAnyHeader); 77Assert.False(corsPolicy.AllowAnyMethod); 78Assert.False(corsPolicy.AllowAnyOrigin); 79Assert.False(corsPolicy.SupportsCredentials); 100Assert.False(corsPolicy.AllowAnyHeader); 101Assert.False(corsPolicy.AllowAnyMethod); 102Assert.False(corsPolicy.AllowAnyOrigin); 103Assert.False(corsPolicy.SupportsCredentials); 122Assert.False(corsPolicy.AllowAnyOrigin); 214Assert.False(corsPolicy.IsOriginAllowed("http://example.com")); 228Assert.False(corsPolicy.AllowAnyOrigin); 258Assert.False(corsPolicy.AllowAnyHeader); 330Assert.False(corsPolicy.SupportsCredentials);
CorsPolicyExtensionsTests.cs (2)
40Assert.False(actual); 79Assert.False(isAllowed);
CorsPolicyTests.cs (5)
15Assert.False(corsPolicy.AllowAnyHeader); 16Assert.False(corsPolicy.AllowAnyMethod); 17Assert.False(corsPolicy.AllowAnyOrigin); 18Assert.False(corsPolicy.SupportsCredentials); 38Assert.False(policy.IsDefaultIsOriginAllowed);
CorsResultTests.cs (1)
18Assert.False(result.SupportsCredentials);
CorsServiceTests.cs (8)
44Assert.False(result.VaryByOrigin); 60Assert.False(result.IsOriginAllowed); 75Assert.False(result.IsOriginAllowed); 94Assert.False(result.IsOriginAllowed); 150Assert.False(result.SupportsCredentials); 186Assert.False(result.VaryByOrigin); 203Assert.False(result.VaryByOrigin); 934Assert.False(result.IsOriginAllowed);
UriHelpersTests.cs (1)
27Assert.False(isSubdomain);
Microsoft.AspNetCore.Cryptography.Internal.Tests (5)
CryptoUtilTests.cs (2)
29Assert.False(CryptoUtil.TimeConstantBuffersAreEqual(a.AsSpan(1, 3), b.AsSpan(2, 3))); 51Assert.False(CryptoUtil.TimeConstantBuffersAreEqual((byte*)&a, (byte*)&b, sizeof(uint)));
WeakReferenceHelpersTests.cs (3)
28Assert.False(newInstance.HasBeenDisposed); 46Assert.False(newInstance.HasBeenDisposed); 70Assert.False(instanceThatWillBeCreatedFirst.HasBeenDisposed);
Microsoft.AspNetCore.DataProtection.Tests (48)
ActivatorTests.cs (1)
31Assert.False(retVal3.ParameterlessCtorCalled);
ContainerUtilsTests.cs (1)
38Assert.False(ContainerUtils.IsDirectoryMounted(new DirectoryInfo(directory), fstab));
Internal\KeyManagementOptionsPostSetupTest.cs (1)
159Assert.False(options.AutoGenerateKeys);
KeyManagement\CacheableKeyRingTests.cs (3)
14Assert.False(CacheableKeyRing.IsValid(null, DateTime.UtcNow)); 29Assert.False(CacheableKeyRing.IsValid(cacheableKeyRing, now.UtcDateTime)); 43Assert.False(CacheableKeyRing.IsValid(cacheableKeyRing, now.AddHours(1).UtcDateTime));
KeyManagement\DefaultKeyResolverTests.cs (8)
43Assert.False(resolution.ShouldGenerateNewKey); 59Assert.False(resolution.ShouldGenerateNewKey); 74Assert.False(resolution.ShouldGenerateNewKey); 89Assert.False(resolution.ShouldGenerateNewKey); // Does not reflect pending expiration 106Assert.False(resolution.ShouldGenerateNewKey); // Does not reflect pending expiration 153Assert.False(resolution.ShouldGenerateNewKey); 185Assert.False(resolution.ShouldGenerateNewKey); 274Assert.False(resolution.ShouldGenerateNewKey);
KeyManagement\DeferredKeyTests.cs (1)
53Assert.False(key.IsRevoked);
KeyManagement\KeyRingBasedDataProtectorTests.cs (3)
503Assert.False(requiresMigration); 504Assert.False(wasRevoked); 554Assert.False(wasRevoked);
KeyManagement\KeyRingProviderTests.cs (7)
51Assert.False(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 94Assert.False(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 144Assert.False(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 233Assert.False(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 317Assert.False(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 355Assert.False(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 393Assert.False(CacheableKeyRing.IsValid(cacheableKeyRing, now));
KeyManagement\KeyRingTests.cs (2)
85Assert.False(isRevoked); 88Assert.False(isRevoked);
KeyManagement\KeyTests.cs (1)
43Assert.False(key.IsRevoked);
KeyManagement\XmlKeyManagerTests.cs (16)
115Assert.False(firstCancellationToken.IsCancellationRequested); 126Assert.False(secondCancellationToken.IsCancellationRequested); 134Assert.False(newKey.IsRevoked); 213Assert.False(firstCancellationToken.IsCancellationRequested); 224Assert.False(secondCancellationToken.IsCancellationRequested); 232Assert.False(newKey.IsRevoked); 376Assert.False(keys[0].IsRevoked); 382Assert.False(keys[1].IsRevoked); 454Assert.False(keys[2].IsRevoked); 641Assert.False(firstCancellationToken.IsCancellationRequested); 648Assert.False(secondCancellationToken.IsCancellationRequested); 691Assert.False(firstCancellationToken.IsCancellationRequested); 701Assert.False(secondCancellationToken.IsCancellationRequested); 968Assert.False(keyDictWithRevocations[key4.KeyId].IsRevoked); 979Assert.False(keyDictWithRevocations[key4.KeyId].IsRevoked); 997Assert.False(withoutDeletion.CanDeleteKeys);
Repositories\FileSystemXmlRepositoryTests.cs (3)
217Assert.False(repository.DeleteElements(deletableElements => 242Assert.False(File.Exists(filePath3)); // Deleted before error 273Assert.False(File.Exists(filePath));
ServiceCollectionTests.cs (1)
91Assert.False(options.AutoGenerateKeys);
Microsoft.AspNetCore.DeveloperCertificates.XPlat.Tests (2)
CertificateManagerTests.cs (2)
54Assert.False(exportedCertificate.HasPrivateKey); 220Assert.False(exportedCertificate.HasPrivateKey);
Microsoft.AspNetCore.Diagnostics.HealthChecks.Tests (1)
HealthCheckMiddlewareTests.cs (1)
469Assert.False(response.Content.Headers.Contains(HeaderNames.Expires));
Microsoft.AspNetCore.Diagnostics.Middleware.Tests (13)
Latency\RequestLatencyTelemetryMiddlewareTests.cs (2)
74Assert.False(httpContextMock.Response.Headers.TryGetValue(TelemetryConstants.ServerApplicationNameHeader, out var val)); 133Assert.False(httpContextMock.Response.Headers.TryGetValue(TelemetryConstants.ServerApplicationNameHeader, out var val));
Logging\AcceptanceTests.Mvc.cs (1)
232Assert.False(response.IsSuccessStatusCode);
Logging\IncomingHttpRouteUtilityTests.cs (7)
142Assert.False(sensitiveParameters.ContainsKey("chatId")); 229Assert.False(sensitiveParameters.ContainsKey("userId")); 230Assert.False(sensitiveParameters.ContainsKey("teamId")); 231Assert.False(sensitiveParameters.ContainsKey("chatId")); 270Assert.False(sensitiveParameters.ContainsKey("userId")); 271Assert.False(sensitiveParameters.ContainsKey("teamId")); 272Assert.False(sensitiveParameters.ContainsKey("chatId"));
Logging\RequestHeadersEnricherTests.cs (3)
136Assert.False(enrichedState.ContainsKey(NormalizedHeaderKey2)); 162Assert.False(enrichedState.ContainsKey(NormalizedHeaderKey3)); 188Assert.False(enrichedState.ContainsKey(HttpLoggingTagNames.RequestHeaderPrefix + headerKey2));
Microsoft.AspNetCore.Diagnostics.Tests (7)
DeveloperExceptionPageMiddlewareTest.cs (1)
631Assert.False(measurement.Tags.ContainsKey("aspnetcore.diagnostics.handler.type"));
ExceptionHandlerMiddlewareTest.cs (2)
274Assert.False(httpContext.Items.ContainsKey("3")); 583Assert.False(measurement.Tags.ContainsKey("aspnetcore.diagnostics.handler.type"));
ExceptionHandlerTest.cs (4)
194Assert.False(response.Headers.TryGetValues("ETag", out values)); 250Assert.False(response.Headers.TryGetValues("ETag", out values)); 374Assert.False(response.Headers.TryGetValues("Expires", out _)); 375Assert.False(response.Headers.TryGetValues("ETag", out _));
Microsoft.AspNetCore.FunctionalTests (1)
WebApplicationFunctionalTests.cs (1)
130Assert.False(logger.IsEnabled(LogLevel.Warning));
Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests (8)
HttpRoutePatternParserTests.cs (8)
34Assert.False(v.HasCatchAllPath); 41Assert.False(v.HasCatchAllPath); 64Assert.False(v.HasCatchAllPath); 156Assert.False(v.HasCatchAllPath); 175Assert.False(v.HasCatchAllPath); 214Assert.False(v.HasCatchAllPath); 235Assert.False(v.HasCatchAllPath); 298Assert.False(v.HasCatchAllPath);
Microsoft.AspNetCore.Grpc.Swagger.Tests (1)
Binding\ResponseBodyTests.cs (1)
90Assert.False(enumSchema.AdditionalPropertiesAllowed);
Microsoft.AspNetCore.HeaderParsing.Tests (36)
HeaderKeyTests.cs (2)
41Assert.False(referenceTimeDefault.HasDefaultValue); 44Assert.False(valueTypeDefault.HasDefaultValue);
HeaderParsingFeatureTests.cs (4)
109Assert.False(feature.TryGetHeaderValue(key, out var value, out var _)); 144Assert.False(feature.TryGetHeaderValue(key, out var value, out var result)); 172Assert.False(helper.Feature.TryGetHeaderValue(firstHeaderKey, out _)); 173Assert.False(helper.Feature.TryGetHeaderValue(thirdHeaderKey, out _));
HeaderRegistryTests.cs (1)
34Assert.False(key.HasDefaultValue);
HostHeaderValueTests.cs (7)
33Assert.False(differentHost.Equals((object)host1)); 34Assert.False(differentPort.Equals((object)host1)); 35Assert.False(differentPort.Equals(new object())); 50Assert.False(host1 == differentHost); 51Assert.False(host1 == differentPort); 53Assert.False(host1 != sameAsHost1); 84Assert.False(HostHeaderValue.TryParse(string.Empty, out var _));
ParserTests.cs (22)
32Assert.False(string.IsNullOrEmpty(error)); 55Assert.False(string.IsNullOrEmpty(error)); 63Assert.False(string.IsNullOrEmpty(error)); 71Assert.False(string.IsNullOrEmpty(error)); 104Assert.False(string.IsNullOrEmpty(error)); 113Assert.False(string.IsNullOrEmpty(error)); 132Assert.False(string.IsNullOrEmpty(error)); 141Assert.False(string.IsNullOrEmpty(error)); 160Assert.False(string.IsNullOrEmpty(error)); 169Assert.False(string.IsNullOrEmpty(error)); 188Assert.False(string.IsNullOrEmpty(error)); 197Assert.False(string.IsNullOrEmpty(error)); 217Assert.False(string.IsNullOrEmpty(error)); 236Assert.False(string.IsNullOrEmpty(error)); 267Assert.False(string.IsNullOrEmpty(error)); 286Assert.False(string.IsNullOrEmpty(error)); 295Assert.False(string.IsNullOrEmpty(error)); 316Assert.False(string.IsNullOrEmpty(error)); 325Assert.False(string.IsNullOrEmpty(error)); 354Assert.False(string.IsNullOrEmpty(error)); 363Assert.False(string.IsNullOrEmpty(error)); 419Assert.False(string.IsNullOrEmpty(error));
Microsoft.AspNetCore.HeaderPropagation.Tests (1)
HeaderPropagationMessageHandlerTest.cs (1)
183Assert.False(Handler.Headers.Contains("inout"));
Microsoft.AspNetCore.HostFiltering.Tests (2)
HostFilteringMiddlewareTests.cs (1)
65Assert.False(c.Request.Headers.TryGetValue(HeaderNames.Host, out var host));
MiddlewareConfigurationManagerTests.cs (1)
67Assert.False(ReferenceEquals(configurationBeforeChange, configurationAfterChange));
Microsoft.AspNetCore.Hosting.FunctionalTests (1)
LinkedApplicationTests.cs (1)
44Assert.False(deployer.HostProcess.HasExited);
Microsoft.AspNetCore.Hosting.Tests (45)
HostingApplicationDiagnosticsTests.cs (8)
169Assert.False(context.MetricsEnabled); 234Assert.False(context.EventLogEnabled); 528Assert.False(context.MetricsTagsFeature.MetricsDisabled); 594Assert.False(startFired); 595Assert.False(stopFired); 629Assert.False(isEnabledStartFired); 630Assert.False(eventsFired); 667Assert.False(eventsFired);
HostingMetricsTests.cs (2)
99Assert.False(measurement.Tags.ContainsKey("error.type")); 111Assert.False(measurement.Tags.ContainsKey("aspnetcore.request.is_unhandled"));
Http\DefaultHttpContextFactoryTests.cs (2)
98Assert.False(context._active); 117Assert.False(context._active);
StaticWebAssets\ManifestStaticWebAssetsFileProviderTests.cs (8)
304Assert.False(file.Exists); 305Assert.False(file.IsDirectory); 322Assert.False(file.IsDirectory); 341Assert.False(file.IsDirectory); 408Assert.False(file.Exists); 423Assert.False(file.IsDirectory); 424Assert.False(file.Exists); 454Assert.False(contents.Exists);
WebHostBuilderTests.cs (2)
1313Assert.False(filter.Executed); 1394Assert.False(service.StartCalled);
WebHostTests.AsyncDisposable.cs (3)
32Assert.False(provider.DisposeCalled); 33Assert.False(provider.DisposeAsyncCalled); 40Assert.False(provider.DisposeCalled);
WebHostTests.cs (20)
46Assert.False(serverAddressesFeature.Addresses.Any()); 47Assert.False(serverAddressesFeature.PreferHostingUrls); 66Assert.False(serverAddressFeature.PreferHostingUrls); 85Assert.False(serverAddressFeature.PreferHostingUrls); 105Assert.False(serverAddressFeature.PreferHostingUrls); 117Assert.False(serverAddressesFeature.PreferHostingUrls); 389Assert.False(singleton.Disposed); 390Assert.False(transient.Disposed); 394Assert.False(singleton.Disposed); 395Assert.False(transient.Disposed); 416Assert.False(applicationLifetime.ApplicationStarted.IsCancellationRequested); 417Assert.False(applicationLifetime2.ApplicationStarted.IsCancellationRequested); 475Assert.False(hostedServiceCalls2[0]); 561Assert.False(svc.StartCalled); 563Assert.False(svc.StopCalled); 565Assert.False(svc.StopCalled); 695Assert.False(hostedServiceCalls2[0]); 696Assert.False(started.All(s => s)); // Server doesn't start if hosted services throw 697Assert.False(started2.All(s => s)); 882Assert.False(string.IsNullOrWhiteSpace(httpContext.TraceIdentifier));
Microsoft.AspNetCore.Http.Abstractions.Tests (43)
EndpointFilterInvocationContextOfTTests.cs (1)
65Assert.False(context.Contains("This does not exist"));
HostStringTest.cs (1)
165Assert.False(HostString.MatchesAny(host, new StringSegment[] { pattern }));
PathStringTests.cs (5)
70Assert.False(result.HasValue); 297Assert.False(converter.CanConvertFrom(typeof(int))); 298Assert.False(converter.CanConvertFrom(typeof(bool))); 300Assert.False(converter.CanConvertTo(typeof(int))); 301Assert.False(converter.CanConvertTo(typeof(bool)));
QueryStringTests.cs (3)
22Assert.False(query.HasValue); 26Assert.False(query.HasValue); 30Assert.False(query.HasValue);
RouteValueDictionaryTests.cs (32)
225Assert.False(value); 298Assert.False(value); 435Assert.False(result); 1065Assert.False(result); 1085Assert.False(result); 1141Assert.False(result); 1162Assert.False(result); 1180Assert.False(result); 1193Assert.False(result); 1206Assert.False(result); 1254Assert.False(result); 1372Assert.False(result); 1393Assert.False(result); 1408Assert.False(result); 1421Assert.False(result); 1434Assert.False(result); 1449Assert.False(result); 1497Assert.False(result); 1548Assert.False(result); 1562Assert.False(result); 1576Assert.False(result); 1592Assert.False(result); 1645Assert.False(result); 1710Assert.False(dict.ContainsKey("key")); 1735Assert.False(dict.ContainsKey("key")); 1760Assert.False(dict.ContainsKey("key")); 1809Assert.False(result); 1900Assert.False(result); 1919Assert.False(result); 1933Assert.False(result); 1947Assert.False(result); 1995Assert.False(result);
UsePathBaseExtensionsTests.cs (1)
27Assert.False(useCalled);
Microsoft.AspNetCore.Http.Connections.Tests (47)
HttpConnectionDispatcherTests.cs (36)
132Assert.False(writeTask.IsCompleted); 240Assert.False(executeTask.IsCompleted); 1020Assert.False(exists); 1052Assert.False(exists); 1084Assert.False(exists); 1120Assert.False(exists); 1159Assert.False(exists); 1302Assert.False(connection.SendingToken.IsCancellationRequested); 1311Assert.False(manager.TryGetConnection(connection.ConnectionId, out var _)); 1341Assert.False(connection.SendingToken.IsCancellationRequested); 1350Assert.False(manager.TryGetConnection(connection.ConnectionId, out var _)); 1385Assert.False(connection.SendingToken.IsCancellationRequested); 1394Assert.False(manager.TryGetConnection(connection.ConnectionId, out var _)); 1455Assert.False(request1.IsCompleted); 1531Assert.False(request2.IsCompleted); 1572Assert.False(request1.IsCompleted); 1573Assert.False(request2.IsCompleted); 1582Assert.False(request2.IsCompleted); 1588Assert.False(request1.IsCompleted); 1699Assert.False(exists); 1741Assert.False(exists); 1966Assert.False(windowsIdentity.AccessToken.IsClosed); 2081Assert.False(pollTask.IsCompleted); 2098Assert.False(manager.TryGetConnection(connection.ConnectionToken, out _)); 2146Assert.False(manager.TryGetConnection(connection.ConnectionToken, out _)); 2186Assert.False(pollTask.IsCompleted); 2303Assert.False(negotiateResponse.TryGetValue("useStatefulReconnect", out _)); 2332Assert.False(negotiateResponse.TryGetValue("useStatefulReconnect", out _)); 2429Assert.False(newWebSocketTask.IsCompleted); 2505Assert.False(called); 2701Assert.False(sendTask.IsCompleted); 2751Assert.False(manager.TryGetConnection(connection.ConnectionToken, out var _)); 2792Assert.False(pollTask.IsCompleted); 3561Assert.False(feature.Enabled); 3588Assert.False(((HttpRequestTimeoutFeature)context.Features.Get<IHttpRequestTimeoutFeature>()).Enabled); 3594Assert.False(((HttpRequestTimeoutFeature)context.Features.Get<IHttpRequestTimeoutFeature>()).Enabled);
HttpConnectionManagerTests.cs (9)
31Assert.False(options.CloseOnAuthenticationExpiration); 194Assert.False(connectionManager.TryGetConnection(connection.ConnectionToken, out newConnection)); 233Assert.False(connectionManager.TryGetConnection(connection.ConnectionId, out var _)); 297Assert.False(firstTask.IsCompleted); 298Assert.False(secondTask.IsCompleted); 320Assert.False(firstTask.IsCompleted); 321Assert.False(secondTask.IsCompleted); 347Assert.False(firstTask.IsCompleted); 348Assert.False(secondTask.IsCompleted);
WebSocketsTests.cs (2)
405Assert.False(sequence.IsSingleSegment); 420Assert.False(messages.Received[0].EndOfMessage);
Microsoft.AspNetCore.Http.Extensions.Tests (67)
HttpRequestJsonExtensionsTests.cs (1)
145Assert.False(readTask.IsCompleted);
HttpResponseJsonExtensionsTests.cs (5)
133Assert.False(writeTask.IsCompleted); 329Assert.False(iterated); 363Assert.False(iterated); 397Assert.False(iterated); 431Assert.False(iterated);
ProblemDetailsDefaultWriterTest.cs (1)
670Assert.False(result);
ProblemDetailsServiceTest.cs (2)
109Assert.False(result); 129Assert.False(result);
PropertyAsParameterInfoTests.cs (2)
145Assert.False(parameterInfo.HasDefaultValue); 173Assert.False(parameterInfo.HasDefaultValue);
RequestDelegateFactoryTests.cs (18)
670Assert.False(headerValues.HasValue); 671Assert.False(queryValues.HasValue); 672Assert.False(formValues.HasValue); 791Assert.False(invoked); 794Assert.False(httpContext.RequestAborted.IsCancellationRequested); 796Assert.False(httpContext.Response.HasStarted); 1618Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1703Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1787Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1817Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1847Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1877Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1904Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1944Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1972Assert.False(invoked); 1973Assert.False(httpContext.RequestAborted.IsCancellationRequested); 2005Assert.False(invoked); 2006Assert.False(httpContext.RequestAborted.IsCancellationRequested);
RequestDelegateFactoryTests.FormMapping.cs (1)
204Assert.False(capturedTodo.IsCompleted);
RequestDelegateGenerator\CompileTimeCreationTests.cs (1)
590Assert.False(endpointModel.Response.IsAwaitable);
RequestDelegateGenerator\RequestDelegateCreationTests.cs (2)
284Assert.False(httpContext.RequestAborted.IsCancellationRequested); 315Assert.False(httpContext.RequestAborted.IsCancellationRequested);
RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (7)
375Assert.False((bool)httpContext.Items["invoked"]); 879Assert.False((bool)httpContext.Items["invoked"]); 938Assert.False(httpContext.RequestAborted.IsCancellationRequested); 970Assert.False(httpContext.RequestAborted.IsCancellationRequested); 972Assert.False(httpContext.Response.HasStarted); 1009Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1011Assert.False(httpContext.Response.HasStarted);
RequestDelegateGenerator\RequestDelegateCreationTests.JsonBody.cs (1)
482Assert.False(httpContext.RequestAborted.IsCancellationRequested);
RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (23)
41Assert.False(httpContext.RequestAborted.IsCancellationRequested); 43Assert.False(httpContext.Response.HasStarted); 104Assert.False(httpContext.RequestAborted.IsCancellationRequested); 106Assert.False(httpContext.Response.HasStarted); 157Assert.False(httpContext.RequestAborted.IsCancellationRequested); 159Assert.False(httpContext.Response.HasStarted); 194Assert.False(httpContext.RequestAborted.IsCancellationRequested); 196Assert.False(httpContext.Response.HasStarted); 225Assert.False(httpContext.RequestAborted.IsCancellationRequested); 274Assert.False(httpContext.RequestAborted.IsCancellationRequested); 276Assert.False(httpContext.Response.HasStarted); 305Assert.False(httpContext.RequestAborted.IsCancellationRequested); 353Assert.False(httpContext.RequestAborted.IsCancellationRequested); 355Assert.False(httpContext.Response.HasStarted); 489Assert.False(httpContext.RequestAborted.IsCancellationRequested); 525Assert.False(httpContext.RequestAborted.IsCancellationRequested); 527Assert.False(httpContext.Response.HasStarted); 567Assert.False(httpContext.RequestAborted.IsCancellationRequested); 569Assert.False(httpContext.Response.HasStarted); 605Assert.False(httpContext.RequestAborted.IsCancellationRequested); 607Assert.False(httpContext.Response.HasStarted); 646Assert.False(httpContext.RequestAborted.IsCancellationRequested); 648Assert.False(httpContext.Response.HasStarted);
RequestDelegateGenerator\RequestDelegateCreationTests.QueryParameters.cs (1)
77Assert.False(httpContext.RequestAborted.IsCancellationRequested);
RequestDelegateGenerator\RuntimeCreationTests.ComplexFormBinding.cs (2)
110Assert.False(elements["bar"]); 147Assert.False(elements["bar"]);
Microsoft.AspNetCore.Http.Results.Tests (44)
HttpResultsHelperTests.cs (1)
211Assert.False(two.IsComplete);
LocalRedirectResultTests.cs (3)
22Assert.False(result.PreserveMethod); 23Assert.False(result.Permanent); 37Assert.False(result.PreserveMethod);
RedirectResultTests.cs (2)
69Assert.False(actual); 83Assert.False(actual);
ResultsTests.cs (11)
323Assert.False(pushStreamResult.EnableRangeProcessing); 1098Assert.False(result.Permanent); 1099Assert.False(result.PreserveMethod); 1116Assert.False(result.PreserveMethod); 1480Assert.False(result.PreserveMethod); 1481Assert.False(result.Permanent); 1482Assert.False(result.AcceptLocalUrlOnly); 1496Assert.False(result.PreserveMethod); 1498Assert.False(result.AcceptLocalUrlOnly); 1513Assert.False(result.Permanent); 1514Assert.False(result.AcceptLocalUrlOnly);
src\Shared\ResultsTests\FileContentResultTestBase.cs (1)
327Assert.False(httpResponse.Headers.ContainsKey(HeaderNames.ContentType));
src\Shared\ResultsTests\FileStreamResultTestBase.cs (13)
67Assert.False(readStream.CanSeek); 108Assert.False(readStream.CanSeek); 145Assert.False(readStream.CanSeek); 182Assert.False(readStream.CanSeek); 216Assert.False(readStream.CanSeek); 252Assert.False(readStream.CanSeek); 288Assert.False(readStream.CanSeek); 322Assert.False(httpResponse.Headers.ContainsKey(HeaderNames.ContentType)); 325Assert.False(readStream.CanSeek); 368Assert.False(readStream.CanSeek); 392Assert.False(originalStream.CanSeek); 418Assert.False(originalStream.CanSeek); 436Assert.False(readStream.CanSeek);
src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (1)
262Assert.False(httpResponse.Headers.ContainsKey(HeaderNames.ContentType));
src\Shared\ResultsTests\VirtualFileResultTestBase.cs (1)
312Assert.False(httpResponse.Headers.ContainsKey(HeaderNames.ContentType));
TypedResultsTests.cs (11)
407Assert.False(pushStreamResult.EnableRangeProcessing); 942Assert.False(result.Permanent); 943Assert.False(result.PreserveMethod); 960Assert.False(result.PreserveMethod); 1262Assert.False(result.PreserveMethod); 1263Assert.False(result.Permanent); 1264Assert.False(result.AcceptLocalUrlOnly); 1278Assert.False(result.PreserveMethod); 1280Assert.False(result.AcceptLocalUrlOnly); 1295Assert.False(result.Permanent); 1296Assert.False(result.AcceptLocalUrlOnly);
Microsoft.AspNetCore.Http.Tests (16)
ApplicationBuilderTests.cs (2)
76Assert.False(endpointCalled); 153Assert.False(endpointCalled);
DefaultHttpContextTests.cs (5)
86Assert.False(context.User.Identity.IsAuthenticated); 93Assert.False(context.User.Identity.IsAuthenticated); 257Assert.False(scope.DisposeCalled); 265Assert.False(context._active); 273Assert.False(context._active);
HeaderDictionaryTests.cs (2)
32Assert.False(headers.ContainsKey("header2")); 82Assert.False(headers.ContainsKey("header2"));
Internal\DefaultHttpRequestTests.cs (3)
123Assert.False(request.IsHttps); 129Assert.False(request.IsHttps); 172Assert.False(cookies0.ContainsKey("key0"));
Internal\DefaultHttpResponseTests.cs (1)
188Assert.False(instance.DisposeCalled);
Internal\ReferenceReadStreamTests.cs (2)
21Assert.False(stream.CanSeek); 28Assert.False(stream.CanWrite);
Timeouts\RequestTimeoutsMiddlewareTests.cs (1)
252Assert.False(context.Items.ContainsKey("SetFrom"));
Microsoft.AspNetCore.HttpLogging.Tests (6)
FileLoggerProcessorTests.cs (2)
466Assert.False(File.Exists(filePath1)); 467Assert.False(File.Exists(filePath2));
HttpLoggingMiddlewareTests.cs (2)
1361Assert.False(TestSink.Writes.TryTake(out var _)); 1557Assert.False(httpContext.Features.Get<IHttpUpgradeFeature>() is UpgradeFeatureLoggingDecorator);
W3CLoggerOptionsTests.cs (2)
13Assert.False(options.LoggingFields.HasFlag(W3CLoggingFields.UserName)); 14Assert.False(options.LoggingFields.HasFlag(W3CLoggingFields.Cookie));
Microsoft.AspNetCore.HttpOverrides.Tests (14)
ForwardedHeadersMiddlewareTest.cs (12)
46Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 48Assert.False(context.Request.Headers.ContainsKey("X-Forwarded-For")); 83Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 192Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 1247Assert.False(context.Request.Headers.ContainsKey("X-Original-Prefix")); 1249Assert.False(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1291Assert.False(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1324Assert.False(context.Request.Headers.ContainsKey("X-Original-Prefix")); 1371Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 1372Assert.False(context.Request.Headers.ContainsKey("X-Original-Host")); 1373Assert.False(context.Request.Headers.ContainsKey("X-Original-Proto")); 1374Assert.False(context.Request.Headers.ContainsKey("X-Original-Prefix"));
IPNetworkTest.cs (2)
41Assert.False(network.Contains(IPAddress.Parse(addressText))); 134Assert.False(result);
Microsoft.AspNetCore.Identity.EntityFrameworkCore.Test (15)
SqlStoreOnlyUsersTestBase.cs (2)
88Assert.False(DbUtil.VerifyColumns(db, "AspNetRoles", "Id", "Name", "NormalizedName", "ConcurrencyStamp")); 89Assert.False(DbUtil.VerifyColumns(db, "AspNetUserRoles", "UserId", "RoleId"));
SqlStoreTestBase.cs (3)
163Assert.False(await roleMgr.RoleExistsAsync(roleName)); 172Assert.False(await roleMgr.RoleExistsAsync(roleName)); 187Assert.False(await roleMgr.RoleExistsAsync(roleName));
UserStoreEncryptPersonalDataTest.cs (10)
231Assert.False(FindInk(connection, "PhoneNumber", guid)); 232Assert.False(FindInk(connection, "Email", guid)); 233Assert.False(FindInk(connection, "UserName", guid)); 234Assert.False(FindInk(connection, "PersonalData1", guid)); 235Assert.False(FindInk(connection, "PersonalData2", guid)); 236Assert.False(FindAuthenticatorKeyInk(connection, guid)); 237Assert.False(FindTokenInk(connection, guid, "loginProvider", "token")); 240Assert.False(FindInk(connection, "NonPersonalData1", guid)); 241Assert.False(FindInk(connection, "NonPersonalData2", guid)); 242Assert.False(FindInk(connection, "SafePersonalData", guid));
Microsoft.AspNetCore.Identity.FunctionalTests (20)
ManagementTests.cs (2)
307Assert.False((bool)jsonData["EmailConfirmed"]); 311Assert.False((bool)jsonData["PhoneNumberConfirmed"]);
MapIdentityApiTests.cs (14)
113Assert.False(loginResponse.Headers.Contains(HeaderNames.SetCookie)); 692Assert.False(twoFactorKeyContent.GetProperty("isTwoFactorEnabled").GetBoolean()); 693Assert.False(twoFactorKeyContent.GetProperty("isMachineRemembered").GetBoolean()); 705Assert.False(enable2faContent.GetProperty("isMachineRemembered").GetBoolean()); 765Assert.False(disable2faContent.GetProperty("isTwoFactorEnabled").GetBoolean()); 804Assert.False(resetKeyContent.GetProperty("isTwoFactorEnabled").GetBoolean()); 901Assert.False(twoFactorKeyContent.GetProperty("isTwoFactorEnabled").GetBoolean()); 902Assert.False(twoFactorKeyContent.GetProperty("isMachineRemembered").GetBoolean()); 914Assert.False(enable2faContent.GetProperty("isMachineRemembered").GetBoolean()); 926Assert.False(session2faContent.GetProperty("isMachineRemembered").GetBoolean()); 935Assert.False(session2faContent2.GetProperty("isMachineRemembered").GetBoolean()); 1148Assert.False(infoPostResponse.Headers.Contains(HeaderNames.SetCookie)); 1169Assert.False(emailConfirmationResponse.Headers.Contains(HeaderNames.SetCookie)); 1252Assert.False(infoPostContent.GetProperty("isEmailConfirmed").GetBoolean());
Pages\Account\Manage\Email.cs (1)
36Assert.False(Context.EmailConfirmed);
Pages\Account\Manage\TwoFactorAuthentication.cs (1)
36Assert.False(Context.TwoFactorEnabled);
Pages\Index.cs (2)
44Assert.False(Context.UserAuthenticated); 54Assert.False(Context.UserAuthenticated);
Microsoft.AspNetCore.Identity.Specification.Tests (72)
IdentityResultAssert.cs (3)
31Assert.False(result.Succeeded); 40Assert.False(result.Succeeded); 50Assert.False(result.Succeeded);
IdentitySpecificationTestBase.cs (10)
133Assert.False(await manager.RoleExistsAsync(roleName)); 220Assert.False(await manager.RoleExistsAsync(roleName)); 224Assert.False(await manager.RoleExistsAsync(roleName)); 291Assert.False(await manager.RoleExistsAsync(roleName)); 306Assert.False(await manager.RoleExistsAsync(roleName)); 311Assert.False(await manager.RoleExistsAsync("update")); 348Assert.False(await manager.RoleExistsAsync(roleName)); 438Assert.False(await userManager.IsInRoleAsync(user, await roleManager.GetRoleNameAsync(roles[2]))); 467Assert.False(await userManager.IsInRoleAsync(u, roleName)); 527Assert.False(await userMgr.IsInRoleAsync(user, roleName));
UserManagerSpecificationTests.cs (59)
331Assert.False(await manager.CheckPasswordAsync(user, "password")); 560Assert.False(await manager.HasPasswordAsync(user)); 561Assert.False(await manager.CheckPasswordAsync(user, "whatever")); 602Assert.False(await manager.HasPasswordAsync(user)); 675Assert.False(await manager.HasPasswordAsync(user)); 694Assert.False(await manager.CheckPasswordAsync(user, password)); 956Assert.False(await manager.IsEmailConfirmedAsync(user)); 1002Assert.False(await manager.CheckPasswordAsync(user, password)); 1073Assert.False(await manager.VerifyUserTokenAsync(user, "Static", "test2", token)); 1076Assert.False(await manager.VerifyUserTokenAsync(user, "Static", "test", token + "a")); 1079Assert.False(await manager.VerifyUserTokenAsync(user2, "Static", "test", token)); 1094Assert.False(await manager.IsEmailConfirmedAsync(user)); 1102Assert.False(await manager.IsEmailConfirmedAsync(user)); 1116Assert.False(await manager.IsEmailConfirmedAsync(user)); 1119Assert.False(await manager.IsEmailConfirmedAsync(user)); 1132Assert.False(await manager.IsEmailConfirmedAsync(user)); 1139Assert.False(await manager.IsEmailConfirmedAsync(user)); 1157Assert.False(await mgr.IsLockedOutAsync(user)); 1179Assert.False(await mgr.IsLockedOutAsync(user)); 1181Assert.False(await mgr.IsLockedOutAsync(user)); 1182Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); 1204Assert.False(await mgr.IsLockedOutAsync(user)); 1206Assert.False(await mgr.IsLockedOutAsync(user)); 1207Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); 1211Assert.False(await mgr.IsLockedOutAsync(user)); 1212Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); 1214Assert.False(await mgr.IsLockedOutAsync(user)); 1215Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); 1232Assert.False(await mgr.GetLockoutEnabledAsync(user)); 1235Assert.False(await mgr.IsLockedOutAsync(user)); 1237Assert.False(await mgr.IsLockedOutAsync(user)); 1238Assert.False(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55)); 1259Assert.False(await mgr.IsLockedOutAsync(user)); 1274Assert.False(await mgr.GetLockoutEnabledAsync(user)); 1278Assert.False(await mgr.IsLockedOutAsync(user)); 1292Assert.False(await mgr.IsLockedOutAsync(user)); 1307Assert.False(await mgr.IsLockedOutAsync(user)); 1370Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); 1403Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); 1408Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); 1437Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); 1455Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); 1460Assert.False(await manager.IsPhoneNumberConfirmedAsync(user)); 1484Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, "bogus", num1)); 1485Assert.False(await manager.VerifyChangePhoneNumberTokenAsync(user, "bogus", num2)); 1502Assert.False(await manager.IsEmailConfirmedAsync(user)); 1524Assert.False(await manager.IsEmailConfirmedAsync(user)); 1551Assert.False(await manager.IsEmailConfirmedAsync(user)); 1573Assert.False(await manager.IsEmailConfirmedAsync(user)); 1580Assert.False(await manager.IsEmailConfirmedAsync(user)); 1597Assert.False(await manager.IsEmailConfirmedAsync(user)); 1602Assert.False(await manager.IsEmailConfirmedAsync(user)); 1620Assert.False(await manager.IsEmailConfirmedAsync(user)); 1626Assert.False(await manager.IsEmailConfirmedAsync(user)); 1657Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); 1811Assert.False(factors.Any()); 1854Assert.False(await manager.VerifyTwoFactorTokenAsync(user, factorId, token)); 1870Assert.False(await manager.VerifyTwoFactorTokenAsync(user, "Email", token)); 1884Assert.False(await manager.VerifyTwoFactorTokenAsync(user, "Phone", "bogus"));
Microsoft.AspNetCore.Identity.Test (131)
IdentityOptionsTest.cs (1)
29Assert.False(options.User.RequireUniqueEmail);
IdentityResultTest.cs (2)
12Assert.False(result.Succeeded); 20Assert.False(result.Succeeded);
Passkeys\PasskeyHandlerAssertionTest.cs (50)
44Assert.False(result.Succeeded); 63Assert.False(result.Succeeded); 79Assert.False(result.Succeeded); 95Assert.False(result.Succeeded); 114Assert.False(result.Succeeded); 129Assert.False(result.Succeeded); 144Assert.False(result.Succeeded); 163Assert.False(result.Succeeded); 178Assert.False(result.Succeeded); 197Assert.False(result.Succeeded); 213Assert.False(result.Succeeded); 232Assert.False(result.Succeeded); 247Assert.False(result.Succeeded); 263Assert.False(result.Succeeded); 282Assert.False(result.Succeeded); 298Assert.False(result.Succeeded); 314Assert.False(result.Succeeded); 330Assert.False(result.Succeeded); 349Assert.False(result.Succeeded); 365Assert.False(result.Succeeded); 381Assert.False(result.Succeeded); 398Assert.False(result.Succeeded); 415Assert.False(result.Succeeded); 430Assert.False(result.Succeeded); 449Assert.False(result.Succeeded); 464Assert.False(result.Succeeded); 483Assert.False(result.Succeeded); 501Assert.False(result.Succeeded); 516Assert.False(result.Succeeded); 535Assert.False(result.Succeeded); 550Assert.False(result.Succeeded); 566Assert.False(result.Succeeded); 584Assert.False(result.Succeeded); 599Assert.False(result.Succeeded); 618Assert.False(result.Succeeded); 633Assert.False(result.Succeeded); 655Assert.False(result.Succeeded); 672Assert.False(result.Succeeded); 687Assert.False(result.Succeeded); 707Assert.False(result.Succeeded); 749Assert.False(result.Succeeded); 766Assert.False(result.Succeeded); 796Assert.False(result.Succeeded); 813Assert.False(result.Succeeded); 830Assert.False(result.Succeeded); 871Assert.False(result.Succeeded); 916Assert.False(result.Succeeded); 932Assert.False(result.Succeeded); 950Assert.False(result.Succeeded); 969Assert.False(result.Succeeded);
Passkeys\PasskeyHandlerAttestationTest.cs (53)
44Assert.False(result.Succeeded); 63Assert.False(result.Succeeded); 79Assert.False(result.Succeeded); 95Assert.False(result.Succeeded); 114Assert.False(result.Succeeded); 129Assert.False(result.Succeeded); 144Assert.False(result.Succeeded); 163Assert.False(result.Succeeded); 179Assert.False(result.Succeeded); 198Assert.False(result.Succeeded); 214Assert.False(result.Succeeded); 233Assert.False(result.Succeeded); 249Assert.False(result.Succeeded); 268Assert.False(result.Succeeded); 283Assert.False(result.Succeeded); 299Assert.False(result.Succeeded); 318Assert.False(result.Succeeded); 334Assert.False(result.Succeeded); 353Assert.False(result.Succeeded); 368Assert.False(result.Succeeded); 384Assert.False(result.Succeeded); 403Assert.False(result.Succeeded); 418Assert.False(result.Succeeded); 433Assert.False(result.Succeeded); 452Assert.False(result.Succeeded); 470Assert.False(result.Succeeded); 485Assert.False(result.Succeeded); 504Assert.False(result.Succeeded); 519Assert.False(result.Succeeded); 535Assert.False(result.Succeeded); 553Assert.False(result.Succeeded); 568Assert.False(result.Succeeded); 587Assert.False(result.Succeeded); 602Assert.False(result.Succeeded); 624Assert.False(result.Succeeded); 641Assert.False(result.Succeeded); 656Assert.False(result.Succeeded); 676Assert.False(result.Succeeded); 706Assert.False(result.Succeeded); 731Assert.False(result.Succeeded); 747Assert.False(result.Succeeded); 763Assert.False(result.Succeeded); 779Assert.False(result.Succeeded); 794Assert.False(result.Succeeded); 810Assert.False(result.Succeeded); 826Assert.False(result.Succeeded); 842Assert.False(result.Succeeded); 857Assert.False(result.Succeeded); 904Assert.False(result.Succeeded); 916Assert.False(result.Succeeded); 932Assert.False(result.Succeeded); 949Assert.False(result.Succeeded); 965Assert.False(result.Succeeded);
RoleManagerTest.cs (1)
54Assert.False(manager.SupportsQueryableRoles);
SignInManagerTest.cs (9)
65Assert.False(result.Succeeded); 109Assert.False(result.Succeeded); 338Assert.False(result.Succeeded); 609Assert.False(result.Succeeded); 1226Assert.False(result.Succeeded); 1227Assert.False(checkResult.Succeeded); 1256Assert.False(result.Succeeded); 1283Assert.False(result.Succeeded); 1310Assert.False(result.Succeeded);
UserManagerTest.cs (15)
169Assert.False(result.Succeeded); 870Assert.False(await manager.CheckPasswordAsync(null, "whatevs")); 883Assert.False(manager.SupportsQueryableUsers); 894Assert.False(manager.SupportsUserEmail); 921Assert.False(manager.SupportsUserPhoneNumber); 976Assert.False(manager.SupportsUserPassword); 1022Assert.False(manager.SupportsUserSecurityStamp); 1051Assert.False(manager.SupportsUserLogin); 1077Assert.False(manager.SupportsUserClaim); 1237Assert.False(manager.SupportsUserTwoFactor); 1247Assert.False(manager.SupportsUserLockout); 1260Assert.False(manager.SupportsUserRole); 1274Assert.False(manager.SupportsUserAuthenticationTokens); 1285Assert.False(manager.SupportsUserAuthenticatorKey); 1295Assert.False(manager.SupportsUserTwoFactorRecoveryCodes);
Microsoft.AspNetCore.InternalTesting.Tests (25)
AspNetTestAssemblyRunnerTest.cs (3)
26Assert.False(fixture.ConstructorWithMessageSinkCalled); 28Assert.False(fixture.ParameterlessConstructorCalled); 42Assert.False(fixture.ParameterlessConstructorCalled);
DockerTests.cs (1)
18Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Windows));
EnvironmentVariableSkipConditionTest.cs (3)
30Assert.False(isMet); 106Assert.False(isMet); 149Assert.False(isMet);
MaximumOSVersionAttributeTest.cs (1)
74Assert.False(osSkipAttribute.IsMet);
MinimumOSVersionAttributeTest.cs (1)
62Assert.False(osSkipAttribute.IsMet);
OSSkipConditionAttributeTest.cs (7)
21Assert.False(osSkipAttribute.IsMet); 44Assert.False(osSkipAttributeLinux.IsMet); 45Assert.False(osSkipAttributeMacOSX.IsMet); 56Assert.False(osSkipAttribute.IsMet); 57Assert.False(osSkipAttributeMacOSX.IsMet); 68Assert.False(osSkipAttribute.IsMet); 69Assert.False(osSkipAttributeLinux.IsMet);
RetryTest.cs (2)
19Assert.False(_wasInvokedPreviously); 36Assert.False(_wasInvokedPreviously);
TestPlatformHelperTest.cs (7)
17Assert.False(TestPlatformHelper.IsMac); 18Assert.False(TestPlatformHelper.IsWindows); 26Assert.False(TestPlatformHelper.IsLinux); 28Assert.False(TestPlatformHelper.IsWindows); 36Assert.False(TestPlatformHelper.IsLinux); 37Assert.False(TestPlatformHelper.IsMac); 52Assert.False(TestPlatformHelper.IsMono);
Microsoft.AspNetCore.JsonPatch.SystemTextJson.Tests (28)
Internal\DictionaryAdapterTest.cs (6)
77Assert.False(getStatus); 104Assert.False(getStatus); 190Assert.False(replaceStatus); 208Assert.False(replaceStatus); 226Assert.False(removeStatus); 332Assert.False(testStatus);
Internal\ListAdapterTest.cs (10)
26Assert.False(addStatus); 44Assert.False(addStatus); 82Assert.False(addStatus); 100Assert.False(addStatus); 190Assert.False(addStatus); 316Assert.False(getStatus); 355Assert.False(removeStatus); 390Assert.False(replaceStatus); 478Assert.False(testStatus); 495Assert.False(testStatus);
Internal\ObjectVisitorTest.cs (4)
152Assert.False(visitStatus); 170Assert.False(visitStatus); 202Assert.False(visitStatus); 218Assert.False(visitStatus);
Internal\PocoAdapterTest.cs (6)
48Assert.False(addStatus); 89Assert.False(getStatus); 129Assert.False(removeStatus); 171Assert.False(replaceStatus); 192Assert.False(replaceStatus); 258Assert.False(testStatus);
JsonPatchDocumentJObjectTest.cs (2)
90Assert.False(model.CustomData.ContainsKey("LastName")); 106Assert.False(model.CustomData.ContainsKey("FirstName"));
Microsoft.AspNetCore.JsonPatch.Tests (28)
Internal\DictionaryAdapterTest.cs (6)
80Assert.False(getStatus); 107Assert.False(getStatus); 193Assert.False(replaceStatus); 211Assert.False(replaceStatus); 229Assert.False(removeStatus); 334Assert.False(testStatus);
Internal\ListAdapterTest.cs (10)
26Assert.False(addStatus); 44Assert.False(addStatus); 82Assert.False(addStatus); 100Assert.False(addStatus); 190Assert.False(addStatus); 316Assert.False(getStatus); 355Assert.False(removeStatus); 390Assert.False(replaceStatus); 476Assert.False(testStatus); 493Assert.False(testStatus);
Internal\ObjectVisitorTest.cs (4)
169Assert.False(visitStatus); 187Assert.False(visitStatus); 219Assert.False(visitStatus); 235Assert.False(visitStatus);
Internal\PocoAdapterTest.cs (6)
54Assert.False(addStatus); 95Assert.False(getStatus); 135Assert.False(removeStatus); 177Assert.False(replaceStatus); 198Assert.False(replaceStatus); 259Assert.False(testStatus);
JsonPatchDocumentJObjectTest.cs (2)
92Assert.False(model.CustomData.ContainsKey("LastName")); 108Assert.False(model.CustomData.ContainsKey("FirstName"));
Microsoft.AspNetCore.Mvc.Abstractions.Test (18)
Filters\FilterContextTest.cs (2)
30Assert.False(result); 69Assert.False(result);
ModelBinding\ModelMetadataTest.cs (5)
30Assert.False(modelMetadata.IsComplexType); 106Assert.False(modelMetadata.IsCollectionType); 128Assert.False(modelMetadata.IsEnumerableType); 438Assert.False(metadata.IsCollectionType); 440Assert.False(metadata.IsComplexType);
ModelBinding\ModelStateDictionaryTest.cs (11)
25Assert.False(result); 43Assert.False(containsKey); 463Assert.False(isValid); 544Assert.False(isValid); 795Assert.False(result); 819Assert.False(dictionary.HasReachedMaxErrors); 823Assert.False(dictionary.HasReachedMaxErrors); 827Assert.False(dictionary.HasReachedMaxErrors); // Still room for TooManyModelErrorsException. 829Assert.False(result); 833Assert.False(result); 900Assert.False(result);
Microsoft.AspNetCore.Mvc.ApiExplorer.Test (46)
ApiResponseTypeProviderTest.cs (28)
41Assert.False(responseType.IsDefaultResponse); 54Assert.False(responseType.IsDefaultResponse); 61Assert.False(responseType.IsDefaultResponse); 106Assert.False(responseType.IsDefaultResponse); 119Assert.False(responseType.IsDefaultResponse); 132Assert.False(responseType.IsDefaultResponse); 164Assert.False(responseType.IsDefaultResponse); 177Assert.False(responseType.IsDefaultResponse); 184Assert.False(responseType.IsDefaultResponse); 221Assert.False(responseType.IsDefaultResponse); 235Assert.False(responseType.IsDefaultResponse); 243Assert.False(responseType.IsDefaultResponse); 275Assert.False(responseType.IsDefaultResponse); 322Assert.False(responseType.IsDefaultResponse); 331Assert.False(responseType.IsDefaultResponse); 370Assert.False(responseType.IsDefaultResponse); 379Assert.False(responseType.IsDefaultResponse); 421Assert.False(responseType.IsDefaultResponse); 430Assert.False(responseType.IsDefaultResponse); 524Assert.False(responseType.IsDefaultResponse); 611Assert.False(responseType.IsDefaultResponse); 620Assert.False(responseType.IsDefaultResponse); 659Assert.False(responseType.IsDefaultResponse); 668Assert.False(responseType.IsDefaultResponse); 701Assert.False(responseType.IsDefaultResponse); 731Assert.False(responseType.IsDefaultResponse); 757Assert.False(responseType.IsDefaultResponse); 824Assert.False(result.Any());
DefaultApiDescriptionProviderTest.cs (5)
61Assert.False(anyParameter.IsRequired); 2086Assert.False(description.IsRequired); 2107Assert.False(description.IsRequired); 2161Assert.False(description.IsRequired); 2180Assert.False(description.IsRequired);
EndpointMetadataApiDescriptionProviderTest.cs (13)
114Assert.False(apiParameterDescription.IsRequired); 916Assert.False(param.IsRequired); 948param => Assert.False(param.IsRequired), 950param => Assert.False(param.IsRequired)); 978param => Assert.False(param.IsRequired)); 998Assert.False(barParam.IsRequired); 1037Assert.False(fooParam.IsRequired); 1056Assert.False(nameParam.IsRequired); 1294Assert.False(bodyParameterDescription.IsRequired); 1385Assert.False(bodyParameterDescription.IsRequired); 1417Assert.False(bodyParameterDescription.IsRequired); 1474Assert.False(bodyParameterDescription.IsRequired); 1547Assert.False(fromFileParam1.IsRequired);
Microsoft.AspNetCore.Mvc.Core.Test (397)
ApiExplorer\ApiConventionMatcherTest.cs (18)
36Assert.False(result); 50Assert.False(result); 64Assert.False(result); 78Assert.False(result); 134Assert.False(result); 148Assert.False(result); 162Assert.False(result); 176Assert.False(result); 190Assert.False(result); 204Assert.False(result); 232Assert.False(result); 258Assert.False(result); 313Assert.False(result); 327Assert.False(result); 341Assert.False(result); 355Assert.False(result); 369Assert.False(result); 383Assert.False(result);
ApiExplorer\ApiConventionResultTest.cs (1)
19Assert.False(result);
ApplicationModels\ApiBehaviorApplicationModelProviderTest.cs (1)
195Assert.False(convention.IsInferForServiceParametersEnabled);
ApplicationModels\AttributeRouteModelTests.cs (2)
292Assert.False(combined.SuppressLinkGeneration); 329Assert.False(combined.SuppressPathMatching);
ApplicationModels\ControllerActionDescriptorProviderTests.cs (2)
297Assert.False(httpMethodMetadata.AcceptCorsPreflight); 330Assert.False(lastHttpMethodMetadata.AcceptCorsPreflight);
ApplicationModels\DefaultApplicationModelProviderTest.cs (10)
506Assert.False(isValid); 523Assert.False(isValid); 539Assert.False(isValid); 554Assert.False(isValid); 569Assert.False(isValid); 590Assert.False(isValid); 608Assert.False(isValid); 646Assert.False(isValid); 680Assert.False(isValid); 742Assert.False(isValid);
ConsumesAttributeTests.cs (5)
136Assert.False(constraint1.Accept(context)); 211Assert.False(constraint1.Accept(context)); 213Assert.False(constraint2.Accept(context)); 250Assert.False(constraint1.Accept(context)); 253Assert.False(constraint2.Accept(context));
ControllerBaseTest.cs (66)
52Assert.False(result.PreserveMethod); 53Assert.False(result.Permanent); 69Assert.False(result.PreserveMethod); 87Assert.False(result.Permanent); 150Assert.False(result.PreserveMethod); 151Assert.False(result.Permanent); 167Assert.False(result.PreserveMethod); 185Assert.False(result.Permanent); 292Assert.False(resultTemporary.PreserveMethod); 293Assert.False(resultTemporary.Permanent); 309Assert.False(resultTemporary.Permanent); 324Assert.False(resultPermanent.PreserveMethod); 359Assert.False(resultTemporary.PreserveMethod); 360Assert.False(resultTemporary.Permanent); 380Assert.False(resultTemporary.Permanent); 399Assert.False(resultPermanent.PreserveMethod); 439Assert.False(resultTemporary.PreserveMethod); 440Assert.False(resultTemporary.Permanent); 464Assert.False(resultTemporary.Permanent); 487Assert.False(resultPermanent.PreserveMethod); 532Assert.False(resultTemporary.PreserveMethod); 533Assert.False(resultTemporary.Permanent); 553Assert.False(resultTemporary.Permanent); 575Assert.False(result.PreserveMethod); 576Assert.False(result.Permanent); 601Assert.False(result.Permanent); 622Assert.False(resultPermanent.PreserveMethod); 665Assert.False(result.PreserveMethod); 716Assert.False(resultTemporary.PreserveMethod); 717Assert.False(resultTemporary.Permanent); 736Assert.False(resultTemporary.Permanent); 756Assert.False(result.PreserveMethod); 757Assert.False(result.Permanent); 780Assert.False(result.Permanent); 800Assert.False(resultPermanent.PreserveMethod); 840Assert.False(result.PreserveMethod); 882Assert.False(resultTemporary.PreserveMethod); 883Assert.False(resultTemporary.Permanent); 900Assert.False(resultTemporary.Permanent); 916Assert.False(resultPermanent.PreserveMethod); 953Assert.False(resultTemporary.PreserveMethod); 954Assert.False(resultTemporary.Permanent); 975Assert.False(resultTemporary.Permanent); 995Assert.False(resultPermanent.PreserveMethod); 1221Assert.False(result.Permanent); 1241Assert.False(resultPermanent.Permanent); 1677Assert.False(result.EnableRangeProcessing); 1739Assert.False(result.EnableRangeProcessing); 1783Assert.False(result.EnableRangeProcessing); 1827Assert.False(result.EnableRangeProcessing); 1876Assert.False(result.EnableRangeProcessing); 1929Assert.False(result.EnableRangeProcessing); 2708Assert.False(result); 2733Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude1"])); 2734Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude2"])); 2766Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude1"])); 2767Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude2"])); 2800Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude1"])); 2801Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude2"])); 2832Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude1"])); 2833Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude2"])); 2871Assert.False(InvokePropertyFilter("Exclude")); 2916Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude1"])); 2917Assert.False(context.PropertyFilter(context.ModelMetadata.Properties["Exclude2"])); 3115Assert.False(result); 3152Assert.False(result);
Controllers\ControllerBinderDelegateProviderTest.cs (2)
416Assert.False(controllerContext.ModelState.IsValid); 512Assert.False(controllerContext.ModelState.IsValid);
Controllers\DefaultControllerActivatorTest.cs (1)
99Assert.False(controller.SyncDisposed);
Filters\FilterFactoryTest.cs (1)
47Assert.False(f.IsReusable);
Filters\MiddlewareFilterTest.cs (3)
79Assert.False(invoker.ControllerFactory.CreateCalled); 129Assert.False(invoker.ControllerFactory.CreateCalled); 214Assert.False(invoker.ControllerFactory.CreateCalled);
Formatters\InputFormatterTest.cs (5)
115Assert.False(result); 180Assert.False(result); 247Assert.False(result); 314Assert.False(result); 427Assert.False(result.HasError);
Formatters\JsonInputFormatterTestBase.cs (10)
79Assert.False(result.HasError); 100Assert.False(result.HasError); 121Assert.False(result.HasError); 227Assert.False(result.HasError); 248Assert.False(result.HasError); 270Assert.False(result.HasError); 302Assert.False(result.HasError); 434Assert.False(formatterContext.ModelState.ContainsKey("age")); 462Assert.False(result.HasError); 557Assert.False(testBufferedReadStream.Disposed);
Formatters\MediaTypeTest.cs (4)
178Assert.False(result.HasValue); 255Assert.False(result); 283Assert.False(result); 311Assert.False(result);
Formatters\OutputFormatterTests.cs (1)
70Assert.False(result);
Formatters\StreamOutputFormatterTest.cs (2)
58Assert.False(canWrite); 81Assert.False(result);
Formatters\StringOutputFormatterTests.cs (2)
56Assert.False(result); 124Assert.False(result);
Formatters\SystemTextJsonInputFormatterTest.cs (2)
103Assert.False(formatterContext.ModelState.IsValid); 124Assert.False(formatterContext.ModelState.IsValid);
Formatters\SystemTextJsonOutputFormatterTest.cs (1)
145Assert.False(iterated);
Infrastructure\AsyncEnumerableReaderTest.cs (1)
26Assert.False(result);
Infrastructure\CompatibilitySwitchTest.cs (4)
15Assert.False(@switch.Value); 16Assert.False(@switch.IsValueSet); 27Assert.False(@switch.IsValueSet); 40Assert.False(@switch.Value);
Infrastructure\ConfigureCompatibilityOptionsTest.cs (2)
27Assert.False(options.TestProperty); 50Assert.False(options.TestProperty);
Infrastructure\ControllerActionInvokerTest.cs (4)
540Assert.False(c.ExceptionHandled); 574Assert.False(c.ExceptionHandled); 616Assert.False(context.ExceptionHandled); 661Assert.False(c.ExceptionHandled);
Infrastructure\DefaultActionDescriptorCollectionProviderTest.cs (3)
113Assert.False(changeToken1.HasChanged); 131Assert.False(changeToken2.HasChanged); 148Assert.False(changeToken3.HasChanged);
Infrastructure\DefaultApiProblemDetailsWriterTest.cs (1)
133Assert.False(result);
Infrastructure\JsonResultExecutorTestBase.cs (2)
380Assert.False(iterated); 414Assert.False(iterated);
LocalRedirectResultTest.cs (3)
27Assert.False(result.PreserveMethod); 28Assert.False(result.Permanent); 42Assert.False(result.PreserveMethod);
ModelBinding\Binders\ArrayModelBinderTest.cs (1)
161Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\BinderTypeModelBinderTest.cs (1)
25Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\BodyModelBinderProviderTest.cs (2)
105Assert.False(allowEmpty); 129Assert.False(allowEmpty);
ModelBinding\Binders\BodyModelBinderTests.cs (13)
66Assert.False(bindingContext.Result.IsModelSet); 91Assert.False(bindingContext.Result.IsModelSet); 115Assert.False(bindingContext.Result.IsModelSet); 149Assert.False(bindingContext.Result.IsModelSet); 150Assert.False(bindingContext.ModelState.IsValid); 242Assert.False(bindingContext.ModelState.IsValid); 271Assert.False(bindingContext.Result.IsModelSet); 314Assert.False(bindingContext.Result.IsModelSet); 345Assert.False(bindingContext.Result.IsModelSet); 385Assert.False(bindingContext.Result.IsModelSet); 416Assert.False(bindingContext.Result.IsModelSet); 496Assert.False(bindingContext.Result.IsModelSet); 552Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\ByteArrayModelBinderTests.cs (4)
28Assert.False(bindingContext.Result.IsModelSet); 75Assert.False(bindingContext.Result.IsModelSet); 76Assert.False(bindingContext.ModelState.IsValid); 97Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\CollectionModelBinderTest.cs (2)
343Assert.False(bindingContext.Result.IsModelSet); 417Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\ComplexObjectModelBinderTest.cs (6)
509Assert.False(result); 534Assert.False(result); 616Assert.False(modelStateDictionary.IsValid); 681Assert.False(modelStateDictionary.IsValid); 720Assert.False(modelStateDictionary.IsValid); 1078Assert.False(bindingContext.ModelState.IsValid);
ModelBinding\Binders\ComplexTypeModelBinderTest.cs (6)
690Assert.False(result); 715Assert.False(result); 794Assert.False(modelStateDictionary.IsValid); 828Assert.False(modelStateDictionary.IsValid); 864Assert.False(modelStateDictionary.IsValid); 1240Assert.False(bindingContext.ModelState.IsValid);
ModelBinding\Binders\DateTimeModelBinderTest.cs (5)
26Assert.False(bindingContext.Result.IsModelSet); 45Assert.False(bindingContext.Result.IsModelSet); 47Assert.False(bindingContext.ModelState.IsValid); 68Assert.False(bindingContext.Result.IsModelSet); 124Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\DictionaryModelBinderProviderTest.cs (1)
58Assert.False(binder.AllowValidatingTopLevelNodes); // work done in DictionaryModelBinder.
ModelBinding\Binders\DictionaryModelBinderTest.cs (3)
260Assert.False(bindingContext.Result.IsModelSet); 537Assert.False(bindingContext.Result.IsModelSet); 581Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\EnumTypeModelBinderTest.cs (6)
40Assert.False(bindingContext.Result.IsModelSet); 42Assert.False(bindingContext.ModelState.IsValid); 145Assert.False(bindingContext.Result.IsModelSet); 147Assert.False(bindingContext.ModelState.IsValid); 228Assert.False(bindingContext.Result.IsModelSet); 230Assert.False(bindingContext.ModelState.IsValid);
ModelBinding\Binders\FloatingPointTypeModelBinderTestOfT.cs (8)
47Assert.False(bindingContext.Result.IsModelSet); 67Assert.False(bindingContext.Result.IsModelSet); 69Assert.False(bindingContext.ModelState.IsValid); 91Assert.False(bindingContext.Result.IsModelSet); 115Assert.False(bindingContext.Result.IsModelSet); 139Assert.False(bindingContext.Result.IsModelSet); 163Assert.False(bindingContext.Result.IsModelSet); 205Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\FormFileModelBinderTest.cs (12)
32Assert.False(entry.SuppressValidation); 66Assert.False(entry.SuppressValidation); 106Assert.False(entry.SuppressValidation); 148Assert.False(entry.SuppressValidation); 182Assert.False(entry.SuppressValidation); 218Assert.False(entry.SuppressValidation); 239Assert.False(entry.SuppressValidation); 304Assert.False(bindingContext.Result.IsModelSet); 324Assert.False(bindingContext.Result.IsModelSet); 374Assert.False(bindingContext.Result.IsModelSet); 394Assert.False(bindingContext.Result.IsModelSet); 428Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\HeaderModelBinderTests.cs (2)
170Assert.False(bindingContext.Result.IsModelSet); 189Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\KeyValuePairModelBinderTest.cs (5)
28Assert.False(bindingContext.Result.IsModelSet); 30Assert.False(bindingContext.ModelState.IsValid); 54Assert.False(bindingContext.ModelState.IsValid); 79Assert.False(bindingContext.Result.IsModelSet); 196Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\SimpleTypeModelBinderTest.cs (6)
107Assert.False(bindingContext.Result.IsModelSet); 126Assert.False(bindingContext.Result.IsModelSet); 151Assert.False(bindingContext.Result.IsModelSet); 153Assert.False(bindingContext.ModelState.IsValid); 323Assert.False(bindingContext.Result.IsModelSet); 372Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\Binders\TryParseTypeModelBinderTest.cs (8)
56Assert.False(bindingContext.Result.IsModelSet); 75Assert.False(bindingContext.Result.IsModelSet); 100Assert.False(bindingContext.Result.IsModelSet); 102Assert.False(bindingContext.ModelState.IsValid); 249Assert.False(bindingContext.Result.IsModelSet); 298Assert.False(bindingContext.Result.IsModelSet); 405Assert.False(bindingContext.Result.IsModelSet); 455Assert.False(bindingContext.Result.IsModelSet);
ModelBinding\CompositeValueProviderTest.cs (2)
58Assert.False(success); 60Assert.False(modelState.IsValid);
ModelBinding\DefaultModelBindingContextTest.cs (1)
54Assert.False(bindingContext.IsTopLevelObject);
ModelBinding\ElementalValueProviderTests.cs (1)
51Assert.False(containsPrefix);
ModelBinding\EnumerableValueProviderTest.cs (2)
39Assert.False(result); 80Assert.False(result);
ModelBinding\FormFileValueProviderTest.cs (1)
27Assert.False(result);
ModelBinding\Metadata\BindingSourceTest.cs (2)
87Assert.False(result); 97Assert.False(result);
ModelBinding\Metadata\CompositeBindingSourceTest.cs (1)
59Assert.False(result);
ModelBinding\Metadata\DefaultBindingMetadataProviderTest.cs (17)
171Assert.False(context.BindingMetadata.IsBindingAllowed); 172Assert.False(context.BindingMetadata.IsBindingRequired); 194Assert.False(context.BindingMetadata.IsBindingAllowed); 195Assert.False(context.BindingMetadata.IsBindingRequired); 218Assert.False(context.BindingMetadata.IsBindingRequired); 286Assert.False(context.BindingMetadata.IsBindingAllowed); 287Assert.False(context.BindingMetadata.IsBindingRequired); 309Assert.False(context.BindingMetadata.IsBindingAllowed); 310Assert.False(context.BindingMetadata.IsBindingRequired); 333Assert.False(context.BindingMetadata.IsBindingRequired); 466Assert.False(context.BindingMetadata.IsBindingAllowed); 467Assert.False(context.BindingMetadata.IsBindingRequired); 484Assert.False(context.BindingMetadata.IsBindingAllowed); 485Assert.False(context.BindingMetadata.IsBindingRequired); 508Assert.False(context.BindingMetadata.IsBindingRequired); 576Assert.False(context.BindingMetadata.IsBindingAllowed); 577Assert.False(context.BindingMetadata.IsBindingRequired);
ModelBinding\Metadata\DefaultModelMetadataTest.cs (28)
35Assert.False(metadata.HasNonDefaultEditFormat); 36Assert.False(metadata.HideSurroundingHtml); 39Assert.False(metadata.IsBindingRequired); 40Assert.False(metadata.IsCollectionType); 41Assert.False(metadata.IsComplexType); 42Assert.False(metadata.IsEnumerableType); 43Assert.False(metadata.IsEnum); 44Assert.False(metadata.IsFlagsEnum); 45Assert.False(metadata.IsNullableValueType); 46Assert.False(metadata.IsReadOnly); 47Assert.False(metadata.IsRequired); // Defaults to false for reference types 50Assert.False(metadata.ValidateChildren); // Defaults to true for complex and enumerable types. 339Assert.False(isBindingRequired); 389Assert.False(isParseableType); 410Assert.False(isParseableType); 432Assert.False(isRequired); 747Assert.False(isReadOnly); 804Assert.False(isReadOnly); 828Assert.False(validateChildren); 943Assert.False(validateChildren); 1000Assert.False(result); 1018Assert.False(result); 1034Assert.False(result); 1165Assert.False(result); 1321Assert.False(result); 1366Assert.False(result); 1457Assert.False(result); 1590Assert.False(result);
ModelBinding\Metadata\DefaultValidationMetadataProviderTest.cs (3)
25Assert.False(context.ValidationMetadata.PropertyValidationFilter.ShouldValidateEntry( 81Assert.False(context.ValidationMetadata.PropertyValidationFilter.ShouldValidateEntry( 103Assert.False(context.ValidationMetadata.PropertyValidationFilter.ShouldValidateEntry(
ModelBinding\Metadata\ExcludeBindingMetadataProviderTest.cs (1)
53Assert.False(context.BindingMetadata.IsBindingAllowed);
ModelBinding\ModelBindingHelperTest.cs (7)
42Assert.False(result); 83Assert.False(result); 148Assert.False(result); 228Assert.False(result); 478Assert.False(result); 560Assert.False(result); 1490Assert.False(result);
ModelBinding\ModelBindingResultTest.cs (1)
29Assert.False(result.IsModelSet);
ModelBinding\ParameterBinderTest.cs (13)
78Assert.False(actionContext.ModelState.IsValid); 116Assert.False(actionContext.ModelState.IsValid); 216Assert.False(actionContext.ModelState.IsValid); 254Assert.False(actionContext.ModelState.IsValid); 295Assert.False(actionContext.ModelState.IsValid); 347Assert.False(actionContext.ModelState.IsValid); 402Assert.False(actionContext.ModelState.IsValid); 457Assert.False(actionContext.ModelState.IsValid); 511Assert.False(actionContext.ModelState.IsValid); 569Assert.False(modelState.IsValid); 629Assert.False(result.IsModelSet); 630Assert.False(modelState.IsValid); 698Assert.False(modelState.IsValid);
ModelBinding\PrefixContainerTest.cs (3)
19Assert.False(result); 69Assert.False(result); 110Assert.False(result);
ModelBinding\RouteValueProviderTests.cs (1)
210Assert.False(result);
ModelBinding\Validation\DefaultModelValidatorProviderTest.cs (1)
167Assert.False(result);
ModelBinding\Validation\DefaultObjectValidatorTests.cs (17)
95Assert.False(modelState.IsValid); 234Assert.False(modelState.IsValid); 309Assert.False(modelState.IsValid); 341Assert.False(modelState.IsValid); 373Assert.False(modelState.IsValid); 486Assert.False(modelState.IsValid); 533Assert.False(modelState.IsValid); 663Assert.False(modelState.IsValid); 699Assert.False(modelState.IsValid); 739Assert.False(modelState.IsValid); 800Assert.False(modelState.IsValid); 843Assert.False(modelState.IsValid); 1042Assert.False(modelState.IsValid); 1241Assert.False(modelState.IsValid); 1329Assert.False(actionContext.ModelState.IsValid); 1355Assert.False(modelState.IsValid); 1439Assert.False(modelState.IsValid);
ModelBinding\Validation\ValidationStackTest.cs (2)
22Assert.False(validationStack.Push(model)); 42Assert.False(validationStack.Contains(model));
RedirectResultTest.cs (3)
44Assert.False(result.PreserveMethod); 45Assert.False(result.Permanent); 59Assert.False(result.PreserveMethod);
RequireHttpsAttributeTests.cs (1)
100Assert.False(result.Permanent);
Routing\ActionEndpointFactoryTest.cs (3)
153Assert.False(endpoint.RoutePattern.Defaults.ContainsKey("action")); 235Assert.False(endpoint.RoutePattern.RequiredValues.ContainsKey("page")); 253Assert.False(endpoint.RoutePattern.RequiredValues.ContainsKey("page"));
Routing\DynamicControllerEndpointMatcherPolicyTest.cs (3)
125Assert.False(candidates.IsValidCandidate(0)); 156Assert.False(candidates.IsValidCandidate(0)); 329Assert.False(candidates.IsValidCandidate(0));
Routing\KnownRouteValueConstraintTests.cs (3)
79Assert.False(match); 153Assert.False(match); 178Assert.False(match);
Routing\UrlHelperTestBase.cs (14)
73Assert.False(result); 120Assert.False(result); 137Assert.False(result); 152Assert.False(result); 167Assert.False(result); 181Assert.False(result); 198Assert.False(result); 216Assert.False(result); 235Assert.False(result); 252Assert.False(result); 271Assert.False(result); 286Assert.False(result); 304Assert.False(result); 323Assert.False(result);
src\Shared\ResultsTests\FileContentResultTestBase.cs (1)
327Assert.False(httpResponse.Headers.ContainsKey(HeaderNames.ContentType));
src\Shared\ResultsTests\FileStreamResultTestBase.cs (13)
67Assert.False(readStream.CanSeek); 108Assert.False(readStream.CanSeek); 145Assert.False(readStream.CanSeek); 182Assert.False(readStream.CanSeek); 216Assert.False(readStream.CanSeek); 252Assert.False(readStream.CanSeek); 288Assert.False(readStream.CanSeek); 322Assert.False(httpResponse.Headers.ContainsKey(HeaderNames.ContentType)); 325Assert.False(readStream.CanSeek); 368Assert.False(readStream.CanSeek); 392Assert.False(originalStream.CanSeek); 418Assert.False(originalStream.CanSeek); 436Assert.False(readStream.CanSeek);
src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (1)
262Assert.False(httpResponse.Headers.ContainsKey(HeaderNames.ContentType));
src\Shared\ResultsTests\VirtualFileResultTestBase.cs (1)
312Assert.False(httpResponse.Headers.ContainsKey(HeaderNames.ContentType));
Microsoft.AspNetCore.Mvc.Core.TestCommon (6)
CommonFilterTest.cs (2)
108Assert.False(context.Cancel); 146Assert.False(context.Cancel);
CommonResourceInvokerTest.cs (4)
1010Assert.False(c.ExceptionHandled); 1052Assert.False(context.ExceptionHandled); 1088Assert.False(c.ExceptionHandled); 1130Assert.False(context.ExceptionHandled);
Microsoft.AspNetCore.Mvc.DataAnnotations.Test (17)
DataAnnotationsMetadataProviderTest.cs (5)
1191Assert.False(((RequiredAttribute)attribute).AllowEmptyStrings); // Default for [Required] 1608Assert.False(result); 1627Assert.False(result); 1644Assert.False(result); 1678Assert.False(result);
DataAnnotationsModelValidatorProviderTest.cs (1)
149Assert.False(result);
ModelMetadataProviderTest.cs (11)
70Assert.False(provider.GetMetadataForProperty(type, "ScaffoldColumnFalse").ShowForDisplay); 83Assert.False(provider.GetMetadataForProperty(type, "ScaffoldColumnFalse").ShowForEdit); 690Assert.False(metadata.IsRequired); 735Assert.False(metadata.IsBindingRequired); 750Assert.False(metadata.IsBindingRequired); 810Assert.False(metadata.IsBindingRequired); 842Assert.False(metadata.IsBindingRequired); 857Assert.False(metadata.IsBindingAllowed); 858Assert.False(metadata.IsBindingRequired); 873Assert.False(metadata.IsBindingAllowed); 874Assert.False(metadata.IsBindingRequired);
Microsoft.AspNetCore.Mvc.Formatters.Xml.Test (38)
XmlDataContractSerializerInputFormatterTest.cs (15)
158Assert.False(result.HasError); 189Assert.False(result.HasError); 194Assert.False(testBufferedReadStream.Disposed); 222Assert.False(result.HasError); 257Assert.False(result.HasError); 289Assert.False(result.HasError); 316Assert.False(result.HasError); 350Assert.False(result.HasError); 382Assert.False(result.HasError); 408Assert.False(result.HasError); 470Assert.False(result.HasError); 553Assert.False(result.HasError); 591Assert.False(result.HasError); 651Assert.False(result.HasError); 710Assert.False(result.HasError);
XmlDataContractSerializerOutputFormatterTest.cs (5)
147Assert.False(writerSettings.CloseOutput); 148Assert.False(writerSettings.CheckCharacters); 664Assert.False(result); 682Assert.False(canWriteResult); 742Assert.False(iterated);
XmlSerializerInputFormatterTest.cs (13)
63Assert.False(result.HasError); 100Assert.False(result.HasError); 136Assert.False(result.HasError); 172Assert.False(result.HasError); 216Assert.False(result.HasError); 352Assert.False(result.HasError); 386Assert.False(result.HasError); 415Assert.False(result.HasError); 487Assert.False(result.HasError); 573Assert.False(result.HasError); 612Assert.False(result.HasError); 644Assert.False(result.HasError); 649Assert.False(testBufferedReadStream.Disposed);
XmlSerializerOutputFormatterTest.cs (5)
153Assert.False(writerSettings.CloseOutput); 154Assert.False(writerSettings.CheckCharacters); 481Assert.False(canWriteResult); 500Assert.False(canWriteResult); 524Assert.False(iterated);
Microsoft.AspNetCore.Mvc.FunctionalTests (30)
ApiExplorerTest.cs (11)
191Assert.False(parameter.RouteInfo.IsOptional); 214Assert.False(parameter.RouteInfo.IsOptional); 237Assert.False(parameter.RouteInfo.IsOptional); 261Assert.False(parameter.RouteInfo.IsOptional); 287Assert.False(month.RouteInfo.IsOptional); 292Assert.False(day.RouteInfo.IsOptional); 297Assert.False(year.RouteInfo.IsOptional); 323Assert.False(month.RouteInfo.IsOptional); 1164Assert.False(parameter.IsRequired); 1174Assert.False(parameter.IsRequired); 1556Assert.False(responseType.IsDefaultResponse);
ConsumesAttributeTests.cs (1)
23Assert.False(result);
HtmlGenerationTest.cs (1)
779Assert.False(lastName.HasAttribute("data-val-regex"));
KeyedServicesTests.cs (1)
99Assert.False(response.IsSuccessStatusCode);
RequestServicesTest.cs (1)
23Assert.False(result);
RoutingDynamicOrderTest.cs (1)
97Assert.False(content.RouteValues.TryGetValue("identifier", out var identifier));
RoutingTests.cs (1)
25Assert.False(result);
RoutingTestsBase.cs (1)
100Assert.False(result.RouteValues.ContainsKey("page"));
TempDataInCookiesTest.cs (3)
85Assert.False(cookieTempDataProviderCookie.Secure); 135Assert.False(setCookieHeader.Secure); 188Assert.False(setCookieHeader.Secure);
TestingInfrastructureInheritanceTests.cs (8)
29Assert.False(factory.CreateServerWithServiceProviderCalled); 32Assert.False(factory.GetTestAssembliesCalled); 34Assert.False(factory.CreateHostCalled); 49Assert.False(factory.GetTestAssembliesCalled); 52Assert.False(factory.CreateServerIWebHostBuilderCalled); 54Assert.False(factory.CreateWebHostBuilderCalled); 122Assert.False(factory.GetTestAssembliesCalled); 125Assert.False(factory.CreateServerIWebHostBuilderCalled);
VersioningTests.cs (1)
23Assert.False(result);
Microsoft.AspNetCore.Mvc.IntegrationTests (138)
ActionParametersIntegrationTest.cs (2)
660Assert.False(modelBindingResult.IsModelSet); 701Assert.False(modelState.IsValid);
BinderTypeBasedModelBinderIntegrationTest.cs (1)
72Assert.False(modelBindingResult.IsModelSet);
BindPropertyIntegrationTest.cs (2)
99Assert.False(result.IsModelSet); 132Assert.False(result.IsModelSet);
BodyValidationIntegrationTests.cs (10)
130Assert.False(modelState.IsValid); 176Assert.False(modelState.IsValid); 215Assert.False(modelState.IsValid); 294Assert.False(modelState.IsValid); 336Assert.False(modelState.IsValid); 390Assert.False(modelState.IsValid); 476Assert.False(modelState.IsValid); 583Assert.False(modelState.IsValid); 636Assert.False(modelState.IsValid); 733Assert.False(modelState.IsValid);
ByteArrayModelBinderIntegrationTest.cs (1)
95Assert.False(modelBindingResult.IsModelSet);
CancellationTokenModelBinderIntegrationTest.cs (3)
46Assert.False(boundPerson.Token.IsCancellationRequested); 82Assert.False(boundPerson.Token.IsCancellationRequested); 120Assert.False(token.IsCancellationRequested);
CollectionModelBinderIntegrationTest.cs (6)
318Assert.False(modelState.IsValid); 377Assert.False(modelState.IsValid); 428Assert.False(modelState.IsValid); 523Assert.False(modelState.IsValid); 674Assert.False(modelState.IsValid); 716Assert.False(modelState.IsValid);
ComplexRecordIntegrationTest.cs (12)
1989Assert.False(modelState.IsValid); 2045Assert.False(modelState.IsValid); 2099Assert.False(modelState.IsValid); 2153Assert.False(modelState.IsValid); 2211Assert.False(modelState.IsValid); 2265Assert.False(modelState.IsValid); 2317Assert.False(modelState.IsValid); 2413Assert.False(modelState.IsValid); 2465Assert.False(modelState.IsValid); 2563Assert.False(modelState.IsValid); 2624Assert.False(modelState.IsValid); 4191Assert.False(modelState.IsValid);
ComplexTypeIntegrationTestBase.cs (13)
1889Assert.False(modelState.IsValid); 1938Assert.False(modelState.IsValid); 2143Assert.False(modelState.IsValid); 2198Assert.False(modelState.IsValid); 2261Assert.False(modelState.IsValid); 2315Assert.False(modelState.IsValid); 2373Assert.False(modelState.IsValid); 2431Assert.False(modelState.IsValid); 2483Assert.False(modelState.IsValid); 2583Assert.False(modelState.IsValid); 2635Assert.False(modelState.IsValid); 2736Assert.False(modelState.IsValid); 2797Assert.False(modelState.IsValid);
DictionaryModelBinderIntegrationTest.cs (8)
455Assert.False(modelBindingResult.IsModelSet); 807Assert.False(modelState.IsValid); 877Assert.False(modelBindingResult.IsModelSet); 1352Assert.False(modelState.IsValid); 1382Assert.False(modelBindingResult.IsModelSet); 1386Assert.False(modelState.IsValid); 1424Assert.False(modelState.IsValid); 1505Assert.False(modelState.IsValid);
ExcludeBindingMetadataProviderIntegrationTest.cs (1)
57Assert.False(modelBinderProvider.Invoked);
FormFileModelBindingIntegrationTest.cs (1)
681Assert.False(modelBindingResult.IsModelSet);
HeaderModelBinderIntegrationTest.cs (1)
59Assert.False(modelState.IsValid);
KeyValuePairModelBinderIntegrationTest.cs (10)
73Assert.False(modelBindingResult.IsModelSet); 76Assert.False(modelState.IsValid); 123Assert.False(modelBindingResult.IsModelSet); 126Assert.False(modelState.IsValid); 160Assert.False(modelBindingResult.IsModelSet); 163Assert.False(modelState.IsValid); 210Assert.False(modelBindingResult.IsModelSet); 213Assert.False(modelState.IsValid); 338Assert.False(modelState.IsValid); 503Assert.False(modelState.IsValid);
NullableReferenceTypeIntegrationTest.cs (4)
48Assert.False(modelState.IsValid); 135Assert.False(modelState.IsValid); 184Assert.False(modelBindingResult.IsModelSet); 190Assert.False(modelState.IsValid);
SimpleTypeModelBinderIntegrationTest.cs (9)
180Assert.False(modelBindingResult.IsModelSet); 386Assert.False(modelBindingResult.IsModelSet); 392Assert.False(modelState.IsValid); 446Assert.False(modelBindingResult.IsModelSet); 452Assert.False(modelState.IsValid); 495Assert.False(modelBindingResult.IsModelSet); 501Assert.False(modelState.IsValid); 549Assert.False(modelBindingResult.IsModelSet); 555Assert.False(modelState.IsValid);
TryValidateModelIntegrationTest.cs (8)
38Assert.False(result); 39Assert.False(modelState.IsValid); 118Assert.False(result); 119Assert.False(modelState.IsValid); 145Assert.False(result); 146Assert.False(modelState.IsValid); 166Assert.False(result); 167Assert.False(modelState.IsValid);
ValidationIntegrationTests.cs (23)
112Assert.False(modelState.IsValid); 229Assert.False(modelState.IsValid); 318Assert.False(modelState.IsValid); 412Assert.False(modelState.IsValid); 502Assert.False(modelState.IsValid); 590Assert.False(modelState.IsValid); 666Assert.False(modelState.IsValid); 745Assert.False(modelState.IsValid); 833Assert.False(modelState.IsValid); 968Assert.False(modelState.IsValid); 1075Assert.False(modelState.IsValid); 1163Assert.False(modelState.IsValid); 1241Assert.False(modelState.IsValid); 1281Assert.False(modelState.IsValid); 1371Assert.False(modelState.IsValid); 1420Assert.False(modelState.IsValid); 1854Assert.False(modelState.IsValid); 1900Assert.False(modelState.IsValid); 1947Assert.False(modelState.IsValid); 2104Assert.False(modelState.IsValid); 2175Assert.False(modelState.IsValid); 2287Assert.False(modelState.IsValid); 2394Assert.False(modelState.IsValid);
ValidationWithRecordIntegrationTests.cs (23)
104Assert.False(modelState.IsValid); 217Assert.False(modelState.IsValid); 299Assert.False(modelState.IsValid); 384Assert.False(modelState.IsValid); 467Assert.False(modelState.IsValid); 549Assert.False(modelState.IsValid); 628Assert.False(modelState.IsValid); 709Assert.False(modelState.IsValid); 837Assert.False(modelState.IsValid); 937Assert.False(modelState.IsValid); 1021Assert.False(modelState.IsValid); 1093Assert.False(modelState.IsValid); 1133Assert.False(modelState.IsValid); 1215Assert.False(modelState.IsValid); 1264Assert.False(modelState.IsValid); 1657Assert.False(modelState.IsValid); 1703Assert.False(modelState.IsValid); 1750Assert.False(modelState.IsValid); 1895Assert.False(modelState.IsValid); 1966Assert.False(modelState.IsValid); 2078Assert.False(modelState.IsValid); 2182Assert.False(modelState.IsValid); 2445Assert.False(modelState.IsValid);
Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (32)
NewtonsoftJsonInputFormatterTest.cs (11)
50Assert.False(result.HasError); 86Assert.False(result.HasError); 124Assert.False(result.HasError); 130Assert.False(httpContext.Request.Body.CanSeek); 134Assert.False(result.HasError); 170Assert.False(formatterContext.ModelState.IsValid); 367Assert.False(formatterContext.ModelState.IsValid); 398Assert.False(formatterContext.ModelState.IsValid); 429Assert.False(formatterContext.ModelState.IsValid); 514Assert.False(result.HasError); 557Assert.False(result.HasError);
NewtonsoftJsonOutputFormatterTest.cs (1)
463Assert.False(iterated);
NewtonsoftJsonPatchInputFormatterTest.cs (7)
49Assert.False(result.HasError); 88Assert.False(result.HasError); 95Assert.False(httpContext.Request.Body.CanSeek); 99Assert.False(result.HasError); 119Assert.False(result.HasError); 143Assert.False(result.HasError); 195Assert.False(result);
src\Mvc\Mvc.Core\test\Formatters\JsonInputFormatterTestBase.cs (10)
79Assert.False(result.HasError); 100Assert.False(result.HasError); 121Assert.False(result.HasError); 227Assert.False(result.HasError); 248Assert.False(result.HasError); 270Assert.False(result.HasError); 302Assert.False(result.HasError); 434Assert.False(formatterContext.ModelState.ContainsKey("age")); 462Assert.False(result.HasError); 557Assert.False(testBufferedReadStream.Disposed);
src\Mvc\Mvc.Core\test\Infrastructure\AsyncEnumerableReaderTest.cs (1)
26Assert.False(result);
src\Mvc\Mvc.Core\test\Infrastructure\JsonResultExecutorTestBase.cs (2)
380Assert.False(iterated); 414Assert.False(iterated);
Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation.Test (8)
ChecksumValidatorTest.cs (5)
24Assert.False(result); 40Assert.False(result); 125Assert.False(result); 144Assert.False(result); 164Assert.False(result);
CSharpCompilerTest.cs (2)
95Assert.False(compilationOptions.AllowUnsafe); 197Assert.False(compiler.EmitPdb);
FileProviderRazorProjectFileSystemTest.cs (1)
239Assert.False(item.Exists);
Microsoft.AspNetCore.Mvc.Razor.Test (12)
Compilation\DefaultRazorPageFactoryProviderTest.cs (1)
38Assert.False(result.Success);
RazorViewEngineTest.cs (11)
78Assert.False(result.Success); 94Assert.False(result.Success); 110Assert.False(result.Success); 125Assert.False(result.Success); 233Assert.False(result.Success); 249Assert.False(result.Success); 265Assert.False(result.Success); 287Assert.False(result.Success); 982Assert.False(result.Success); 990Assert.False(result.Success); 1041Assert.False(result.Success);
Microsoft.AspNetCore.Mvc.RazorPages.Test (113)
ApplicationModels\DefaultPageApplicationModelProviderTest.cs (1)
1018Assert.False(result);
ApplicationModels\PageRouteModelFactoryTest.cs (2)
179Assert.False(success); 196Assert.False(success);
DependencyInjection\PageConventionCollectionExtensionsTest.cs (4)
905Assert.False(selector.AttributeRouteModel.SuppressLinkGeneration); 915Assert.False(selector.AttributeRouteModel.SuppressLinkGeneration); 956Assert.False(selector.AttributeRouteModel.SuppressLinkGeneration); 971Assert.False(selector.AttributeRouteModel.SuppressLinkGeneration);
Filters\PageSaveTempDataPropertyFilterTest.cs (1)
39Assert.False(tempData.ContainsKey("TestDataProperty-Test2"));
Infrastructure\DefaultPageActivatorProviderTest.cs (1)
188Assert.False(page.SyncDisposed);
Infrastructure\DefaultPageModelActivatorProviderTest.cs (1)
213Assert.False(model.SyncDisposed);
Infrastructure\DynamicPageEndpointMatcherPolicyTest.cs (3)
142Assert.False(candidates.IsValidCandidate(0)); 173Assert.False(candidates.IsValidCandidate(0)); 332Assert.False(candidates.IsValidCandidate(0));
Infrastructure\PageActionInvokerTest.cs (4)
1063Assert.False(c.ExceptionHandled); 1098Assert.False(c.ExceptionHandled); 1142Assert.False(context.ExceptionHandled); 1189Assert.False(c.ExceptionHandled);
Infrastructure\PageBinderFactoryTest.cs (2)
566Assert.False(modelState.IsValid); 696Assert.False(modelState.IsValid);
PageModelTest.cs (47)
43Assert.False(result.PreserveMethod); 44Assert.False(result.Permanent); 60Assert.False(result.PreserveMethod); 78Assert.False(result.Permanent); 141Assert.False(result.PreserveMethod); 142Assert.False(result.Permanent); 158Assert.False(result.PreserveMethod); 176Assert.False(result.Permanent); 283Assert.False(resultTemporary.PreserveMethod); 284Assert.False(resultTemporary.Permanent); 300Assert.False(resultTemporary.Permanent); 315Assert.False(resultPermanent.PreserveMethod); 350Assert.False(resultTemporary.PreserveMethod); 351Assert.False(resultTemporary.Permanent); 371Assert.False(resultTemporary.Permanent); 390Assert.False(resultPermanent.PreserveMethod); 430Assert.False(resultTemporary.PreserveMethod); 431Assert.False(resultTemporary.Permanent); 455Assert.False(resultTemporary.Permanent); 478Assert.False(resultPermanent.PreserveMethod); 523Assert.False(resultTemporary.PreserveMethod); 524Assert.False(resultTemporary.Permanent); 544Assert.False(resultTemporary.Permanent); 566Assert.False(result.PreserveMethod); 567Assert.False(result.Permanent); 592Assert.False(result.Permanent); 613Assert.False(resultPermanent.PreserveMethod); 656Assert.False(result.PreserveMethod); 707Assert.False(resultTemporary.PreserveMethod); 708Assert.False(resultTemporary.Permanent); 727Assert.False(resultTemporary.Permanent); 747Assert.False(result.PreserveMethod); 748Assert.False(result.Permanent); 771Assert.False(result.Permanent); 791Assert.False(resultPermanent.PreserveMethod); 831Assert.False(result.PreserveMethod); 873Assert.False(resultTemporary.PreserveMethod); 874Assert.False(resultTemporary.Permanent); 891Assert.False(resultTemporary.Permanent); 907Assert.False(resultPermanent.PreserveMethod); 1241Assert.False(result.Permanent); 1261Assert.False(resultPermanent.Permanent); 1302Assert.False(resultTemporary.PreserveMethod); 1303Assert.False(resultTemporary.Permanent); 1324Assert.False(resultTemporary.Permanent); 1344Assert.False(resultPermanent.PreserveMethod); 1773Assert.False(result);
PageTest.cs (47)
63Assert.False(result.PreserveMethod); 64Assert.False(result.Permanent); 80Assert.False(result.PreserveMethod); 98Assert.False(result.Permanent); 161Assert.False(result.PreserveMethod); 162Assert.False(result.Permanent); 178Assert.False(result.PreserveMethod); 196Assert.False(result.Permanent); 303Assert.False(resultTemporary.PreserveMethod); 304Assert.False(resultTemporary.Permanent); 320Assert.False(resultTemporary.Permanent); 335Assert.False(resultPermanent.PreserveMethod); 370Assert.False(resultTemporary.PreserveMethod); 371Assert.False(resultTemporary.Permanent); 391Assert.False(resultTemporary.Permanent); 410Assert.False(resultPermanent.PreserveMethod); 450Assert.False(resultTemporary.PreserveMethod); 451Assert.False(resultTemporary.Permanent); 475Assert.False(resultTemporary.Permanent); 498Assert.False(resultPermanent.PreserveMethod); 543Assert.False(resultTemporary.PreserveMethod); 544Assert.False(resultTemporary.Permanent); 564Assert.False(resultTemporary.Permanent); 586Assert.False(result.PreserveMethod); 587Assert.False(result.Permanent); 612Assert.False(result.Permanent); 633Assert.False(resultPermanent.PreserveMethod); 676Assert.False(result.PreserveMethod); 727Assert.False(resultTemporary.PreserveMethod); 728Assert.False(resultTemporary.Permanent); 747Assert.False(resultTemporary.Permanent); 767Assert.False(result.PreserveMethod); 768Assert.False(result.Permanent); 791Assert.False(result.Permanent); 811Assert.False(resultPermanent.PreserveMethod); 851Assert.False(result.PreserveMethod); 893Assert.False(resultTemporary.PreserveMethod); 894Assert.False(resultTemporary.Permanent); 911Assert.False(resultTemporary.Permanent); 927Assert.False(resultPermanent.PreserveMethod); 964Assert.False(resultTemporary.PreserveMethod); 965Assert.False(resultTemporary.Permanent); 986Assert.False(resultTemporary.Permanent); 1006Assert.False(resultPermanent.PreserveMethod); 1315Assert.False(result.Permanent); 1335Assert.False(resultPermanent.Permanent); 1851Assert.False(result);
Microsoft.AspNetCore.Mvc.TagHelpers.Test (38)
AttributeMatcherTest.cs (1)
34Assert.False(modeMatch);
CacheTagHelperTest.cs (4)
533Assert.False(result); 694Assert.False(tagHelperOutput1.IsContentModified); 758Assert.False(tagHelperOutput1.IsContentModified); 770Assert.False(tagHelperOutput2.IsContentModified);
DistributedCacheTagHelperTest.cs (1)
706Assert.False(tagHelperOutput1.IsContentModified);
EnvironmentTagHelperTest.cs (2)
103Assert.False(output.IsContentModified); 205Assert.False(output.IsContentModified);
FormActionTagHelperTest.cs (10)
81Assert.False(output.IsContentModified); 82Assert.False(output.PostContent.IsModified); 83Assert.False(output.PostElement.IsModified); 84Assert.False(output.PreContent.IsModified); 85Assert.False(output.PreElement.IsModified); 155Assert.False(output.IsContentModified); 156Assert.False(output.PostContent.IsModified); 157Assert.False(output.PostElement.IsModified); 158Assert.False(output.PreContent.IsModified); 159Assert.False(output.PreElement.IsModified);
InputTagHelperTest.cs (13)
392Assert.False(output.IsContentModified); 448Assert.False(output.IsContentModified); 451Assert.False(viewContext.FormContext.HasEndOfFormContent); 499Assert.False(output.IsContentModified); 555Assert.False(output.IsContentModified); 955Assert.False(output.IsContentModified); 958Assert.False(viewContext.FormContext.HasEndOfFormContent); 1015Assert.False(output.IsContentModified); 1018Assert.False(viewContext.FormContext.HasEndOfFormContent); 1075Assert.False(output.IsContentModified); 1135Assert.False(output.IsContentModified); 1138Assert.False(viewContext.FormContext.HasEndOfFormContent); 1378Assert.False(output.IsContentModified);
LinkTagHelperTest.cs (3)
318Assert.False(output.IsContentModified); 541Assert.False(output.IsContentModified); 560Assert.False(output.IsContentModified);
ScriptTagHelperTest.cs (3)
294Assert.False(output.IsContentModified); 469Assert.False(output.IsContentModified); 489Assert.False(output.IsContentModified);
SelectTagHelperTest.cs (1)
772Assert.False(output.IsContentModified);
Microsoft.AspNetCore.Mvc.Test (15)
MvcOptionsSetupTest.cs (1)
153Assert.False(options.RespectBrowserAcceptHeader);
Routing\ActionConstraintMatcherPolicyTest.cs (14)
70Assert.False(candidateSet.IsValidCandidate(1)); 104Assert.False(candidateSet.IsValidCandidate(0)); 105Assert.False(candidateSet.IsValidCandidate(1)); 140Assert.False(candidateSet.IsValidCandidate(0)); 141Assert.False(candidateSet.IsValidCandidate(1)); 176Assert.False(candidateSet.IsValidCandidate(1)); 213Assert.False(candidateSet.IsValidCandidate(0)); 214Assert.False(candidateSet.IsValidCandidate(1)); 248Assert.False(candidateSet.IsValidCandidate(0)); 250Assert.False(candidateSet.IsValidCandidate(2)); 290Assert.False(candidateSet.IsValidCandidate(1)); 331Assert.False(candidateSet.IsValidCandidate(1)); 332Assert.False(candidateSet.IsValidCandidate(2)); 404Assert.False(result);
Microsoft.AspNetCore.Mvc.ViewFeatures.Test (42)
AttributeDictionaryTest.cs (6)
111Assert.False(result); 145Assert.False(result); 182Assert.False(result); 243Assert.False(result); 288Assert.False(result); 333Assert.False(result);
CookieTempDataProviderTest.cs (2)
210Assert.False(cookieInfo.Options.Secure); 260Assert.False(cookieInfo.Options.Secure);
DefaultHtmlGeneratorTest.cs (1)
410Assert.False(didForceInvariantFormatting);
PartialViewResultExecutorTest.cs (5)
130Assert.False(result.Success); 165Assert.False(result.Success); 200Assert.False(result.Success); 234Assert.False(listener.ViewFound.IsMainPage); 271Assert.False(viewEngineResult.Success);
Rendering\HtmlHelperCheckboxTest.cs (2)
185Assert.False(helper.ViewContext.FormContext.HasEndOfFormContent); 252Assert.False(helper.ViewContext.FormContext.HasEndOfFormContent);
Rendering\HtmlHelperSelectTest.cs (2)
1562Assert.False(actualItem.Disabled); 1564Assert.False(actualItem.Selected);
Rendering\TagBuilderTest.cs (1)
193Assert.False(tagBuilder.HasInnerHtml);
SkipStatusCodePagesAttributeTest.cs (1)
28Assert.False(statusCodePagesFeature.Enabled);
TempDataDictionaryTest.cs (8)
36Assert.False(tempData.ContainsKey("Foo")); 57Assert.False(tempData.ContainsKey("Foo")); 58Assert.False(tempData.ContainsKey("Bar")); 73Assert.False(tempData.ContainsKey("Foo")); 109Assert.False(tempData.ContainsKey("Bar")); 159Assert.False(tempData.ContainsKey("foo")); 176Assert.False(tempData.ContainsKey("Foo")); 177Assert.False(tempData.ContainsKey("Boo"));
ViewComponents\DefaultViewComponentActivatorTests.cs (1)
78Assert.False(instance.SyncDisposed);
ViewDataOfTTest.cs (1)
58Assert.False(viewData.IsReadOnly);
ViewEngines\CompositeViewEngineTest.cs (6)
66Assert.False(result.Success); 155Assert.False(result.Success); 198Assert.False(result.Success); 296Assert.False(result.Success); 333Assert.False(result.Success); 422Assert.False(result.Success);
ViewExecutorTest.cs (2)
211Assert.False(viewDataNull); 212Assert.False(tempDataNull);
ViewResultExecutorTest.cs (4)
128Assert.False(result.Success); 162Assert.False(result.Success); 196Assert.False(result.Success); 266Assert.False(viewEngineResult.Success);
Microsoft.AspNetCore.OpenApi.Tests (37)
Extensions\JsonNodeSchemaExtensionsTests.cs (8)
122Assert.False(schema.TryGetPropertyValue("minimum", out _)); 123Assert.False(schema.TryGetPropertyValue("maximum", out _)); 129Assert.False(schema.TryGetPropertyValue("exclusiveMinimum", out _)); 130Assert.False(schema.TryGetPropertyValue("exclusiveMaximum", out _)); 145Assert.False(schema.TryGetPropertyValue("minimum", out _)); 146Assert.False(schema.TryGetPropertyValue("maximum", out _)); 147Assert.False(schema.TryGetPropertyValue("exclusiveMinimum", out _)); 148Assert.False(schema.TryGetPropertyValue("exclusiveMaximum", out _));
Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Parameters.cs (4)
86Assert.False(nullableQueryParameter.Required); 89Assert.False(defaultQueryParameter.Required); 112Assert.False(nullableHeaderParameter.Required); 115Assert.False(defaultHeaderParameter.Required);
Services\OpenApiDocumentService\OpenApiDocumentServiceTests.RequestBody.cs (8)
279Assert.False(operation.RequestBody.Required); 332Assert.False(operation.RequestBody.Required); 1152Assert.False(operation.RequestBody.Required); 1207Assert.False(operation.RequestBody.Required); 1277Assert.False(operation.RequestBody.Required); 1332Assert.False(operation.RequestBody.Required); 1414Assert.False(operation.RequestBody.Required); 1440Assert.False(operation.RequestBody.Required);
Services\OpenApiGeneratorTests.cs (11)
125Assert.False(request.Required); 522Assert.False(barParam.Required); 536Assert.False(fooParam.Required); 704Assert.False(requestBody.Required); 738Assert.False(requestBody.Required); 754Assert.False(requestBody.Required); 786Assert.False(requestBody.Required); 845Assert.False(fromFileParam1.Required); 990param => Assert.False(param.Required), 992param => Assert.False(param.Required)); 1010param => Assert.False(param.Required));
Services\OpenApiSchemaService\OpenApiSchemaService.RequestBodySchemas.cs (2)
156Assert.False(GetRequestBodyForPath(document, "/non-required-poco").Required); 813Assert.False(schema.AdditionalPropertiesAllowed);
Transformers\CustomSchemaTransformerTests.cs (2)
297Assert.False(document.Components.Schemas.ContainsKey("NestedItem")); 495Assert.False(schema.Properties.ContainsKey("temporaryData"));
Transformers\Implementations\OpenApiSchemaReferenceTransformerTests.cs (1)
301Assert.False(responseSchema.Extensions.TryGetValue("x-my-extension", out var _));
Transformers\SchemaTransformerTests.cs (1)
233Assert.False(responseSchema.Extensions.TryGetValue("x-my-extension", out var _));
Microsoft.AspNetCore.OutputCaching.Tests (33)
OutputCacheAttributeTests.cs (2)
42Assert.False(context.EnableOutputCaching); 71Assert.False(context.EnableOutputCaching);
OutputCacheMiddlewareTests.cs (8)
61Assert.False(await middleware.TryServeFromCacheAsync(context, policies)); 165Assert.False(middleware.ContentIsNotModified(context)); 198Assert.False(middleware.ContentIsNotModified(context)); 240Assert.False(middleware.ContentIsNotModified(context)); 285Assert.False(middleware.ContentIsNotModified(context)); 299Assert.False(middleware.ContentIsNotModified(context)); 346Assert.False(middleware.ContentIsNotModified(context)); 787Assert.False(await middleware.TryServeFromCacheAsync(context, policies));
OutputCachePoliciesTests.cs (6)
63Assert.False(context.EnableOutputCaching); 74Assert.False(context.CacheVaryByRules.VaryByHost); 108Assert.False(context.AllowLocking); 119Assert.False(context.AllowCacheLookup); 130Assert.False(context.AllowCacheStorage); 166Assert.False(context.EnableOutputCaching);
OutputCachePolicyBuilderTests.cs (10)
52Assert.False(context.EnableOutputCaching); 87Assert.False(context.EnableOutputCaching); 100Assert.False(context.CacheVaryByRules.VaryByHost); 283Assert.False(context.AllowLocking); 295Assert.False(context.AllowLocking); 296Assert.False(context.AllowCacheLookup); 297Assert.False(context.AllowCacheStorage); 298Assert.False(context.EnableOutputCaching); 310Assert.False(context.EnableOutputCaching); 362Assert.False(context.EnableOutputCaching);
OutputCachePolicyProviderTests.cs (6)
72Assert.False(context.AllowCacheLookup); 73Assert.False(context.AllowCacheStorage); 88Assert.False(context.AllowCacheStorage); 89Assert.False(context.AllowCacheLookup); 204Assert.False(context.AllowCacheStorage); 328Assert.False(context.AllowCacheStorage);
OutputCacheTests.cs (1)
1067Assert.False(subsequentResponse.Headers.Contains(HeaderNames.Age));
Microsoft.AspNetCore.Owin.Tests (6)
OwinEnvironmentTests.cs (4)
107Assert.False(env.TryGetValue(key, out value)); 111Assert.False(env.Keys.Contains(key)); 112Assert.False(env.ContainsKey(key)); 172Assert.False(env1.ContainsKey("owin.RequestProtocol"));
OwinExtensionTests.cs (2)
150Assert.False(environment.ContainsKey("websocket.Accept")); 151Assert.False(environment.ContainsKey("websocket.AcceptAlt"));
Microsoft.AspNetCore.RateLimiting.Tests (12)
RateLimitingMetricsTests.cs (1)
327Assert.False(tags.ContainsKey(tagName));
RateLimitingMiddlewareTests.cs (11)
246Assert.False(onRejectedInvoked); 279Assert.False(globalOnRejectedInvoked); 343Assert.False(globalOnRejectedInvoked); 418Assert.False(globalOnRejectedInvoked); 452Assert.False(globalOnRejectedInvoked); 458Assert.False(globalOnRejectedInvoked); 511Assert.False(globalOnRejectedInvoked); 539Assert.False(globalOnRejectedInvoked); 548Assert.False(globalOnRejectedInvoked); 578Assert.False(globalOnRejectedInvoked); 618Assert.False(globalOnRejectedInvoked);
Microsoft.AspNetCore.Razor.Test (12)
TagHelpers\DefaultTagHelperContentTest.cs (6)
23Assert.False(tagHelperContent.IsModified); 403Assert.False(tagHelperContent.IsEmptyOrWhiteSpace); 610Assert.False(tagHelperContent.IsEmptyOrWhiteSpace); 637Assert.False(tagHelperContent.IsEmptyOrWhiteSpace); 650Assert.False(tagHelperContent.IsEmptyOrWhiteSpace); 665Assert.False(tagHelperContent.IsEmptyOrWhiteSpace);
TagHelpers\NullHtmlEncoderTest.cs (1)
152Assert.False(result);
TagHelpers\TagHelperAttributeListTest.cs (1)
225Assert.False(isReadOnly);
TagHelpers\TagHelperOutputTest.cs (4)
56Assert.False(output.PreContent.IsModified); 57Assert.False(output.PostContent.IsModified); 58Assert.False(output.PreElement.IsModified); 59Assert.False(output.PostElement.IsModified);
Microsoft.AspNetCore.ResponseCaching.Tests (35)
ResponseCachingMiddlewareTests.cs (11)
44Assert.False(await middleware.TryServeFromCacheAsync(context)); 117Assert.False(await middleware.TryServeFromCacheAsync(context)); 183Assert.False(ResponseCachingMiddleware.ContentIsNotModified(context)); 209Assert.False(ResponseCachingMiddleware.ContentIsNotModified(context)); 243Assert.False(ResponseCachingMiddleware.ContentIsNotModified(context)); 284Assert.False(ResponseCachingMiddleware.ContentIsNotModified(context)); 296Assert.False(ResponseCachingMiddleware.ContentIsNotModified(context)); 339Assert.False(ResponseCachingMiddleware.ContentIsNotModified(context)); 408Assert.False(context.ShouldCacheResponse); 427Assert.False(context.ShouldCacheResponse); 873Assert.False(await middleware.TryServeFromCacheAsync(context));
ResponseCachingPolicyProviderTests.cs (23)
61Assert.False(new ResponseCachingPolicyProvider().AttemptResponseCaching(context)); 75Assert.False(new ResponseCachingPolicyProvider().AttemptResponseCaching(context)); 107Assert.False(new ResponseCachingPolicyProvider().AllowCacheLookup(context)); 121Assert.False(new ResponseCachingPolicyProvider().AllowCacheLookup(context)); 151Assert.False(new ResponseCachingPolicyProvider().AllowCacheStorage(context)); 161Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 192Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 209Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 226Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 243Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 260Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 354Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 395Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 437Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 479Assert.False(new ResponseCachingPolicyProvider().IsResponseCacheable(context)); 532Assert.False(new ResponseCachingPolicyProvider().IsCachedEntryFresh(context)); 574Assert.False(new ResponseCachingPolicyProvider().IsCachedEntryFresh(context)); 618Assert.False(new ResponseCachingPolicyProvider().IsCachedEntryFresh(context)); 641Assert.False(new ResponseCachingPolicyProvider().IsCachedEntryFresh(context)); 664Assert.False(new ResponseCachingPolicyProvider().IsCachedEntryFresh(context)); 735Assert.False(new ResponseCachingPolicyProvider().IsCachedEntryFresh(context)); 760Assert.False(new ResponseCachingPolicyProvider().IsCachedEntryFresh(context)); 785Assert.False(new ResponseCachingPolicyProvider().IsCachedEntryFresh(context));
ResponseCachingTests.cs (1)
971Assert.False(subsequentResponse.Headers.Contains(HeaderNames.Age));
Microsoft.AspNetCore.ResponseCompression.Tests (11)
ResponseCompressionMiddlewareTest.cs (11)
45Assert.False(options.EnableForHttps); 425Assert.False(response.Content.Headers.ContentEncoding.Contains("gzip")); 755Assert.False(response.Content.Headers.TryGetValues(HeaderNames.ContentMD5, out _)); 808Assert.False(response.Content.Headers.TryGetValues(HeaderNames.ContentMD5, out _)); 877Assert.False(response.Content.Headers.TryGetValues(HeaderNames.ContentMD5, out _)); 941Assert.False(response.Content.Headers.TryGetValues(HeaderNames.ContentMD5, out _)); 1119Assert.False(fakeSendFile.SendFileInvoked); 1169Assert.False(fakeSendFile.SendFileInvoked); 1217Assert.False(response.Content.Headers.TryGetValues(HeaderNames.ContentMD5, out _)); 1301Assert.False(response.Content.Headers.TryGetValues(HeaderNames.ContentMD5, out _)); 1323Assert.False(response.Headers.Contains(HeaderNames.Vary));
Microsoft.AspNetCore.Rewrite.Tests (3)
ApacheModRewrite\CookieActionFactoryTest.cs (1)
48Assert.False(action.Secure);
ApacheModRewrite\RuleRegexParserTest.cs (1)
26Assert.False(results.Invert);
IISUrlRewrite\FileParserTests.cs (1)
146Assert.False(rules[1].Global);
Microsoft.AspNetCore.Routing.FunctionalTests (10)
MinimalFormTests.cs (5)
69Assert.False(result.IsCompleted); 129Assert.False(result.IsCompleted); 290Assert.False(result.IsCompleted); 337Assert.False(result.IsCompleted); 497Assert.False(result.IsCompleted);
RouteHandlerTest.cs (2)
100Assert.False(testDisposeDataSource.IsDisposed); 101Assert.False(testGroupDisposeDataSource.IsDisposed);
ShortCircuitTests.cs (3)
55Assert.False(response.Headers.Contains("NotSet")); 92Assert.False(response1.Headers.Contains("NotSet")); 96Assert.False(response2.Headers.Contains("NotSet"));
Microsoft.AspNetCore.Routing.Tests (149)
Builder\GroupTest.cs (2)
227Assert.False(mapGetCalled); 373Assert.False(groupChangeToken.HasChanged);
Builder\OpenApiRouteHandlerBuilderExtensionsTest.cs (1)
118Assert.False(metadata.IsOptional);
Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (1)
222Assert.False(httpContext.Items.ContainsKey("ExecutedEndpoint"));
Builder\RouteHandlerEndpointRouteBuilderExtensionsTest.cs (1)
691Assert.False(endpointMetadata!.IsOptional);
CompositeEndpointDataSourceTest.cs (10)
167Assert.False(token.HasChanged); // initial state 180Assert.False(token.HasChanged); 194Assert.False(token.HasChanged); 207Assert.False(token.HasChanged); 219Assert.False(token.HasChanged); 230Assert.False(token.HasChanged); 243Assert.False(token.HasChanged); 254Assert.False(token.HasChanged); 266Assert.False(token.HasChanged); 278Assert.False(changeToken3.HasChanged);
ConstraintMatcherTest.cs (3)
132Assert.False(RouteConstraintMatcher.Match( 152Assert.False(RouteConstraintMatcher.Match( 172Assert.False(RouteConstraintMatcher.Match(
Constraints\FileNameRouteConstraintTest.cs (2)
79Assert.False(result); 94Assert.False(result);
Constraints\HttpMethodRouteConstraintTests.cs (2)
50Assert.False(result); 90Assert.False(result);
Constraints\NonFIleNameRouteConstraintTest.cs (1)
22Assert.False(result);
Constraints\RegexInlineRouteConstraintTests.cs (2)
57Assert.False(match); 87Assert.False(match);
Constraints\RegexRouteConstraintTests.cs (3)
80Assert.False(match); 99Assert.False(match); 129Assert.False(match);
Constraints\RequiredRouteConstraintTests.cs (3)
29Assert.False(result); 49Assert.False(result); 69Assert.False(result);
Constraints\StringRouteConstraintTest.cs (4)
68Assert.False(match); 88Assert.False(match); 108Assert.False(match); 128Assert.False(match);
DataSourceDependentCacheTest.cs (1)
48Assert.False(called);
DefaultLinkGeneratorProcessTemplateTest.cs (7)
665Assert.False(success); 715Assert.False(success); 965Assert.False(success); 1043Assert.False(success); 1097Assert.False(success); 1539Assert.False(success); 1647Assert.False(success);
EndpointRoutingMiddlewareFormOptionsTest.cs (2)
49Assert.False(formOptions.BufferBody); 121Assert.False(formOptions.BufferBody);
InlineRouteParameterParserTests.cs (10)
285Assert.False(param1.IsOptional); 295Assert.False(param2.IsOptional); 781Assert.False(templatePart.IsOptional); 811Assert.False(templatePart.IsOptional); 841Assert.False(templatePart.IsOptional); 856Assert.False(templatePart.IsOptional); 872Assert.False(templatePart.IsOptional); 887Assert.False(templatePart.IsOptional); 902Assert.False(templatePart.IsOptional); 917Assert.False(templatePart.IsOptional);
MatcherPolicyTest.cs (2)
44Assert.False(result); 57Assert.False(result);
Matching\AcceptsMatcherPolicyTest.cs (7)
26Assert.False(result); 44Assert.False(result); 82Assert.False(result); 153Assert.False(result); 535Assert.False(candidates.IsValidCandidate(0)); 564Assert.False(candidates.IsValidCandidate(0)); 593Assert.False(candidates.IsValidCandidate(0));
Matching\CandidateSetTest.cs (4)
40Assert.False(candidateSet.IsValidCandidate(i)); 103Assert.False(candidateSet.IsValidCandidate(i)); 133Assert.False(candidateSet.IsValidCandidate(0)); 366Assert.False(candidateSet.IsValidCandidate(i));
Matching\ContentEncodingNegotiationMatcherPolicyTest.cs (18)
50Assert.False(result); 87Assert.False(endpoints.IsValidCandidate(1)); 106Assert.False(endpoints.IsValidCandidate(0)); 127Assert.False(endpoints.IsValidCandidate(1)); 146Assert.False(endpoints.IsValidCandidate(0)); 166Assert.False(endpoints.IsValidCandidate(1)); 187Assert.False(endpoints.IsValidCandidate(1)); 205Assert.False(endpoints.IsValidCandidate(0)); 206Assert.False(endpoints.IsValidCandidate(1)); 226Assert.False(endpoints.IsValidCandidate(0)); 227Assert.False(endpoints.IsValidCandidate(1)); 248Assert.False(endpoints.IsValidCandidate(1)); 267Assert.False(endpoints.IsValidCandidate(1)); 285Assert.False(endpoints.IsValidCandidate(0)); 286Assert.False(endpoints.IsValidCandidate(1)); 305Assert.False(endpoints.IsValidCandidate(1)); 324Assert.False(endpoints.IsValidCandidate(1)); 342Assert.False(endpoints.IsValidCandidate(1));
Matching\EndpointComparerTest.cs (4)
120Assert.False(result); 136Assert.False(result); 152Assert.False(result); 168Assert.False(result);
Matching\HostMatcherPolicyTest.cs (4)
23Assert.False(result); 41Assert.False(result); 79Assert.False(result); 171Assert.False(result);
Matching\HttpMethodMatcherPolicyTest.cs (4)
24Assert.False(result); 42Assert.False(result); 80Assert.False(result); 151Assert.False(result);
Matching\ILEmitTrieFactoryTest.cs (1)
45Assert.False(actual);
Patterns\DefaultRoutePatternTransformerTest.cs (2)
205Assert.False(actual.Defaults.ContainsKey("controller")); 207Assert.False(actual.Defaults.ContainsKey("action"));
Patterns\InlineRouteParameterParserTest.cs (14)
277Assert.False(param1.IsOptional); 287Assert.False(param2.IsOptional); 773Assert.False(templatePart.IsOptional); 803Assert.False(templatePart.IsOptional); 833Assert.False(templatePart.IsOptional); 848Assert.False(templatePart.IsOptional); 864Assert.False(templatePart.IsOptional); 879Assert.False(templatePart.IsOptional); 894Assert.False(templatePart.IsOptional); 909Assert.False(templatePart.IsOptional); 1012Assert.False(parameterPart.EncodeSlashes); 1026Assert.False(parameterPart.EncodeSlashes); 1041Assert.False(parameterPart.EncodeSlashes); 1058Assert.False(parameterPart.EncodeSlashes);
Patterns\RoutePatternMatcherTest.cs (13)
41Assert.False(match); 74Assert.False(match); 235Assert.False(match); 266Assert.False(match); 330Assert.False(match); 345Assert.False(match); 931Assert.False(values.ContainsKey("action")); 949Assert.False(values.ContainsKey("controller")); 986Assert.False(values.ContainsKey("id")); 1007Assert.False(match); 1053Assert.False(match); 1087Assert.False(match); 1116Assert.False(match);
RouteEndpointBuilderTest.cs (2)
115(metadata) => Assert.False(metadata.AcceptCorsPreflight), 136Assert.False(httpMethodMetadata.AcceptCorsPreflight);
RouteHandlerOptionsTests.cs (1)
66Assert.False(options.Value.ThrowOnBadRequest);
RouteTest.cs (2)
285Assert.False(routeValues.ContainsKey("id")); 286Assert.False(context.RouteData.Values.ContainsKey("id"));
Template\TemplateBinderTests.cs (1)
1223Assert.False(TemplateBinder.RoutePartsEqual(left, right));
Template\TemplateMatcherTests.cs (13)
40Assert.False(match); 73Assert.False(match); 234Assert.False(match); 265Assert.False(match); 329Assert.False(match); 344Assert.False(match); 930Assert.False(values.ContainsKey("action")); 948Assert.False(values.ContainsKey("controller")); 985Assert.False(values.ContainsKey("id")); 1006Assert.False(match); 1052Assert.False(match); 1086Assert.False(match); 1115Assert.False(match);
Tree\LinkGenerationDecisionTreeTest.cs (2)
91Assert.False(match.IsFallbackMatch); 115Assert.False(match.IsFallbackMatch);
Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (99)
AuthenticationTests.cs (13)
34Assert.False(httpContext.User.Identity.IsAuthenticated); 73Assert.False(httpContext.User.Identity.IsAuthenticated); 99Assert.False(httpContext.User.Identity.IsAuthenticated); 125Assert.False(httpContext.User.Identity.IsAuthenticated); 190Assert.False(string.IsNullOrEmpty(userName)); 207Assert.False(httpContext.User.Identity.IsAuthenticated); 209Assert.False(authResults.Succeeded); 254Assert.False(httpContext.User.Identity.IsAuthenticated); 277Assert.False(httpContext.User.Identity.IsAuthenticated); 295Assert.False(httpContext.User.Identity.IsAuthenticated); 321Assert.False(httpContext.User.Identity.IsAuthenticated); 339Assert.False(httpContext.User.Identity.IsAuthenticated); 389Assert.False(httpContext.User.Identity.IsAuthenticated);
DelegateTests.cs (2)
91Assert.False(delegateFeature.CanDelegate); 123Assert.False(delegateFeature.CanDelegate);
Http2Tests.cs (10)
35Assert.False(feature.IsUpgradableRequest); 120Assert.False(httpContext.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 170Assert.False(httpContext.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 339Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 350Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 386Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 425Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 465Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 482Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 501Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection));
HttpsTests.cs (3)
279Assert.False(requestTimingFeature.TryGetTimestamp(HttpSysRequestTimingType.Http3StreamStart, out var streamStart)); 280Assert.False(requestTimingFeature.TryGetTimestamp((HttpSysRequestTimingType)int.MaxValue, out var invalid)); 281Assert.False(requestTimingFeature.TryGetElapsedTime(HttpSysRequestTimingType.Http3StreamStart, HttpSysRequestTimingType.RequestHeaderParseStart, out elapsed));
Listener\AuthenticationOnExistingQueueTests.cs (4)
64Assert.False(context.User.Identity.IsAuthenticated); 105Assert.False(context.User.Identity.IsAuthenticated); 130Assert.False(context.User.Identity.IsAuthenticated); 155Assert.False(context.User.Identity.IsAuthenticated);
Listener\RequestBodyTests.cs (4)
27Assert.False(server.Options.AllowSynchronousIO); 133Assert.False(readTask.IsCanceled); 159Assert.False(readTask.IsCanceled); 183Assert.False(context.DisconnectToken.IsCancellationRequested);
Listener\RequestHeaderTests.cs (3)
32Assert.False(headers.TryGetValue("Connection", out _)); 38Assert.False(headers.TryGetValue("Custom-Header", out _)); 51Assert.False(removedAgain);
Listener\ResponseBodyTests.cs (1)
29Assert.False(context.AllowSynchronousIO);
Listener\ResponseHeaderTests.cs (11)
41Assert.False(response.Headers.TransferEncodingChunked.HasValue); 63Assert.False(response.Headers.TransferEncodingChunked.HasValue); 86Assert.False(response.Headers.TransferEncodingChunked.HasValue); 89Assert.False(response.Content.Headers.Contains("Content-Length")); 114Assert.False(response.Headers.TransferEncodingChunked.HasValue); 118Assert.False(response.Content.Headers.Contains("Content-Length")); 144Assert.False(response.Headers.TransferEncodingChunked.HasValue); 173Assert.False(response.Headers.TransferEncodingChunked.HasValue); 176Assert.False(response.Content.Headers.Contains("Content-Length")); 196Assert.False(response.Headers.TransferEncodingChunked.HasValue); 199Assert.False(response.Content.Headers.Contains("Content-Length"));
OpaqueUpgradeTests.cs (4)
136Assert.False(feature.IsReadOnly); 264Assert.False(opaqueFeature.IsUpgradableRequest); 287Assert.False(opaqueFeature.IsUpgradableRequest); 314Assert.False(opaqueFeature.IsUpgradableRequest);
RequestBodyLimitTests.cs (16)
28Assert.False(feature.IsReadOnly); 50Assert.False(feature.IsReadOnly); 72Assert.False(feature.IsReadOnly); 95Assert.False(feature.IsReadOnly); 117Assert.False(feature.IsReadOnly); 139Assert.False(feature.IsReadOnly); 162Assert.False(feature.IsReadOnly); 187Assert.False(feature.IsReadOnly); 212Assert.False(feature.IsReadOnly); 238Assert.False(feature.IsReadOnly); 263Assert.False(feature.IsReadOnly); 287Assert.False(feature.IsReadOnly); 315Assert.False(feature.IsReadOnly); 341Assert.False(feature.IsReadOnly); 365Assert.False(feature.IsReadOnly); 389Assert.False(feature.IsReadOnly);
RequestHeaderTests.cs (3)
28Assert.False(StringValues.IsNullOrEmpty(requestHeaders["Host"])); 45Assert.False(StringValues.IsNullOrEmpty(requestHeaders["Host"])); 162Assert.False(requestHeaders.ContainsKey("Content-Length"));
ResponseHeaderTests.cs (7)
32Assert.False(response.Headers.TransferEncodingChunked.HasValue); 157Assert.False(result); 179Assert.False(response.Headers.TransferEncodingChunked.HasValue); 205Assert.False(response.Content.Headers.Contains("Content-Length")); 225Assert.False(response.HasStarted); 256Assert.False(response.HasStarted); 292Assert.False(headers.Contains(headerName));
ResponseTests.cs (2)
29Assert.False(httpContext.Response.HasStarted); 240Assert.False(httpContext.Response.HasStarted);
ResponseTrailersTests.cs (2)
28Assert.False(httpContext.Response.SupportsTrailers()); 331Assert.False(headers.Contains(headerName));
ServerTests.cs (14)
436Assert.False(stopTask1.IsCompleted); 437Assert.False(stopTask2.IsCompleted); 438Assert.False(stopTask3.IsCompleted); 470Assert.False(stopTask1.IsCompleted); 471Assert.False(stopTask2.IsCompleted); 472Assert.False(stopTask3.IsCompleted); 507Assert.False(stopTask1.IsCompleted); 508Assert.False(stopTask2.IsCompleted); 509Assert.False(stopTask3.IsCompleted); 544Assert.False(stopTask1.IsCompleted); 545Assert.False(stopTask2.IsCompleted); 546Assert.False(stopTask3.IsCompleted); 581Assert.False(stopTask1.IsCompleted); 582Assert.False(stopTask2.IsCompleted);
Microsoft.AspNetCore.Server.HttpSys.Tests (1)
UrlPrefixTests.cs (1)
81Assert.False(urlPrefix.Path.IsNormalized(NormalizationForm.FormC));
Microsoft.AspNetCore.Server.IISIntegration.Tests (5)
IISMiddlewareTests.cs (5)
93Assert.False(assertsExecuted); 139Assert.False(requestExecuted.Task.IsCompleted); 197Assert.False(applicationStoppingFired.Task.IsCompleted); 242Assert.False(applicationStoppingFired.Task.IsCompleted); 287Assert.False(applicationStoppingFired.Task.IsCompleted);
Microsoft.AspNetCore.Server.Kestrel.Core.Tests (174)
AddressBinderTests.cs (9)
45Assert.False(AddressBinder.TryCreateIPEndPoint( 62Assert.False(https); 73Assert.False(https); 107Assert.False(https); 117Assert.False(https); 128Assert.False(https); 139Assert.False(https); 150Assert.False(https); 161Assert.False(https);
AsciiDecoding.cs (5)
103Assert.False(StringUtilities.BytesOrdinalEqualsStringAndAscii(s, span.Slice(0, span.Length - 1))); 104Assert.False(StringUtilities.BytesOrdinalEqualsStringAndAscii(s.Substring(0, s.Length - 1), span)); 107Assert.False(StringUtilities.BytesOrdinalEqualsStringAndAscii(s, span.Slice(1, span.Length - 1))); 108Assert.False(StringUtilities.BytesOrdinalEqualsStringAndAscii(s.Substring(1, s.Length - 1), span)); 146Assert.False(StringUtilities.BytesOrdinalEqualsStringAndAscii(s, asciiBytes));
CertificatePathWatcherTests.cs (4)
63Assert.False(changeToken.HasChanged); 163Assert.False(newChangeToken.HasChanged); 213Assert.False(Directory.Exists(dir)); 391Assert.False(changeTcs.Task.IsCompleted);
ConcurrentPipeWriterTests.cs (14)
110Assert.False(flushTask0.IsCompleted); 122Assert.False(flushTask0.IsCompleted); 123Assert.False(flushTask1.IsCompleted); 142Assert.False(flushTask0.IsCompleted); 143Assert.False(flushTask1.IsCompleted); 155Assert.False(flushTask0.IsCompleted); 156Assert.False(flushTask1.IsCompleted); 207Assert.False(flushTask0.IsCompleted); 238Assert.False(flushTask1.IsCompleted); 290Assert.False(flushTask0.IsCompleted); 360Assert.False(flushTask0.IsCompleted); 371Assert.False(flushTask0.IsCompleted); 372Assert.False(flushTask1.IsCompleted); 389Assert.False(flushTask2.IsCompleted);
Http1\Http1ConnectionTests.cs (13)
127Assert.False(_http1Connection.TakeMessageHeaders(ref reader, trailers: false)); 688Assert.False(original.IsCancellationRequested); 689Assert.False(_http1Connection.RequestAborted.IsCancellationRequested); 710Assert.False(original.IsCancellationRequested); 711Assert.False(_http1Connection.RequestAborted.IsCancellationRequested); 721Assert.False(successResult.IsCompleted); 735Assert.False(successResult.IsCanceled); 744Assert.False(goodResult.IsCanceled); 770Assert.False(original.IsCancellationRequested); 771Assert.False(_http1Connection.RequestAborted.IsCancellationRequested); 788Assert.False(original.IsCancellationRequested); 789Assert.False(_http1Connection.RequestAborted.IsCancellationRequested); 1037Assert.False(_http1Connection.RequestHeaders.ContainsKey(HeaderNames.ContentLength));
Http1\Http1OutputProducerTests.cs (4)
51Assert.False(socketOutput.Pipe.Reader.TryRead(out var result)); 73Assert.False(successResult.IsCompleted); 101Assert.False(successResult.IsCanceled); 111Assert.False(goodResult.IsCanceled);
Http2\Http2HeadersEnumeratorTests.cs (1)
138Assert.False(e.MoveNext());
Http2\Http2HPackEncoderTests.cs (1)
587Assert.False(integerDecoder.BeginTryDecode((byte)(buffer[0] & ~DynamicTableSizeUpdateMask), prefixLength: 5, out _));
Http2\Http2HttpProtocolFeatureCollectionTests.cs (1)
44Assert.False(upgradeFeature.IsUpgradableRequest);
Http3\Http3HeadersEnumeratorTests.cs (1)
145Assert.False(e.MoveNext());
Http3\Http3HttpProtocolFeatureCollectionTests.cs (1)
44Assert.False(upgradeFeature.IsUpgradableRequest);
HttpHeadersTests.cs (8)
256Assert.False(headers.TryGetValue("Content-Length", out var value)); 258Assert.False(httpHeaders.ContentLength.HasValue); 273Assert.False(headers.TryGetValue("Content-Length", out value)); 275Assert.False(httpHeaders.ContentLength.HasValue); 291Assert.False(headers.TryGetValue("Content-Length", out value)); 293Assert.False(httpHeaders.ContentLength.HasValue); 298Assert.False(headers.TryGetValue("Content-Length", out value)); 300Assert.False(httpHeaders.ContentLength.HasValue);
HttpParserTests.cs (11)
60Assert.False(ParseRequestLine(parser, requestHandler, buffer, out var consumed, out var examined)); 71Assert.False(ParseRequestLine(parser, requestHandler, buffer, out var consumed, out var examined)); 237Assert.False(parser.ParseHeaders(requestHandler, ref reader)); 264Assert.False(parser.ParseHeaders(requestHandler, ref reader)); 465Assert.False(parser.ParseHeaders(requestHandler, ref reader1)); 572Assert.False(result); 662Assert.False(result); 676Assert.False(result); 748Assert.False(result); 773Assert.False(parser.ParseHeaders(requestHandler, ref reader)); 846Assert.False(parser.ParseHeaders(requestHandler, ref reader));
HttpRequestHeadersTests.cs (45)
26Assert.False(headers.IsReadOnly); 72Assert.False(headers.TryGetValue("host", out value)); 73Assert.False(headers.TryGetValue("custom", out value)); 74Assert.False(headers.TryGetValue("Content-Length", out value)); 78Assert.False(headers.TryGetValue("custom", out value)); 79Assert.False(headers.TryGetValue("Content-Length", out value)); 84Assert.False(headers.TryGetValue("Content-Length", out value)); 241Assert.False(headers.ContainsKey("host")); 242Assert.False(headers.ContainsKey("custom")); 243Assert.False(headers.ContainsKey("Content-Length")); 244Assert.False(headers.Contains(kv1)); 245Assert.False(headers.Contains(kv2)); 246Assert.False(headers.Contains(kv3)); 250Assert.False(headers.ContainsKey("custom")); 251Assert.False(headers.ContainsKey("Content-Length")); 253Assert.False(headers.Contains(kv2)); 254Assert.False(headers.Contains(kv3)); 255Assert.False(headers.Contains(kv1b)); 256Assert.False(headers.Contains(kv2b)); 257Assert.False(headers.Contains(kv3b)); 262Assert.False(headers.ContainsKey("Content-Length")); 265Assert.False(headers.Contains(kv3)); 266Assert.False(headers.Contains(kv1b)); 267Assert.False(headers.Contains(kv2b)); 268Assert.False(headers.Contains(kv3b)); 277Assert.False(headers.Contains(kv1b)); 278Assert.False(headers.Contains(kv2b)); 279Assert.False(headers.Contains(kv3b)); 288Assert.False(headers.TryGetValue("host", out value)); 289Assert.False(headers.TryGetValue("custom", out value)); 290Assert.False(headers.TryGetValue("Content-Length", out value)); 324Assert.False(headers.TryGetValue("host", out value)); 325Assert.False(headers.TryGetValue("custom", out value)); 326Assert.False(headers.TryGetValue("Content-Length", out value)); 344Assert.False(headers.Remove("host")); 347Assert.False(headers.TryGetValue("host", out value)); 351Assert.False(headers.Remove("custom")); 354Assert.False(headers.TryGetValue("host", out value)); 355Assert.False(headers.TryGetValue("custom", out value)); 359Assert.False(headers.Remove("Content-Length")); 362Assert.False(headers.TryGetValue("host", out value)); 363Assert.False(headers.TryGetValue("custom", out value)); 364Assert.False(headers.TryGetValue("Content-Length", out value)); 567Assert.False(nextSpan.SequenceEqual(Encoding.ASCII.GetBytes(headerValueUtf16Latin1CrossOver))); 612Assert.False(latinValueSpan.SequenceEqual(Encoding.ASCII.GetBytes(headerValueUtf16Latin1CrossOver)));
HttpRequestStreamTests.cs (2)
29Assert.False(stream.CanSeek); 36Assert.False(stream.CanWrite);
HttpResponseHeadersTests.cs (1)
50Assert.False(headers.IsReadOnly);
HttpResponseStreamTests.cs (2)
22Assert.False(stream.CanRead); 29Assert.False(stream.CanSeek);
HttpUtilitiesTest.cs (1)
229Assert.False(HttpUtilities.IsHostHeaderValid(host));
KestrelServerOptionsTests.cs (1)
22Assert.False(options.AllowSynchronousIO);
KestrelServerTests.cs (8)
583Assert.False(stopTask1.IsCompleted); 584Assert.False(stopTask2.IsCompleted); 585Assert.False(stopTask3.IsCompleted); 641Assert.False(stopTask1.IsCompleted); 642Assert.False(stopTask2.IsCompleted); 643Assert.False(stopTask3.IsCompleted); 695Assert.False(stopTask1.IsCompleted); 696Assert.False(stopTask2.IsCompleted);
ListenOptionsTests.cs (2)
54Assert.False(localhostListenOptions.ProtocolsSetExplicitly); 57Assert.False(clone1.ProtocolsSetExplicitly);
MessageBodyTests.cs (10)
346Assert.False(readTask.IsCompleted); 928Assert.False(startRequestBodyCalled); 1058Assert.False(readResult.IsCanceled); 1095Assert.False(readResult.IsCompleted); 1122Assert.False(readResult.IsCompleted); 1172Assert.False(readResult.IsCompleted); 1196Assert.False(readResult.IsCompleted); 1309Assert.False(readResult.IsCompleted); 1333Assert.False(readResult.IsCompleted); 1359Assert.False(readResult.IsCompleted);
PinnedBlockMemoryPoolTests.cs (2)
202Assert.False(memoryPool.TryScheduleEviction(time)); 216Assert.False(memoryPool.TryScheduleEviction(time.AddSeconds(10)));
ResourceCounterTests.cs (3)
26Assert.False(counter.TryLockOne()); 44Assert.False(counter.TryLockOne()); 53Assert.False(counter.TryLockOne());
SniOptionsSelectorTests.cs (1)
763Assert.False(options.ClientCertificateRequired);
src\Shared\test\Shared.Tests\runtime\Http2\HPackDecoderTest.cs (1)
731Assert.False(_handler.DecodedHeaders.ContainsKey(string8194));
src\Shared\test\Shared.Tests\runtime\Http2\HPackIntegerTest.cs (3)
31Assert.False(success); 71Assert.False(decodeResult); 100Assert.False(decoder.TryDecode(octets[j], out intResult));
src\Shared\test\Shared.Tests\runtime\Http3\VariableLengthIntegerHelperTests.cs (10)
20Assert.False(isSuccess); 66Assert.False(isSuccess); 99Assert.False(isSuccess); 131Assert.False(isSuccess); 215Assert.False(isSuccess); 244Assert.False(result); 256Assert.False(isSuccess); 299Assert.False(isSuccess); 327Assert.False(isSuccess); 355Assert.False(isSuccess);
ThrowingWasUpgradedWriteOnlyStreamTests.cs (3)
19Assert.False(stream.CanRead); 20Assert.False(stream.CanSeek); 21Assert.False(stream.CanTimeout);
TlsListenerTests.cs (6)
74Assert.False(tlsClientHelloCallbackInvoked); 97Assert.False(tlsClientHelloCallbackInvoked); 122Assert.False(tlsClientHelloCallbackInvoked); 151Assert.False(tlsClientHelloCallbackInvoked); 182Assert.False(data.IsEmpty); 233Assert.False(data.IsEmpty);
Microsoft.AspNetCore.Server.Kestrel.Tests (17)
ConfigurationReaderTests.cs (12)
26Assert.False(certificates.Any()); 39Assert.False(certificates.Any()); 61Assert.False(fileCert.IsStoreCert); 66Assert.False(storeCert.IsFileCert); 89Assert.False(fileCert.IsStoreCert); 114Assert.False(endpoints.Any()); 127Assert.False(endpoints.Any()); 182Assert.False(end1.Certificate.ConfigSection.Exists()); 190Assert.False(end2.Certificate.ConfigSection.Exists()); 201Assert.False(cert3.IsStoreCert); 213Assert.False(cert4.IsFileCert); 295Assert.False(endpoint.Sni.Any());
HttpsConfigurationTests.cs (1)
267Assert.False(host.Services.GetRequiredService<IHttpsConfigurationService>().IsInitialized);
KestrelConfigurationLoaderTests.cs (4)
131Assert.False(run1); 147Assert.False(run1); 196Assert.False(serverOptions.CodeBackedListenOptions[0].IsTls); 1180Assert.False(fileTcs.Task.IsCompleted);
Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (12)
QuicConnectionContextTests.cs (2)
168Assert.False(serverStream.ConnectionClosed.IsCancellationRequested); 211Assert.False(serverStream.ConnectionClosed.IsCancellationRequested);
QuicConnectionListenerTests.cs (5)
57Assert.False(serverConnection.ConnectionClosed.IsCancellationRequested); 62Assert.False(serverConnection.ConnectionClosed.IsCancellationRequested); 78Assert.False(serverConnection1.ConnectionClosed.IsCancellationRequested); 103Assert.False(serverConnection2.ConnectionClosed.IsCancellationRequested); 405Assert.False(acceptTask.IsCompleted);
QuicStreamContextTests.cs (3)
321Assert.False(quicStreamContext.CanWrite); 431Assert.False(quicStreamContext.CanRead); 475Assert.False(quicStreamContext.CanRead);
WebHostTests.cs (2)
327Assert.False(response1.Headers.Contains("alt-svc")); 340Assert.False(response2.Headers.Contains("alt-svc"));
Microsoft.AspNetCore.Session.Tests (12)
SessionTests.cs (12)
57Assert.False(response.Headers.TryGetValues("Set-Cookie", out var _)); 178Assert.False(value.HasValue); 227Assert.False(value.HasValue); 239Assert.False(value.HasValue); 286Assert.False(value.HasValue); 298Assert.False(value.HasValue); 395Assert.False(value.HasValue); 401Assert.False(value.HasValue); 654Assert.False(context.Session.TryGetValue("key", out var value)); 657Assert.False(context.Session.Keys.Any()); 705Assert.False(context.Session.IsAvailable); 707Assert.False(context.Session.Keys.Any());
Microsoft.AspNetCore.Shared.Tests (58)
AdaptiveCapacityDictionaryTests.cs (21)
97Assert.False(result); 541Assert.False(result); 561Assert.False(result); 575Assert.False(result); 588Assert.False(result); 604Assert.False(result); 722Assert.False(result); 743Assert.False(result); 758Assert.False(result); 771Assert.False(result); 787Assert.False(result); 838Assert.False(result); 852Assert.False(result); 869Assert.False(result); 934Assert.False(dict.ContainsKey("key")); 959Assert.False(dict.ContainsKey("key")); 984Assert.False(dict.ContainsKey("key")); 1069Assert.False(result); 1094Assert.False(result); 1108Assert.False(result); 1125Assert.False(result);
CommandLineApplicationTests.cs (11)
346Assert.False(option.HasValue()); 770Assert.False(commandRan); 922Assert.False(optHelp.HasValue()); 923Assert.False(optVersion.HasValue()); 954Assert.False(optHelp.HasValue()); 955Assert.False(optVersion.HasValue()); 981Assert.False(optHelp.HasValue()); 982Assert.False(optVersion.HasValue()); 1008Assert.False(optHelp.HasValue()); 1009Assert.False(optVersion.HasValue()); 1100Assert.False(optFlag.HasValue());
CopyOnWriteDictionaryHolderTest.cs (2)
33Assert.False(holder.TryGetValue("different-key", out value)); 35Assert.False(holder.HasBeenCopied);
CopyOnWriteDictionaryTest.cs (1)
54Assert.False(copyOnWriteDictionary.TryGetValue("different-key", out value));
ObjectMethodExecutorTest.cs (5)
28Assert.False(executor.IsMethodAsync); 39Assert.False(executor.IsMethodAsync); 51Assert.False(executor.IsMethodAsync); 64Assert.False(executor.IsMethodAsync); 73Assert.False(executor.IsMethodAsync);
runtime\Http2\HPackDecoderTest.cs (1)
731Assert.False(_handler.DecodedHeaders.ContainsKey(string8194));
runtime\Http2\HPackIntegerTest.cs (3)
31Assert.False(success); 71Assert.False(decodeResult); 100Assert.False(decoder.TryDecode(octets[j], out intResult));
runtime\Http3\VariableLengthIntegerHelperTests.cs (10)
20Assert.False(isSuccess); 66Assert.False(isSuccess); 99Assert.False(isSuccess); 131Assert.False(isSuccess); 215Assert.False(isSuccess); 244Assert.False(result); 256Assert.False(isSuccess); 299Assert.False(isSuccess); 327Assert.False(isSuccess); 355Assert.False(isSuccess);
SecurityHelperTests.cs (2)
60Assert.False(existingPrincipal.Identity.IsAuthenticated); 71Assert.False(user.Identity.IsAuthenticated);
SegmentWriteStreamTests.cs (1)
38Assert.False(stream.CanWrite);
ValueStopwatchTest.cs (1)
15Assert.False(default(ValueStopwatch).IsActive);
Microsoft.AspNetCore.SignalR.Client.FunctionalTests (8)
HubConnectionTests.cs (3)
2664Assert.False(reconnectCalled); 2734Assert.False(reconnectCalled); 2827Assert.False(resultTask.IsCompleted);
HubConnectionTests.Tracing.cs (5)
147Assert.False(a.HasRemoteParent); 181Assert.False(a.HasRemoteParent); 279Assert.False(clientActivity.IsStopped); 320Assert.False(a.HasRemoteParent); 343Assert.False(a.HasRemoteParent);
Microsoft.AspNetCore.SignalR.Client.Tests (30)
HttpConnectionTests.ConnectionLifecycle.cs (6)
240Assert.False(stopTask.IsCompleted); 271Assert.False(testTransport.Receiving.IsCompleted); 373Assert.False(connectResponseTcs.Task.IsCompleted); 374Assert.False(startTask.IsCompleted); 414Assert.False(startTask.IsCanceled); 476Assert.False(transportStartCalled);
HttpConnectionTests.cs (1)
112Assert.False(httpClientHandler.UseDefaultCredentials);
HubClientProxyGeneratorTests.cs (4)
113Assert.False(noArgReg.IsDisposed); 114Assert.False(singleArgReg.IsDisposed); 115Assert.False(manyArgsReg.IsDisposed); 116Assert.False(returnTaskReg.IsDisposed);
HubConnectionTests.ConnectionLifecycle.cs (9)
59Assert.False(firstStart.IsCompleted); 66Assert.False(secondStart.IsCompleted); 135Assert.False(stopTask.IsCompleted); 137Assert.False(stopTask.IsCompleted); 216Assert.False(startTask.IsCompleted); 248Assert.False(startTask.IsCompleted); 312Assert.False(testConnection.Disposed.IsCompleted); 348Assert.False(testConnection.Disposed.IsCompleted); 544Assert.False(onStartCalled);
HubConnectionTests.cs (1)
395Assert.False(closeTcs.Task.IsCompleted);
HubConnectionTests.Protocol.cs (6)
491Assert.False(handlerCalled.Task.IsCompleted); 525Assert.False(handlerCalled.Task.IsCompleted); 574Assert.False(task.IsCompleted); 578Assert.False(task.IsCompleted); 636Assert.False(tcs.Task.IsCompleted); 640Assert.False(tcs.Task.IsCompleted);
HubConnectionTests.Reconnect.cs (1)
65Assert.False(reconnectingCalled);
LongPollingTransportTests.cs (1)
54Assert.False(transportActiveTask.IsCompleted);
ServerSentEventsTransportTests.cs (1)
106Assert.False(transportActiveTask.IsCompleted);
Microsoft.AspNetCore.SignalR.Common.Tests (6)
Internal\Formatters\BinaryMessageParserTests.cs (2)
84Assert.False(BinaryMessageParser.TryParseMessage(ref buffer, out var message)); 118Assert.False(BinaryMessageParser.TryParseMessage(ref buffer, out var message));
Internal\Formatters\TextMessageParserTests.cs (3)
21Assert.False(TextMessageParser.TryParseMessage(ref message, out payload)); 28Assert.False(TextMessageParser.TryParseMessage(ref message, out var payload)); 49Assert.False(TextMessageParser.TryParseMessage(ref message, out payload));
Internal\Protocol\HandshakeProtocolTests.cs (1)
73Assert.False(HandshakeProtocol.TryParseRequestMessage(ref message, out _));
Microsoft.AspNetCore.SignalR.Specification.Tests (1)
HubLifetimeManagerTestBase.cs (1)
310Assert.False(invoke1.IsCompleted);
Microsoft.AspNetCore.SignalR.StackExchangeRedis.Tests (4)
RedisEndToEnd.cs (3)
176Assert.False(tcs.Task.IsCompleted); 208Assert.False(tcs.Task.IsCompleted); 304Assert.False(tcs.Task.IsCompleted);
TestConnectionMultiplexer.cs (1)
297Assert.False(channel.IsPattern);
Microsoft.AspNetCore.SignalR.Tests (60)
DefaultHubLifetimeManagerTests.cs (14)
36Assert.False(sendTask.IsCompleted); 49Assert.False(connection1.ConnectionAborted.IsCancellationRequested); 66Assert.False(sendTask.IsCompleted); 75Assert.False(connection1.ConnectionAborted.IsCancellationRequested); 90Assert.False(sendTask.IsCompleted); 112Assert.False(sendTask.IsCompleted); 135Assert.False(sendTask.IsCompleted); 162Assert.False(sendTask.IsCompleted); 171Assert.False(connection1.ConnectionAborted.IsCancellationRequested); 187Assert.False(sendTask.IsCompleted); 212Assert.False(sendTask.IsCompleted); 225Assert.False(connection1.ConnectionAborted.IsCancellationRequested); 242Assert.False(sendTask.IsCompleted); 255Assert.False(connection1.ConnectionAborted.IsCancellationRequested);
HubConnectionHandlerTests.cs (12)
111Assert.False(state.TokenStateInConnected); 158Assert.False(close.AllowReconnect); 356Assert.False(task.IsCompleted); 360Assert.False(task.IsCompleted); 397Assert.False(task.IsCompleted); 401Assert.False(task.IsCompleted); 680Assert.False(handshakeReadTask.IsCompleted); 965Assert.False(closeMessage.AllowReconnect); 2654Assert.False((bool)result); 2827Assert.False(connectionHandlerTask.IsCompleted); 2927Assert.False(connectionHandlerTask.IsCompleted); 5233Assert.False(readTask.IsCompleted);
HubFilterTests.cs (11)
345Assert.False(syncPoints2[0].WaitForSyncPoint().IsCompleted); 356Assert.False(syncPoints2[1].WaitForSyncPoint().IsCompleted); 369Assert.False(syncPoints2[2].WaitForSyncPoint().IsCompleted); 405Assert.False(syncPoints2[0].WaitForSyncPoint().IsCompleted); 416Assert.False(syncPoints2[1].WaitForSyncPoint().IsCompleted); 429Assert.False(syncPoints2[2].WaitForSyncPoint().IsCompleted); 467Assert.False(syncPoints2[0].WaitForSyncPoint().IsCompleted); 478Assert.False(syncPoints2[1].WaitForSyncPoint().IsCompleted); 491Assert.False(syncPoints2[2].WaitForSyncPoint().IsCompleted); 783Assert.False(tcsService.StartedMethod.Task.IsCompleted); 859Assert.False(tcsService.StartedMethod.Task.IsCompleted);
Internal\MessageBufferTests.cs (12)
58Assert.False(writeTask.IsCompleted); 69Assert.False(writeTask.IsCompleted); 97Assert.False(writeTask.IsCompleted); 119Assert.False(pipes.Application.Input.TryRead(out res)); 170Assert.False(messageBuffer.ShouldProcessMessage(CompletionMessage.WithResult("1", null))); 226Assert.False(messageBuffer.ShouldProcessMessage(CompletionMessage.WithResult("1", null))); 337Assert.False(pipes.Application.Input.TryRead(out res)); 352Assert.False(writeTask.IsCompleted); 363Assert.False(writeTask.IsCompleted); 416Assert.False(pipes.Application.Input.TryRead(out res)); 521Assert.False(resendTask.IsCompleted); 551Assert.False(pipes.Application.Input.TryRead(out res));
Internal\TypedClientBuilderTests.cs (9)
19Assert.False(task.IsCompleted); 43Assert.False(task.IsCompleted); 67Assert.False(task1.IsCompleted); 70Assert.False(task2.IsCompleted); 103Assert.False(task1.IsCompleted); 107Assert.False(task2.IsCompleted); 213Assert.False(task.IsCompleted); 251Assert.False(task1.IsCompleted); 255Assert.False(task2.IsCompleted);
SerializedHubMessageTests.cs (1)
74Assert.False(secondSerialization.IsCompleted);
WebSocketsTransportTests.cs (1)
56Assert.False(webSocketsOptions.UseDefaultCredentials);
Microsoft.AspNetCore.StaticFiles.Tests (10)
DefaultContentTypeProviderTests.cs (2)
13Assert.False(provider.TryGetContentType("unknown.ext", out contentType)); 29Assert.False(provider.TryGetContentType("known.exe.config", out contentType));
RangeHelperTests.cs (2)
71Assert.False(isRangeRequest); 88Assert.False(isRangeRequest);
StaticFileContextTest.cs (3)
31Assert.False(contentTypeResult); 32Assert.False(lookupResult); 113Assert.False(result);
StaticFileMiddlewareTests.cs (3)
303Assert.False(syncCallbackInvoked); 304Assert.False(asyncCallbackInvoked); 310Assert.False(asyncCallbackInvoked);
Microsoft.AspNetCore.TestHost.Tests (18)
ClientHandlerTests.cs (6)
135Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 152Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 234Assert.False(readTask.IsCompleted); 395Assert.False(task.IsCompleted); 397Assert.False(task.Wait(50)); 457Assert.False(readTask.IsCompleted);
HttpContextBuilderTests.cs (4)
156Assert.False(task.IsCompleted); 158Assert.False(task.Wait(50)); 293Assert.False(readTask.IsCompleted); 361Assert.False(readTask.IsCompleted);
ResponseBodyTests.cs (1)
147Assert.False(zeroByteRead.IsCompleted);
ResponseFeatureTests.cs (2)
16Assert.False(responseInformation.HasStarted); 32Assert.False(responseInformation.HasStarted);
TestClientTests.cs (4)
197Assert.False(disposable.IsDisposed); 718Assert.False(ctx.Request.Headers.ContainsKey(HeaderNames.SecWebSocketProtocol)); 1280Assert.False(upgradeFeature.IsUpgradableRequest); 1285Assert.False(webSocketFeature.IsWebSocketRequest);
WebSocketClientTests.cs (1)
125Assert.False(upgradeFeature.IsUpgradableRequest);
Microsoft.AspNetCore.Testing.Tests (2)
FakeCertificateFactoryTests.cs (1)
23Assert.False(certificate.Extensions.OfType<X509EnhancedKeyUsageExtension>().Single().Critical);
FakeCertificateHttpClientHandlerTests.cs (1)
49Assert.False(sut.ServerCertificateCustomValidationCallback!(
Microsoft.AspNetCore.Tests (6)
WebApplicationTests.cs (6)
1349Assert.False(builder.Host.Properties.ContainsKey("Lowercase")); 1970Assert.False(newBuilder.Properties.TryGetValue(WebApplication.GlobalEndpointRouteBuilderKey, out _)); 2041Assert.False(response.IsSuccessStatusCode); 2147Assert.False(response.IsSuccessStatusCode); 2172Assert.False(response.IsSuccessStatusCode); 2506Assert.False(app.Properties.ContainsKey("__AuthorizationMiddlewareSet"));
Microsoft.AspNetCore.WebSockets.Tests (12)
HandshakeTests.cs (2)
36Assert.False(HandshakeHelpers.IsRequestKeyValid(key)); 92Assert.False(HandshakeHelpers.ParseDeflateOptions(clientHeader.AsSpan(), serverContextTakeover: true, serverMaxWindowBits: 15,
Http2WebSocketTests.cs (3)
52Assert.False(headers.TryGetValue(HeaderNames.Connection, out var _)); 53Assert.False(headers.TryGetValue(HeaderNames.Upgrade, out var _)); 54Assert.False(headers.TryGetValue(HeaderNames.SecWebSocketAccept, out var _));
WebSocketCompressionMiddlewareTests.cs (1)
69Assert.False(response.Headers.Contains(HeaderNames.SecWebSocketExtensions));
WebSocketMiddlewareTests.cs (6)
179Assert.False(result.EndOfMessage); 187Assert.False(result.EndOfMessage); 319Assert.False(result.EndOfMessage); 326Assert.False(result.EndOfMessage); 698Assert.False(context.WebSockets.IsWebSocketRequest); 788Assert.False(feature.Enabled);
Microsoft.AspNetCore.WebUtilities.Tests (24)
FileBufferingReadStreamTests.cs (23)
28Assert.False(stream.CanWrite); 34Assert.False(bufferSteam.CanRead); // Buffered Stream now disposed 35Assert.False(bufferSteam.CanSeek); 125Assert.False(stream.InMemory); 134Assert.False(stream.InMemory); 142Assert.False(File.Exists(tempFileName)); 163Assert.False(File.Exists(stream.TempFileName)); 186Assert.False(stream.InMemory); 193Assert.False(stream.InMemory); 197Assert.False(File.Exists(tempFileName)); 287Assert.False(stream.InMemory); 296Assert.False(stream.InMemory); 304Assert.False(File.Exists(tempFileName)); 318Assert.False(stream.InMemory); 345Assert.False(File.Exists(tempFileName)); 366Assert.False(File.Exists(stream.TempFileName)); 389Assert.False(stream.InMemory); 396Assert.False(stream.InMemory); 400Assert.False(File.Exists(tempFileName)); 429Assert.False(File.Exists(tempFileName)); 458Assert.False(File.Exists(tempFileName)); 616Assert.False(stream.InMemory); 627Assert.False(File.Exists(tempFileName));
PagedByteBufferTest.cs (1)
162Assert.False(buffer.Disposed);
Microsoft.Build.Tasks.CodeAnalysis.UnitTests (13)
CopyRefAssemblyTests.cs (4)
38Assert.False(task.Execute()); 39Assert.False(string.IsNullOrEmpty(engine.Log)); 56Assert.False(task.Execute()); 57Assert.False(string.IsNullOrEmpty(engine.Log));
CscTests.cs (1)
549Assert.False(string.IsNullOrEmpty(engine.Log));
MapSourceRootTests.cs (5)
147Assert.False(result); 274Assert.False(result); 381Assert.False(result); 410Assert.False(result); 444Assert.False(result);
MiscTests.cs (1)
29Assert.False(isBadRef);
MSBuildManagedToolTests.cs (1)
28Assert.False(ManagedToolTask.IsSdkFrameworkToCoreBridgeTask);
VbcTests.cs (1)
520Assert.False(string.IsNullOrEmpty(engine.Log));
Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (152)
CommandLineIVTTests.cs (2)
356Assert.False(compiler.Arguments.ReportInternalsVisibleToAttributes); 367Assert.False(compiler.Arguments.ReportInternalsVisibleToAttributes);
CommandLineTests.cs (149)
318Assert.False(options.TryGetValue("my_option2", out _)); 319Assert.False(options.TryGetValue("dotnet_diagnostic.cs0169.severity", out _)); 325Assert.False(options.TryGetValue("my_option", out _)); 326Assert.False(options.TryGetValue("dotnet_diagnostic.cs0169.severity", out _)); 509Assert.False(args.IsScriptRunner); 947Assert.False(resource.IsPublic); 954Assert.False(resource.IsPublic); 957Assert.False(TryParse(@",,\somepath\someFile.goo.bar,,private", out resource)); 964Assert.False(TryParse(@", ,\somepath\someFile.goo.bar,,private", out resource)); 976Assert.False(resource.IsPublic); 984Assert.False(resource.IsPublic); 986Assert.False(TryParse(@"\somepath\someFile.goo.bar,someName,publi", out resource)); 990Assert.False(TryParse(@"D:rive\relative\path,someName,public", out resource)); 994Assert.False(TryParse(@"inva\l*d?path,someName,public", out resource)); 998Assert.False(TryParse((string)null, out resource)); 1002Assert.False(TryParse("", out resource)); 1006Assert.False(TryParse(" ", out resource)); 1012Assert.False(TryParse(" , ", out resource)); 1025Assert.False(TryParse(" ,name", out resource)); 1031Assert.False(TryParse(" , , ", out resource)); 1037Assert.False(TryParse("path, , ", out resource)); 1043Assert.False(TryParse(" ,name, ", out resource)); 1049Assert.False(TryParse(" , ,private", out resource)); 1055Assert.False(TryParse("path,name,", out resource)); 1062Assert.False(TryParse("path,name,,", out resource)); 1069Assert.False(TryParse("path,name, ", out resource)); 1080Assert.False(resource.IsPublic); 1082Assert.False(TryParse(" ,name,private", out resource)); 1095Assert.False(resource.IsPublic); 1099Assert.False(TryParse($"{longI},e,private", out resource)); 1116Assert.False(parsedArgs.DisplayHelp); 1123Assert.False(parsedArgs.DisplayHelp); 1130Assert.False(parsedArgs.DisplayHelp); 1137Assert.False(parsedArgs.DisplayHelp); 1468Assert.False(parsedArgs.DisplayHelp); 1473Assert.False(parsedArgs.DisplayHelp); 1479Assert.False(parsedArgs.SourceFiles.Any()); 1484Assert.False(parsedArgs.SourceFiles.Any()); 1489Assert.False(parsedArgs.SourceFiles.Any()); 1505Assert.False(parsedArgs.SourceFiles.Any()); 1510Assert.False(parsedArgs.SourceFiles.Any()); 1514Assert.False(parsedArgs.DisplayHelp); 1522Assert.False(parsedArgs.DisplayHelp); 1527Assert.False(parsedArgs.DisplayHelp); 1535Assert.False(parsedArgs.DisplayHelp); 1536Assert.False(parsedArgs.SourceFiles.Any()); 1540Assert.False(parsedArgs.DisplayHelp); 1545Assert.False(parsedArgs.DisplayHelp); 1550Assert.False(parsedArgs.DisplayHelp); 1557Assert.False(parsedArgs.DisplayHelp); 1562Assert.False(parsedArgs.DisplayHelp); 1567Assert.False(parsedArgs.DisplayHelp); 1903Assert.False(parsedArgs.Errors.Any()); 1908Assert.False(parsedArgs.Errors.Any()); 1915Assert.False(parsedArgs.Errors.Any()); 1965Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 1966Assert.False(parsedArgs.EmitPdb); 1967Assert.False(parsedArgs.EmitPdbFile); 1972Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 1973Assert.False(parsedArgs.EmitPdb); 1974Assert.False(parsedArgs.EmitPdbFile); 1979Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 1993Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 1994Assert.False(parsedArgs.EmitPdb); 1995Assert.False(parsedArgs.EmitPdbFile); 2000Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2006Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2013Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2019Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2026Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2033Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2039Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2045Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2051Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2052Assert.False(parsedArgs.EmitPdb); 2057Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2075Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2076Assert.False(parsedArgs.EmitPdb); 2098Assert.False(parsedArgs.EmitPdbFile); 2103Assert.False(parsedArgs.EmitPdbFile); 2614Assert.False(parsedArgs.CompilationOptions.Deterministic); 2626Assert.False(parsedArgs.CompilationOptions.Deterministic); 4174Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4181Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4188Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4227Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4235Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4248Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4256Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4275Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4285Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4294Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4523Assert.False(parsedArgs.Errors.Any()); 4527Assert.False(parsedArgs.Errors.Any()); 4576Assert.False(parsedArgs.Errors.Any()); 4814Assert.False(parsedArgs.Errors.Any()); 4817Assert.False(parsedArgs.Errors.Any()); 4820Assert.False(parsedArgs.Errors.Any()); 4821Assert.False(parsedArgs.EmitOptions.HighEntropyVirtualAddressSpace); 4832Assert.False(parsedArgs.Errors.Any()); 4833Assert.False(parsedArgs.EmitOptions.HighEntropyVirtualAddressSpace); 4845Assert.False(parsedArgs.CompilationOptions.CheckOverflow); 5580Assert.False(parsedArgs.CompilationOptions.AllowUnsafe); 5588Assert.False(parsedArgs.CompilationOptions.AllowUnsafe); 5618Assert.False((bool)parsedArgs.CompilationOptions.DelaySign); 5641Assert.False(parsedArgs.CompilationOptions.PublicSign); 5648Assert.False(parsedArgs.CompilationOptions.PublicSign); 7434Assert.False(((CSharpCompilation)comp).FeatureDisableLengthBasedSwitch); 8362Assert.False(parsedArgs.PrintFullPaths); 9431Assert.False(parsedArgs2.ReportAnalyzer); 9464Assert.False(parsedArgs.SkipAnalyzers); 9480Assert.False(parsedArgs.SkipAnalyzers); 9488Assert.False(parsedArgs.SkipAnalyzers); 10531Assert.False(hostOutputRan); 11875Assert.False(File.Exists(dll)); 11878Assert.False(File.Exists(refDll)); 11938Assert.False(File.Exists(pdb)); 12384Assert.False(options.Features.ContainsKey("InterceptorsNamespaces")); 14698Assert.False(globalOptions.TryGetValue("key2", out _)); 14699Assert.False(globalOptions.TryGetValue("key3", out _)); 14700Assert.False(globalOptions.TryGetValue("key4", out _)); 14701Assert.False(globalOptions.TryGetValue("key5", out _)); 14702Assert.False(globalOptions.TryGetValue("key6", out _)); 14703Assert.False(globalOptions.TryGetValue("key7", out _)); 14709Assert.False(classOptions.TryGetValue("key2", out _)); 14710Assert.False(classOptions.TryGetValue("key3", out _)); 14713Assert.False(classOptions.TryGetValue("key5", out _)); 14714Assert.False(classOptions.TryGetValue("key6", out _)); 14715Assert.False(classOptions.TryGetValue("key7", out _)); 14738Assert.False(globalOptions.TryGetValue("key2", out _)); 14739Assert.False(globalOptions.TryGetValue("key3", out _)); 14740Assert.False(globalOptions.TryGetValue("key4", out _)); 14741Assert.False(globalOptions.TryGetValue("key5", out _)); 14742Assert.False(globalOptions.TryGetValue("key6", out _)); 14743Assert.False(globalOptions.TryGetValue("key7", out _)); 14749Assert.False(classOptions.TryGetValue("key2", out _)); 14750Assert.False(classOptions.TryGetValue("key3", out _)); 14753Assert.False(classOptions.TryGetValue("key5", out _)); 14754Assert.False(classOptions.TryGetValue("key6", out _)); 14755Assert.False(classOptions.TryGetValue("key7", out _)); 14761Assert.False(generatedOptions.TryGetValue("key2", out _)); 14762Assert.False(generatedOptions.TryGetValue("key3", out _)); 14765Assert.False(generatedOptions.TryGetValue("key5", out _)); 14766Assert.False(generatedOptions.TryGetValue("key6", out _)); 14767Assert.False(generatedOptions.TryGetValue("key7", out _)); 15061Assert.False(options.TryGetValue("key2", out _)); 15067Assert.False(options.TryGetValue("key1", out _)); 15075Assert.False(options.TryGetValue("key1", out _)); 15076Assert.False(options.TryGetValue("key2", out _));
SarifV2ErrorLoggerTests.cs (1)
669Assert.False(File.Exists(Path.Combine(mappedDir.Path, "otherfile.cs")));
Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (19)
CodeActions\PreviewExceptionTests.cs (5)
63Assert.False(errorReported); 71Assert.False(extensionManager.IsIgnored(provider)); 79Assert.False(extensionManager.IsIgnored(provider)); 86Assert.False(extensionManager.IsDisabled(provider)); 87Assert.False(extensionManager.IsIgnored(provider));
Completion\CompletionProviders\OverrideCompletionProviderTests.cs (1)
3488Assert.False(completionList.ItemsList.Any(c => c.DisplayText == "Goo()"));
Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (6)
96Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && e.ReturnsVoid)); 97Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && !e.ReturnsVoid)); 99Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property)); 109Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && e.ReturnsVoid)); 110Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && !e.ReturnsVoid)); 112Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property));
Extensions\SyntaxTreeExtensionsTests.cs (1)
21Assert.False(tree.IsInInactiveRegion(pos, CancellationToken.None));
Formatting\Indentation\SmartIndenterEnterOnTokenTests.cs (1)
1370Assert.False(
NavigateTo\NavigateToSearcherTests.cs (1)
332Assert.False(searchGeneratedDocumentsAsyncCalled);
PdbSourceDocument\ImplementationAssemblyLookupServiceTests.cs (1)
53Assert.False(service.TryFindImplementationAssemblyPath(GetDllPath(packDir), out var implementationDll));
Workspaces\WorkspaceTests_EditorFeatures.cs (3)
77Assert.False(workspaceChanged); 360Assert.False(workspace.IsDocumentOpen(document.Id)); 697Assert.False(foundTheError);
Microsoft.CodeAnalysis.CSharp.EditorFeatures2.UnitTests (8)
EmbeddedLanguages\Json\CSharpJsonParserTests.cs (4)
445Assert.False(token.IsMissing); 446Assert.False(chars.IsDefaultOrEmpty); 496Assert.False(token.IsMissing); 497Assert.False(chars.IsDefaultOrEmpty);
EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (4)
354Assert.False(token.IsMissing); 355Assert.False(chars.IsDefaultOrEmpty); 368Assert.False(token.IsMissing); 369Assert.False(chars.IsDefaultOrEmpty);
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (513)
CodeGen\CodeGenAsyncIteratorTests.cs (4)
959Assert.False(m2.IsAsync); 960Assert.False(m2.IsIterator); 1127Assert.False(m.IsIterator); 2072Assert.False(m.IsIterator);
CodeGen\CodeGenAsyncTests.cs (2)
80Assert.False(options.EnableEditAndContinue); 89Assert.False(options.EnableEditAndContinue);
CodeGen\CodeGenAwaitForeachTests.cs (3)
2482Assert.False(internalInfo.NeedsDisposal); 5033Assert.False(internalInfo.NeedsDisposal); 8232Assert.False(internalInfo.NeedsDisposal);
CodeGen\CodeGenAwaitUsingTests.cs (21)
3580Assert.False(first.Equals(nulls1)); 3581Assert.False(first.Equals(nulls2)); 3582Assert.False(first.Equals(nulls3)); 3583Assert.False(first.Equals(nulls4)); 3584Assert.False(first.Equals(nulls5)); 3586Assert.False(nulls1.Equals(first)); 3587Assert.False(nulls2.Equals(first)); 3588Assert.False(nulls3.Equals(first)); 3589Assert.False(nulls4.Equals(first)); 3590Assert.False(nulls5.Equals(first)); 3599Assert.False(first.Equals(nullObj)); 3610Assert.False(first.Equals(second1)); 3611Assert.False(first.Equals(second2)); 3612Assert.False(first.Equals(second3)); 3613Assert.False(first.Equals(second4)); 3614Assert.False(first.Equals(second5)); 3616Assert.False(second1.Equals(first)); 3617Assert.False(second2.Equals(first)); 3618Assert.False(second3.Equals(first)); 3619Assert.False(second4.Equals(first)); 3620Assert.False(second5.Equals(first));
CodeGen\CodeGenDeconstructTests.cs (6)
5001Assert.False(nodes.Any(n => n.Kind() == SyntaxKind.SimpleAssignmentExpression)); 5405Assert.False(xType.IsErrorType()); 5412Assert.False(yType.IsErrorType()); 5438Assert.False(xType.IsErrorType()); 5445Assert.False(yType.IsErrorType()); 5570Assert.False(xType.IsErrorType());
CodeGen\CodeGenDynamicTests.cs (6)
603Assert.False(field.IsReadOnly); 844Assert.False(member.IsStatic); 845Assert.False(member.IsSealed); 846Assert.False(member.IsVirtual); 850Assert.False(member.IsStatic); 851Assert.False(member.IsSealed);
CodeGen\CodeGenFunctionPointersTests.cs (15)
716Assert.False(inMod.IsOptional); 7079Assert.False(array.IsSZArray); 7693Assert.False(funcPtr.Equals(funcPtrWithTestOnReturn, TypeCompareKind.ConsiderEverything)); 7695Assert.False(funcPtrRef.Equals(funcPtrWithTestOnRef, TypeCompareKind.ConsiderEverything)); 7778Assert.False(funcPtr.Equals(funcPtrWithTestOnReturn, TypeCompareKind.ConsiderEverything)); 7780Assert.False(funcPtrRef.Equals(funcPtrWithTestOnRef, TypeCompareKind.ConsiderEverything)); 11677Assert.False(attr.HasErrors); 11740Assert.False(attr.HasErrors); 11803Assert.False(attr.HasErrors); 11862Assert.False(attr.HasErrors); 11896Assert.False(attr.HasErrors); 12137Assert.False(attr.HasErrors); 12280Assert.False(attr.HasErrors); 12319Assert.False(attr.HasErrors); 12367Assert.False(attr.HasErrors);
CodeGen\CodeGenInterpolatedString.cs (2)
48Assert.False(string.IsNullOrEmpty(token.Text)); 49Assert.False(string.IsNullOrEmpty(token.ValueText));
CodeGen\CodeGenLocalFunctionTests.cs (12)
5777Assert.False(importData.SetLastError); 5778Assert.False(importData.ExactSpelling); 6056Assert.False(methodParam.IsMetadataOut); 6060Assert.False(localFunctionParam.IsMetadataOut); 6066Assert.False(methodParam.IsMetadataOut); 6070Assert.False(localFunctionParam.IsMetadataOut); 6112Assert.False(methodParam.IsMetadataIn); 6116Assert.False(localFunctionParam.IsMetadataIn); 6122Assert.False(methodParam.IsMetadataIn); 6126Assert.False(localFunctionParam.IsMetadataIn); 6166Assert.False(param.IsMetadataOut); 6171Assert.False(synthesizedParam.IsMetadataIn);
CodeGen\CodeGenOverridingAndHiding.cs (5)
4007Assert.False(methodB.IsVirtual); 4008Assert.False(methodB.IsOverride); 4113Assert.False(parameterA.IsParamsCollection); 4121Assert.False(parameterB.IsParamsCollection); 4139Assert.False(parameter.IsParamsCollection);
CodeGen\CodeGenReadonlyStructTests.cs (77)
866Assert.False(namedType.IsReadOnly); 873Assert.False(namedType.IsReadOnly); 880Assert.False(namedType.IsReadOnly); 886Assert.False(type.IsReadOnly); 890Assert.False(type.IsReadOnly); 894Assert.False(type.IsReadOnly); 898Assert.False(iNamedType.IsReadOnly); 902Assert.False(type.IsReadOnly); 906Assert.False(iNamedType.IsReadOnly); 1030Assert.False(namedType.IsReadOnly); 1037Assert.False(namedType.IsReadOnly); 1044Assert.False(namedType.IsReadOnly); 1050Assert.False(type.IsReadOnly); 1054Assert.False(type.IsReadOnly); 1058Assert.False(type.IsReadOnly); 1062Assert.False(iNamedType.IsReadOnly); 1066Assert.False(type.IsReadOnly); 1070Assert.False(iNamedType.IsReadOnly); 1355Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m1).Handle)); 1356Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m1).Signature.ReturnParam.Handle)); 1358Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m2).Signature.ReturnParam.Handle)); 1360Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p1).Handle)); 1362Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p1.GetMethod).Signature.ReturnParam.Handle)); 1363Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p1.SetMethod).Handle)); 1364Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p1.SetMethod).Signature.ReturnParam.Handle)); 1366Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p2).Handle)); 1368Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p2.GetMethod).Signature.ReturnParam.Handle)); 1370Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p3).Handle)); 1372Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p3.GetMethod).Signature.ReturnParam.Handle)); 1373Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p3.SetMethod).Handle)); 1374Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p3.SetMethod).Signature.ReturnParam.Handle)); 1376Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p4).Handle)); 1377Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p4.GetMethod).Handle)); 1378Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p4.GetMethod).Signature.ReturnParam.Handle)); 1380Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p4.SetMethod).Signature.ReturnParam.Handle)); 1382Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p5).Handle)); 1383Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p5.GetMethod).Handle)); 1384Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p5.GetMethod).Signature.ReturnParam.Handle)); 1385Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p5.SetMethod).Handle)); 1386Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p5.SetMethod).Signature.ReturnParam.Handle)); 1428Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m1).Handle)); 1429Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m1).Signature.ReturnParam.Handle)); 1432Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m2).Signature.ReturnParam.Handle)); 1434Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m3).Handle)); 1440Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p1).Handle)); 1441Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p1.GetMethod).Handle)); 1442Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p1.GetMethod).Signature.ReturnParam.Handle)); 1444Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p2).Handle)); 1446Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p2.GetMethod).Signature.ReturnParam.Handle)); 1449Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p3.GetMethod).Handle)); 1493Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m1).Handle)); 1494Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m1).Signature.ReturnParam.Handle)); 1495Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m2).Handle)); 1496Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)m2).Signature.ReturnParam.Handle)); 1498Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p1).Handle)); 1499Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p1.GetMethod).Handle)); 1500Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p1.GetMethod).Signature.ReturnParam.Handle)); 1502Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p2).Handle)); 1503Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p2.GetMethod).Handle)); 1504Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p2.GetMethod).Signature.ReturnParam.Handle)); 1506Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p3).Handle)); 1507Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p3.GetMethod).Handle)); 1508Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p3.GetMethod).Signature.ReturnParam.Handle)); 1509Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p3.SetMethod).Handle)); 1510Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p3.SetMethod).Signature.ReturnParam.Handle)); 1512Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p4).Handle)); 1513Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p4.GetMethod).Handle)); 1514Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p4.GetMethod).Signature.ReturnParam.Handle)); 1515Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p4.SetMethod).Handle)); 1516Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p4.SetMethod).Signature.ReturnParam.Handle)); 1518Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEPropertySymbol)p5).Handle)); 1519Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p5.GetMethod).Handle)); 1520Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p5.GetMethod).Signature.ReturnParam.Handle)); 1521Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p5.SetMethod).Handle)); 1522Assert.False(peModule.Module.HasIsReadOnlyAttribute(((PEMethodSymbol)p5.SetMethod).Signature.ReturnParam.Handle)); 1683Assert.False(m2.IsDeclaredReadOnly); 1684Assert.False(m2.IsEffectivelyReadOnly);
CodeGen\CodeGenScriptTests.cs (2)
229Assert.False(sx.AnonymousTypeManager.AreTemplatesSealed); 253Assert.False(sx.AnonymousTypeManager.AreTemplatesSealed);
CodeGen\CodeGenTests.cs (1)
13082Assert.False(field.CanBeReferencedByName);
CodeGen\CodeGenTupleEqualityTests.cs (1)
692Assert.False(model.GetConstantValue(tuple2).HasValue);
CodeGen\CodeGenTupleTest.cs (173)
495Assert.False(((NamedTypeSymbol)typeArg).IsSerializable); 700Assert.False(typeArg.TupleElementNames.IsDefault); 716Assert.False(typeArg.TupleElementNames.IsDefault); 838Assert.False(validField.Type.IsErrorType()); 844Assert.False(validFieldWithAttribute.Type.IsTupleType); 850Assert.False(((NamedTypeSymbol)tooFewNames.Type).IsSerializable); 931Assert.False(validField.Type.IsErrorType()); 937Assert.False(validFieldWithAttribute.Type.IsTupleType); 941Assert.False(partialNames.Type.IsErrorType()); 946Assert.False(allNullNames.Type.IsErrorType()); 952Assert.False(partialParamType.Type.IsErrorType()); 958Assert.False(allNullParamType.Type.IsErrorType()); 997Assert.False(field1.Type.IsErrorType()); 3355Assert.False(mTuple.IsImplicitlyDeclared); 3358Assert.False(mTuple.TupleData.UnderlyingDefinitionToMemberMap.Any()); 3373Assert.False(mFirst.Locations.IsEmpty); 3375Assert.False(mFirst.IsImplicitlyDeclared); 3648Assert.False(item.CorrespondingTupleField.IsExplicitlyNamedTupleElement); 3695Assert.False(yType.TupleElements[0].CorrespondingTupleField.IsExplicitlyNamedTupleElement); 3698Assert.False(yType.TupleElements[1].IsExplicitlyNamedTupleElement); 3703Assert.False(yType.TupleElements[2].CorrespondingTupleField.IsExplicitlyNamedTupleElement); 4514Assert.False(namedTuple.IsDefinition); 4520Assert.False(namedTuple.Equals(namedTuple.TupleUnderlyingType, TypeCompareKind.ConsiderEverything)); 5831Assert.False(vt8.IsTupleType); 6035Assert.False(vt8.OriginalDefinition.IsTupleType); 6158Assert.False(vt2.IsDefinition); 6226Assert.False(ns.IsGlobalNamespace); 6234Assert.False(ns.IsGlobalNamespace); 6242Assert.False(ns.IsGlobalNamespace); 6253Assert.False(ns.IsGlobalNamespace); 6508Assert.False(tuple9WithoutNames.IsDefinition); 6529Assert.False(tuple9WithNames.IsDefinition); 6618Assert.False(tuple1.Equals(tuple3)); 6621Assert.False(tuple1.Equals(tuple4)); 6815Assert.False(tuple1.Equals(tuple2, SymbolEqualityComparer.IncludeNullability)); 6850Assert.False(TypeEquals(tuple1, tuple2, TypeCompareKind.IgnoreTupleNames)); 6884Assert.False(tuple1.Equals(tuple2, SymbolEqualityComparer.IncludeNullability)); 6919Assert.False(TypeEquals(tuple1, tuple2, TypeCompareKind.IgnoreTupleNames)); 6936Assert.False(stringType.IsTupleType); 7586Assert.False(conversion2.UnderlyingConversions.IsDefault); 7595Assert.False(conversion3.UnderlyingConversions.IsDefault); 11155Assert.False(m1Tuple.IsImplicitlyDeclared); 11160Assert.False(m1Tuple.IsDefinition); 11209Assert.False(m1Tuple.IsComImport); 11227Assert.False(m1Tuple.Equals(m2Tuple)); 11228Assert.False(m1Tuple.Equals(m6Tuple)); 11229Assert.False(m6Tuple.Equals(m2Tuple)); 11255Assert.False(m1Item1.Locations.IsEmpty); 11262Assert.False(m2Item1.IsDefinition); 11270Assert.False(m2Tuple.IsDefinition); 11276Assert.False(m2Item1.Locations.IsEmpty); 11297Assert.False(m2a2.Locations.IsEmpty); 11300Assert.False(m2a2.IsImplicitlyDeclared); 11303Assert.False(m6Tuple.IsDefinition); 11419Assert.False(m1Tuple.IsImplicitlyDeclared); 11498Assert.False(m1Tuple.IsComImport); 11521Assert.False(m1Tuple.Equals(m2Tuple)); 11522Assert.False(m1Tuple.Equals(m6Tuple)); 11523Assert.False(m6Tuple.Equals(m2Tuple)); 11550Assert.False(m1Item9.Locations.IsEmpty); 11565Assert.False(m2Item9.Locations.IsEmpty); 11582Assert.False(m2i2.Locations.IsEmpty); 11585Assert.False(m2i2.IsImplicitlyDeclared); 11604Assert.False(members[i].Equals(members[j])); 11605Assert.False(members[j].Equals(members[i])); 11661Assert.False(members1[i].Equals(members2[j])); 11668Assert.False(tuple2.Equals(tuple1)); 11673Assert.False(members2.Any(u => u.Equals(m))); 11674Assert.False(members2.Any(u => m.Equals(u))); 11784Assert.False(m3Item8.Locations.IsEmpty); 11977Assert.False(m4Item8.Locations.IsEmpty); 11996Assert.False(m4h4.Locations.IsEmpty); 11999Assert.False(m4h4.IsImplicitlyDeclared); 12225Assert.False(m5Item8.Locations.IsEmpty); 12228Assert.False(m5Item8.IsImplicitlyDeclared); 12593Assert.False(m8Item8.Locations.IsEmpty); 12613Assert.False(m8Item1.Locations.IsEmpty); 12617Assert.False(m8Item1.IsImplicitlyDeclared); 12737Assert.False(m1Tuple.IsImplicitlyDeclared); 12756Assert.False(m1Tuple.IsComImport); 12778Assert.False(m1Tuple.Equals(m2Tuple)); 12779Assert.False(m1Tuple.Equals(m6Tuple)); 12780Assert.False(m6Tuple.Equals(m2Tuple)); 12806Assert.False(m1Item1.Locations.IsEmpty); 12825Assert.False(m2Item1.Locations.IsEmpty); 12844Assert.False(m2a2.Locations.IsEmpty); 12847Assert.False(m2a2.IsImplicitlyDeclared); 12857Assert.False(m1ToString.IsExplicitInterfaceImplementation); 12859Assert.False(m1ToString.ReturnsVoid); 12866Assert.False(m1ToString.Locations.IsEmpty); 13451Assert.False(sym.IsVirtualTupleField); 13469Assert.False(sym.IsVirtualTupleField); 13599Assert.False(t1.Equals(t3)); 13607Assert.False(t5.Equals(t3)); 13618Assert.False(t1.Equals(t6)); 13625Assert.False(t1.Equals(t8)); 13630Assert.False(t6.Equals(t8)); 13651Assert.False(t1.Equals(t3)); 13659Assert.False(t5.Equals(t3)); 13672Assert.False(t1.Equals(t6)); 13680Assert.False(t1.Equals(t8)); 13685Assert.False(t6.Equals(t8)); 13704Assert.False(t1.Equals(t11)); 13708Assert.False(t1.Equals(t11)); 13710Assert.False(t11.Equals(t1)); 13761Assert.False(t1.Equals(t12)); 13765Assert.False(t1.TupleUnderlyingType.Equals(t12.TupleUnderlyingType)); 13767Assert.False(t12.TupleUnderlyingType.Equals(t1.TupleUnderlyingType)); 13770Assert.False(t1.Equals(t12)); 13772Assert.False(t12.Equals(t1)); 13838Assert.False(t1.Equals(t3)); 13846Assert.False(t5.Equals(t3)); 13857Assert.False(t1.Equals(t6)); 13864Assert.False(t1.Equals(t8)); 13869Assert.False(t6.Equals(t8)); 14005Assert.False(typeInfo.Type.IsTupleType); 14232Assert.False(m1Tuple.IsTupleType); 14237Assert.False(m1Tuple.IsTupleType); 14271Assert.False(f1Tuple.IsTupleType); 14285Assert.False(p1Tuple.IsTupleType); 14299Assert.False(m3TupleArray.ElementType.IsTupleType); 14317Assert.False(m4TupleList.TypeArguments[0].IsTupleType); 14426Assert.False(e1Tuple.IsTupleType); 14443Assert.False(m5TuplePointer.PointedAtType.IsTupleType); 14460Assert.False(v1Tuple.IsTupleType); 15829Assert.False(m1P1.IsImplicitlyDeclared); 15833Assert.False(m1P1.IsExplicitInterfaceImplementation); 15835Assert.False(m1P1.IsIndexer); 15839Assert.False(m1P1Get.IsImplicitlyDeclared); 15842Assert.False(m1P1Set.IsImplicitlyDeclared); 15859Assert.False(m1this.IsImplicitlyDeclared); 15863Assert.False(m1this.IsExplicitInterfaceImplementation); 15868Assert.False(m1this.IsDefinition); 15869Assert.False(m1thisGet.IsImplicitlyDeclared); 16060Assert.False(m1E1.IsImplicitlyDeclared); 16063Assert.False(m1E1.IsExplicitInterfaceImplementation); 16091Assert.False(m1E2.IsImplicitlyDeclared); 16096Assert.False(m1E2.IsExplicitInterfaceImplementation); 16103Assert.False(m1E2Add.IsImplicitlyDeclared); 16107Assert.False(m1E2Remove.IsImplicitlyDeclared); 22292Assert.False(item.IsExplicitlyNamedTupleElement); 25330Assert.False(found.IsErrorType()); 25335Assert.False(tuple2.IsErrorType()); 25341Assert.False(tuple3.IsErrorType()); 26901Assert.False(tuple.TupleUnderlyingType.IsErrorType()); 26902Assert.False(tuple.IsErrorType()); 26968Assert.False(tuple1.TupleUnderlyingType.IsErrorType()); 26969Assert.False(tuple1.IsErrorType()); 26984Assert.False(tuple2.TupleUnderlyingType.IsErrorType()); 26985Assert.False(tuple2.IsErrorType()); 27479Assert.False(type.Equals(underlyingType, TypeCompareKind.ConsiderEverything)); 27502Assert.False(type.Equals(underlyingType, SymbolEqualityComparer.Default)); 27503Assert.False(type.Equals(underlyingType, SymbolEqualityComparer.ConsiderEverything)); 27928Assert.False(field.HasComplete(CompletionPart.All)); 27929Assert.False(underlyingField.HasComplete(CompletionPart.All)); 28010Assert.False(field.IsExplicitlyNamedTupleElement); 28271Assert.False(item.IsImplicitlyDeclared); 28272Assert.False(item.IsVirtualTupleField); 28289Assert.False(item.IsExplicitlyNamedTupleElement); 28332Assert.False(namedType.IsTupleType); 28348Assert.False(item.IsDefaultTupleElement); 28351Assert.False(item.IsImplicitlyDeclared); 28352Assert.False(item.IsVirtualTupleField); 28369Assert.False(item.IsExplicitlyNamedTupleElement); 28410Assert.All(fields, f => Assert.False(f.HasUseSiteError)); 28438Assert.False(item.IsImplicitlyDeclared); 28439Assert.False(item.IsVirtualTupleField); 28463Assert.False(item.IsExplicitlyNamedTupleElement); 28568Assert.False(field.IsTupleElement()); 28569Assert.False(field.IsDefaultTupleElement); 28717Assert.False(tuple1Item1.IsDefinition); 28729Assert.False(tuple2Item1.IsDefinition); 28743Assert.False(tuple3Item1.IsDefinition);
CodeGen\DestructorTests.cs (15)
591Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("B").GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); 592Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); 593Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("D").GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); 594Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("E").GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); 595Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("F").GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); 596Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("G").GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); 598Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("I").GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); 604Assert.False(classJ.GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); 606Assert.False(classJInt.GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); 674Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("D").GetMember<MethodSymbol>("Finalize").IsRuntimeFinalizer()); //same but has "newslot" 827Assert.False(destructor.IsVirtual); 828Assert.False(destructor.IsOverride); 829Assert.False(destructor.IsSealed); 830Assert.False(destructor.IsStatic); 831Assert.False(destructor.IsAbstract);
CodeGen\EventTests.cs (4)
213Assert.False(@event.MustCallMethodsDirectly); 239Assert.False(@event.HasAssociatedField); 719Assert.False((addMethod.ImplementationAttributes & System.Reflection.MethodImplAttributes.Synchronized) == 0); 722Assert.False((removeMethod.ImplementationAttributes & System.Reflection.MethodImplAttributes.Synchronized) == 0);
CodeGen\IndexerTests.cs (4)
156Assert.False(indexer.IsIndexer); 159Assert.False(indexer.IsStatic); 259Assert.False(indexer.MustCallMethodsDirectly); 261Assert.False(indexer.IsStatic);
CodeGen\WinMdDelegateTests.cs (1)
264Assert.False(isWinRt(fieldSymbol));
Emit\CompilationEmitTests.cs (24)
161Assert.False(emitResult.Success); 2703Assert.False(libComp.GetDiagnostics().Any()); 2760Assert.False(exeComp.GetDiagnostics().Any()); 3378Assert.False(emitResult.Success); 3502Assert.False(peHeaders.Requires64Bits()); 3503Assert.False(peHeaders.RequiresAmdInstructionSet()); 3508Assert.False(peHeaders.Requires64Bits()); 3509Assert.False(peHeaders.RequiresAmdInstructionSet()); 3529Assert.False(peHeaders.Requires64Bits()); 3531Assert.False(peHeaders.IsExe); 3532Assert.False(peHeaders.CoffHeader.Characteristics.HasFlag(Characteristics.LargeAddressAware)); 3565Assert.False(peHeaders.IsExe); 3613Assert.False(peHeaders.Requires64Bits()); 3615Assert.False(peHeaders.IsExe); 3653Assert.False(peHeaders.Requires64Bits()); 3655Assert.False(peHeaders.IsDll); 3695Assert.False(peHeaders.IsDll); 4066Assert.False(peReader.IsAssembly); 4239Assert.False(result.Success); 5459Assert.False(result.Success); 5481Assert.False(result.Success); 5558Assert.False(b.IsErrorType()); 5563Assert.False(a.IsErrorType()); 5599Assert.False(emitResult.Success);
Emit\DeterministicTests.cs (1)
87Assert.False(resultDeterministic.Success);
Emit\EmitCustomModifiers.cs (3)
607Assert.False(parameter.TypeWithAnnotations.CustomModifiers.IsEmpty); 663Assert.False(baseParameter.TypeWithAnnotations.CustomModifiers.IsEmpty); 671Assert.False(derivedParameter.TypeWithAnnotations.CustomModifiers.IsEmpty);
Emit\EmitErrorTests.cs (1)
243Assert.False(result.Success);
Emit\EmitMetadataTests.cs (72)
260Assert.False(file1.HashValue.IsNil); 261Assert.False(file2.HashValue.IsNil); 364Assert.False(i3.Interfaces().Any()); 365Assert.False(i4.Interfaces().Any()); 367Assert.False(i6.Interfaces().Any()); 368Assert.False(i7.Interfaces().Any()); 555Assert.False(f1.IsVolatile); 576Assert.False(mod.IsOptional); 606Assert.False(ctor.IsStatic); 607Assert.False(ctor.IsAbstract); 608Assert.False(ctor.IsSealed); 609Assert.False(ctor.IsVirtual); 610Assert.False(ctor.IsOverride); 611Assert.False(ctor.IsGenericMethod); 612Assert.False(ctor.IsExtensionMethod); 614Assert.False(ctor.IsVararg); 628Assert.False(cctor.IsAbstract); 629Assert.False(cctor.IsSealed); 630Assert.False(cctor.IsVirtual); 631Assert.False(cctor.IsOverride); 632Assert.False(cctor.IsGenericMethod); 633Assert.False(cctor.IsExtensionMethod); 635Assert.False(cctor.IsVararg); 949Assert.False(pBack.IsReadOnly); 950Assert.False(pBack.IsStatic); 955Assert.False(qBack.IsReadOnly); 956Assert.False(qBack.IsStatic); 962Assert.False(rBack.IsStatic); 1019Assert.False(p.HasInitializer); 1021Assert.False(p.IsStatic); 1027Assert.False(qBack.IsStatic); 1033Assert.False(rBack.IsStatic); 1090Assert.False(propertyP.SetMethod.IsVirtual); 1091Assert.False(propertyP.SetMethod.IsOverride); 1099Assert.False(propertyP.GetMethod.IsOverride); 1103Assert.False(propertyQ.GetMethod.IsOverride); 1105Assert.False(propertyQ.SetMethod.IsOverride); 1106Assert.False(propertyQ.IsReadOnly); 1107Assert.False(propertyQ.IsWriteOnly); 1110Assert.False(propertyP.MustCallMethodsDirectly); 1111Assert.False(propertyQ.MustCallMethodsDirectly); 1117Assert.False(propertyP.GetMethod.IsVirtual); 1123Assert.False(propertyQ.SetMethod.IsVirtual); 1125Assert.False(propertyQ.IsReadOnly); 1126Assert.False(propertyQ.IsWriteOnly); 1129Assert.False(propertyP.MustCallMethodsDirectly); 1130Assert.False(propertyQ.MustCallMethodsDirectly); 1239Assert.False(getMethodA.IsOverride); 1245Assert.False(getMethodC.IsVirtual); 1385Assert.False(fieldDefinition.IsSpecialName); 1386Assert.False(fieldDefinition.IsRuntimeSpecial); 1408Assert.False(field.IsStatic); 1409Assert.False(field.IsConst); 1410Assert.False(field.IsReadOnly); 2551Assert.False(parameters[3].IsMetadataIn); 2575Assert.False(parameters[3].IsMetadataIn); 2607Assert.False(parameters[3].IsMetadataIn); 2617Assert.False(delegateParameters[3].IsMetadataIn); 2624Assert.False(lambdaParameters[2].IsMetadataIn); 2625Assert.False(lambdaParameters[3].IsMetadataIn); 2649Assert.False(parameters[1].IsMetadataIn); 2672Assert.False(parameters[3].IsMetadataIn); 2701Assert.False(parameters[3].IsMetadataIn); 2725Assert.False(parameters[3].IsMetadataIn); 2816Assert.False(parentParameters[0].IsMetadataIn); 2817Assert.False(parentParameters[1].IsMetadataIn); 2818Assert.False(parentParameters[2].IsMetadataIn); 2819Assert.False(parentParameters[3].IsMetadataIn); 2833Assert.False(childParameters[3].IsMetadataIn); 2885Assert.False(proxyChildParameters[1].IsMetadataOut); // User placed attributes are not copied. 2937Assert.False(proxyChildParameters[1].IsMetadataIn); // User placed attributes are not copied. 3681Assert.False(emitResult.Success);
Emit\GeneratedNamesTests.cs (2)
54Assert.False(GeneratedNames.TryParseSynthesizedDelegateName(name, out _, out _, out _, out _)); 96Assert.False(CommonGeneratedNames.TryParseDebugIds(metadataName.AsSpan(), GeneratedNameConstants.IdSeparator, isMethodIdOptional: false, out _, out _));
Emit\InAttributeModifierTests.cs (4)
4502Assert.False(parentMethod.IsMetadataVirtual()); 4507Assert.False(childMethod.IsMetadataVirtual()); 4545Assert.False(parentMethod.IsMetadataVirtual()); 4568Assert.False(modifier.IsOptional);
Emit\NoPiaEmbedTypes.cs (45)
136Assert.False(result.Success); 151Assert.False(result.Success); 1179Assert.False(itest1.IsSerializable); 1180Assert.False(itest1.IsSealed); 1200Assert.False(test2.IsComImport); 1201Assert.False(test2.IsSerializable); 1221Assert.False(itest3.IsSerializable); 1222Assert.False(itest3.IsSealed); 1232Assert.False(test5.IsComImport); 1260Assert.False(test9.IsComImport); 1261Assert.False(test9.IsSerializable); 1283Assert.False(value__.IsStatic); 1296Assert.False(f1.HasSpecialName); 1297Assert.False(f1.HasRuntimeSpecialName); 1322Assert.False(f3.IsStatic); 1323Assert.False(f3.HasSpecialName); 1324Assert.False(f3.HasRuntimeSpecialName); 1327Assert.False(f3.TypeLayoutOffset.HasValue); 1333Assert.False(f4.IsNotSerialized); 1481Assert.False(paramInfo[0].IsByRef); 1501Assert.False(metadata.GetMethodsOfTypeOrThrow(itest18.Handle).AsEnumerable().Any()); 1579Assert.False(p1.HasRuntimeSpecialName); 1608Assert.False(p4.HasSpecialName); 1609Assert.False(p4.HasRuntimeSpecialName); 1621Assert.False(e1.HasRuntimeSpecialName); 1633Assert.False(e2.HasSpecialName); 1634Assert.False(e2.HasRuntimeSpecialName); 1744Assert.False(t1.HasConstructorConstraint); 1745Assert.False(t1.HasValueTypeConstraint); 1746Assert.False(t1.HasReferenceTypeConstraint); 1751Assert.False(t2.HasConstructorConstraint); 1752Assert.False(t2.HasValueTypeConstraint); 1753Assert.False(t2.HasReferenceTypeConstraint); 1760Assert.False(t5.HasValueTypeConstraint); 1761Assert.False(t5.HasReferenceTypeConstraint); 1766Assert.False(t6.HasConstructorConstraint); 1768Assert.False(t6.HasReferenceTypeConstraint); 1773Assert.False(t7.HasConstructorConstraint); 1774Assert.False(t7.HasValueTypeConstraint); 3325Assert.False(m1.Parameters[0].IsParamsCollection); 5889Assert.False(p.IsMetadataOptional); 5892Assert.False(p.HasExplicitDefaultValue); 5957Assert.False(p.IsMetadataOptional); 5961Assert.False(p.HasExplicitDefaultValue); 6027Assert.False(p1.Handle.IsNil);
Emit\ResourceTests.cs (7)
473Assert.False(result.Success); 483Assert.False(result.Success); 492Assert.False(result.Success); 717Assert.False(result6.Success); 736Assert.False(result6.Success); 780Assert.False(result.Success); 807Assert.False(result.Success);
Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (22)
Emit\EditAndContinue\EditAndContinueTests.cs (7)
361Assert.False(diff1.GetMetadata().Reader.IsAssembly); 9182Assert.False(diff1.MetadataDelta.IsIncluded("WriteLine")); 12833Assert.False(result.Success); 12849Assert.False(result.Success); 12865Assert.False(result.Success); 12921Assert.False(result.Success); 12957Assert.False(diff1.EmitResult.Success);
Emit\NumericIntPtrTests.cs (6)
3539Assert.False(IsNoConversion(expectedConversions)); 10365Assert.False(fromAPI.IsNativeIntegerWrapperType); 10378Assert.False(fromAPI.IsNativeIntegerWrapperType); 10404Assert.False(type.IsNativeIntegerWrapperType); 10738Assert.False(m.ReturnType.IsNativeIntegerWrapperType); 11207Assert.False(symbol.IsNativeIntegerType);
Emit\UnmanagedTypeModifierTests.cs (4)
1067Assert.False(typeParameter.HasConstructorConstraint); // .ctor is an artifact of emit, we will ignore it on importing. 1093Assert.False(typeParameter.HasConstructorConstraint); // .ctor is an artifact of emit, we will ignore it on importing. 1449Assert.False(typeParameter.HasReferenceTypeConstraint); 1450Assert.False(typeParameter.HasConstructorConstraint);
PDB\PDBTests.cs (5)
59Assert.False(result.Success); 272Assert.False(result.Success); 304Assert.False(result.Success); 336Assert.False(result.Success); 368Assert.False(result.Success);
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (1339)
Attributes\AttributeTests.cs (36)
57Assert.False(predefined.IsPossibleMatch(typeForwardedTo, QuickAttributes.TypeIdentifier)); 58Assert.False(predefined.IsPossibleMatch(typeForwardedTo, QuickAttributes.None)); 60Assert.False(predefined.IsPossibleMatch(typeIdentifier, QuickAttributes.TypeForwardedTo)); 62Assert.False(predefined.IsPossibleMatch(typeIdentifier, QuickAttributes.None)); 67Assert.False(checker1.IsPossibleMatch(alias1, QuickAttributes.TypeIdentifier)); 76Assert.False(checker1b.IsPossibleMatch(alias1, QuickAttributes.TypeIdentifier)); 77Assert.False(checker1b.IsPossibleMatch(alias2, QuickAttributes.TypeForwardedTo)); 355Assert.False(c.IsErrorType()); 1917Assert.False(field2.HasSpecialName); 1979Assert.False(field2.IsNotSerialized); 2337Assert.False(field1.ObsoleteAttributeData.IsError); 3456Assert.False(attrs.First().AttributeConstructor.Parameters.Last().IsParamsCollection); 3595Assert.False(attrs.First().AttributeConstructor.Parameters.Last().IsParamsCollection); 4646Assert.False(attr.HasErrors); 4678Assert.False(attr.HasErrors); 4711Assert.False(attr.HasErrors); 4743Assert.False(attr.HasErrors); 4779Assert.False(attr.HasErrors); 4810Assert.False(attr.HasErrors); 4836Assert.False(attr.HasErrors); 4868Assert.False(attr.HasErrors); 8778Assert.False(method.TestIsExtensionBitTrue); 8779Assert.False(method.IsExtensionMethod); 8819Assert.False(yParam.IsParamsCollection); 10039Assert.False(emitResult2.Success); 10053Assert.False(emitResult3.Success); 10242Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType); 10246Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType); 10263Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType); 10271Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType); 10292Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType); 10296Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType); 10318Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType); 10322Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType); 10344Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType); 10348Assert.False(comp.GlobalNamespace.GetTypeMember("C").GetAttributes().Single().AttributeClass.IsGenericType);
Attributes\AttributeTests_Assembly.cs (3)
1071Assert.False(token.IsNil); //could the type ref be located? If not then the attribute's not there. 1192Assert.False(token.IsNil); //could the type ref be located? If not then the attribute's not there. 1839Assert.False(token.IsNil); //could the type ref be located? If not then the attribute's not there.
Attributes\AttributeTests_Dynamic.cs (3)
203Assert.False(_inner2Class.BaseType().ContainsDynamic()); 207Assert.False(_innerInner2Class.BaseType().ContainsDynamic()); 440Assert.False(_unsafeClass.ContainsDynamic());
Attributes\AttributeTests_Embedded.cs (1)
749Assert.False(referenceAttribute.Equals(generatedAttribute));
Attributes\AttributeTests_NativeInteger.cs (2)
1467Assert.False(attributeUsage.Inherited); 1468Assert.False(attributeUsage.AllowMultiple);
Attributes\AttributeTests_Nullable.cs (5)
195Assert.False(reader.TypeDefinitions.Any(h => reader.StringComparer.Equals(reader.GetTypeDefinition(h).Name, name))); 4975Assert.False(attributeUsage.Inherited); 4976Assert.False(attributeUsage.AllowMultiple); 5396Assert.False(attributes.Contains("NullableContextAttribute")); 5397Assert.False(attributes.Contains("NullableAttribute"));
Attributes\AttributeTests_NullableContext.cs (2)
210Assert.False(attributeUsage.Inherited); 211Assert.False(attributeUsage.AllowMultiple);
Attributes\AttributeTests_NullablePublicOnly.cs (2)
506Assert.False(attributeUsage.Inherited); 507Assert.False(attributeUsage.AllowMultiple);
Attributes\AttributeTests_RefReadOnly.cs (9)
1374Assert.False(NeedsGeneratedIsReadOnlyAttribute(compilation)); 1388Assert.False(NeedsGeneratedIsReadOnlyAttribute(compilation)); 1416Assert.False(NeedsGeneratedIsReadOnlyAttribute(compilation)); 1430Assert.False(NeedsGeneratedIsReadOnlyAttribute(compilation)); 1445Assert.False(NeedsGeneratedIsReadOnlyAttribute(compilation)); 1457Assert.False(NeedsGeneratedIsReadOnlyAttribute(compilation)); 1472Assert.False(NeedsGeneratedIsReadOnlyAttribute(compilation)); 1484Assert.False(NeedsGeneratedIsReadOnlyAttribute(compilation)); 1511Assert.False(NeedsGeneratedIsReadOnlyAttribute(compilation));
Attributes\AttributeTests_Security.cs (1)
1640Assert.False(emitResult.Success);
Attributes\AttributeTests_StructLayout.cs (8)
638Assert.False(hasClassLayout); 640Assert.False(badLayout); 646Assert.False(hasClassLayout); 655Assert.False(badLayout); 663Assert.False(badLayout); 668Assert.False(hasClassLayout); 670Assert.False(badLayout); 695Assert.False(layout.IsDefault);
Attributes\AttributeTests_WellKnownAttributes.cs (25)
864Assert.False(ps[0].HasExplicitDefaultValue); 873Assert.False(ps[0].IsOptional); 903Assert.False(ps[0].IsOptional); 930Assert.False(ps[0].HasExplicitDefaultValue); 1019Assert.False(ps[0].HasExplicitDefaultValue); 1063Assert.False(ps[0].HasExplicitDefaultValue); 2771Assert.False(info.ExactSpelling); 2772Assert.False(info.SetLastError); 3433Assert.False(MetadataValidation.FindCustomAttribute(metadataReader, "DefaultCharSetAttribute").IsNil); 3465Assert.False(MetadataValidation.FindCustomAttribute(metadataReader, "DefaultCharSetAttribute").IsNil); 3693Assert.False(ctorA.IsExtern); 3696Assert.False(methodGoo.IsExtern); 4905Assert.False(typeBobAttribute.IsSerializable); 4974Assert.False(((NamedTypeSymbol)substitutedNested).IsSerializable); 4986Assert.False(((NamedTypeSymbol)constructed).IsSerializable); 4994Assert.False(((NamedTypeSymbol)extendedError).IsSerializable); 4998Assert.False(((NamedTypeSymbol)topLevel).IsSerializable); 5002Assert.False(((NamedTypeSymbol)nested).IsSerializable); 5006Assert.False(((NamedTypeSymbol)constructedError).IsSerializable); 5010Assert.False(((NamedTypeSymbol)nestedSubstitutedError).IsSerializable); 5014Assert.False(((NamedTypeSymbol)unbound).IsSerializable); 5019Assert.False(((NamedTypeSymbol)scriptClass).IsSerializable); 9745Assert.False(param.IsParamsCollection); 9746Assert.False(param.IsOptional); 9747Assert.False(param.HasExplicitDefaultValue);
Attributes\InternalsVisibleToAndStrongNameTests.cs (15)
618Assert.False(comp.IsRealSigned); 640Assert.False(comp.IsRealSigned); 666Assert.False(comp.IsRealSigned); 707Assert.False(comp.IsRealSigned); 1306Assert.False(other.Assembly.GivesAccessTo(requestor.Assembly)); 1342Assert.False(other.Assembly.GivesAccessTo(requestor.Assembly)); 1541Assert.False(token.IsNil); //could the type ref be located? If not then the attribute's not there. 1649Assert.False(success.Success); 1704Assert.False(success.Success); 1800Assert.False(success.Success); 2547Assert.False(success.Success); 2578Assert.False(result.Success); 2608Assert.False(success.Success); 2663Assert.False(success.Success); 2804Assert.False(assembly.GetAttributes().Any(attr => attr.IsTargetAttribute(AttributeDescription.InternalsVisibleToAttribute)));
Attributes\WellKnownAttributesTestBase.cs (1)
90Assert.False(parameter.IsParamsCollection);
Diagnostics\DiagnosticAnalyzerTests.cs (6)
514Assert.False(c.Symbol.IsImplicitlyDeclared); 528Assert.False(partiallyDisabledAnalyzer.IsDiagnosticAnalyzerSuppressed(options)); 535Assert.False(fullyDisabledAnalyzer.IsDiagnosticAnalyzerSuppressed(options)); 3574Assert.False(second.Concurrent); 3578Assert.False(second.Concurrent); 3724Assert.False(diagnostics.ContainsKey(analyzer));
Diagnostics\GetDiagnosticsTests.cs (6)
642Assert.False(diagnostics.Single().IsSuppressed); 647Assert.False(effectiveDiagnostics.Single().IsSuppressed); 654Assert.False(analyzerDiagnostics.Single().IsSuppressed); 699Assert.False(diagnostic.IsSuppressed); 747Assert.False(diagnostic.IsSuppressed); 917Assert.False(eventQueue.IsCompleted);
FieldKeywordTests.cs (3)
11119Assert.False(prop.BackingField.InfersNullableAnnotation); 11418Assert.False(prop.BackingField.InfersNullableAnnotation); 11576Assert.False(sourceField.InfersNullableAnnotation);
FirstClassSpanTests.cs (2)
2835Assert.False(argConv.IsUserDefined); 2836Assert.False(argConv.IsIdentity);
FlowAnalysis\IterationJumpYieldStatementTests.cs (28)
46Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 79Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 139Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 169Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 198Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 228Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 281Assert.False(analysisResults.EndPointIsReachable); 303Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 332Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 361Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 390Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 448Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 474Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 512Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 531Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 550Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 572Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 614Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 886Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 937Assert.False(analysis.EndPointIsReachable); 977Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 1005Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 1033Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 1061Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 1104Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 1166Assert.False(ctrlFlow.EndPointIsReachable); 1322Assert.False(ctrlFlow.EndPointIsReachable); 1326Assert.False(ctrlFlow.EndPointIsReachable);
FlowAnalysis\RegionAnalysisTests.cs (19)
322Assert.False(results.Succeeded); 346Assert.False(results.Succeeded); 370Assert.False(results.Succeeded); 2222Assert.False(analysis.Succeeded); 3200Assert.False(analysis.EndPointIsReachable); 4070Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 4359Assert.False(ctrlFlows.EndPointIsReachable); 4440Assert.False(results.Item1.Succeeded); 4441Assert.False(results.Item2.Succeeded); 4740Assert.False(controlFlow.StartPointIsReachable); 4741Assert.False(controlFlow.EndPointIsReachable); 4767Assert.False(controlFlow.EndPointIsReachable); 4819Assert.False(controlFlow.EndPointIsReachable); 5081Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 6278Assert.False(controlFlowAnalysisResults.Succeeded); 8101Assert.False(analysis.Succeeded); 8129Assert.False(analysis.Succeeded); 8973Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 8998Assert.False(controlFlowAnalysisResults.EndPointIsReachable);
FlowAnalysis\TryLockUsingStatementTests.cs (9)
88Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 261Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 299Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 405Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 661Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 817Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 946Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 1183Assert.False(controlFlowAnalysisResults.EndPointIsReachable); 1230Assert.False(controlFlowAnalysisResults.EndPointIsReachable);
PartialEventsAndConstructorsTests.cs (48)
1073Assert.False(e.IsAbstract); 1076Assert.False(e.IsStatic); 1077Assert.False(e.IsExtern); 1078Assert.False(e.IsOverride); 1087Assert.False(m.IsAbstract); 1092Assert.False(m.IsStatic); 1093Assert.False(m.IsExtern); 1094Assert.False(m.IsOverride); 1231Assert.False(e.IsAbstract); 1233Assert.False(e.IsSealed); 1235Assert.False(e.IsExtern); 1236Assert.False(e.IsOverride); 1245Assert.False(m.IsAbstract); 1248Assert.False(m.IsMetadataNewSlot()); 1249Assert.False(m.IsSealed); 1251Assert.False(m.IsExtern); 1252Assert.False(m.IsOverride); 1594Assert.False(ev.GetPublicSymbol().IsExtern); 1595Assert.False(ev.AddMethod!.GetPublicSymbol().IsExtern); 1596Assert.False(ev.RemoveMethod!.GetPublicSymbol().IsExtern); 1599Assert.False(c.GetPublicSymbol().IsExtern); 1719Assert.False(accessor.ImplementationAttributes.HasFlag(MethodImplAttributes.Synchronized)); 1725Assert.False(importData.SetLastError); 1726Assert.False(importData.ExactSpelling); 1763Assert.False(ev.AddMethod.ImplementationAttributes.HasFlag(MethodImplAttributes.Synchronized)); 1767Assert.False(ev.RemoveMethod.ImplementationAttributes.HasFlag(MethodImplAttributes.Synchronized)); 1778Assert.False(ev.GetPublicSymbol().IsExtern); 1779Assert.False(ev.AddMethod!.GetPublicSymbol().IsExtern); 1782Assert.False(ev.AddMethod.ImplementationAttributes.HasFlag(MethodImplAttributes.Synchronized)); 1783Assert.False(ev.RemoveMethod!.GetPublicSymbol().IsExtern); 1786Assert.False(ev.RemoveMethod.ImplementationAttributes.HasFlag(MethodImplAttributes.Synchronized)); 1789Assert.False(c.GetPublicSymbol().IsExtern); 1928Assert.False(e.IsPartialImplementation); 1929Assert.False(e.HasAssociatedField); 1930Assert.False(e.IsWindowsRuntimeEvent); 1933Assert.False(e.SourcePartialImplementationPart.IsPartialDefinition); 1934Assert.False(e.SourcePartialImplementationPart.HasAssociatedField); 1935Assert.False(e.SourcePartialImplementationPart.IsWindowsRuntimeEvent); 1950Assert.False(c.IsPartialImplementation); 1954Assert.False(cImpl.IsPartialDefinition); 1960Assert.False(e.HasAssociatedField); 2007Assert.False(implSymbol.IsPartialDefinition); 2025Assert.False(implSymbol.IsPartialDefinition); 2046Assert.False(implSymbol.IsPartialDefinition); 2083Assert.False(implSymbol.IsPartialDefinition); 2095Assert.False(defOfIntSymbol.IsPartialDefinition); 2114Assert.False(implSymbol.IsPartialDefinition); 2126Assert.False(defOfIntSymbol.IsPartialDefinition);
RefReadonlyParameterTests.cs (3)
101Assert.False(method.HasUnsupportedMetadata); 102Assert.False(method.HasUseSiteError); 1229Assert.False(mod.IsOptional);
RefStructInterfacesTests.cs (287)
111Assert.False(comp.GetMember<MethodSymbol>("I.M").HasUnscopedRefAttribute); 134Assert.False(comp.GetMember<MethodSymbol>("I.M").HasUnscopedRefAttribute); 158Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 190Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 223Assert.False(propertySymbol.HasUnscopedRefAttribute); 224Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 248Assert.False(propertySymbol.HasUnscopedRefAttribute); 249Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 274Assert.False(propertySymbol.HasUnscopedRefAttribute); 312Assert.False(propertySymbol.HasUnscopedRefAttribute); 352Assert.False(propertySymbol.HasUnscopedRefAttribute); 353Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 380Assert.False(propertySymbol.HasUnscopedRefAttribute); 381Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 405Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 437Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 470Assert.False(propertySymbol.HasUnscopedRefAttribute); 471Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 495Assert.False(propertySymbol.IsStatic); 497Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 522Assert.False(propertySymbol.HasUnscopedRefAttribute); 560Assert.False(propertySymbol.HasUnscopedRefAttribute); 600Assert.False(propertySymbol.HasUnscopedRefAttribute); 601Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 628Assert.False(propertySymbol.IsStatic); 629Assert.False(propertySymbol.HasUnscopedRefAttribute); 669Assert.False(comp2.GetMember<MethodSymbol>("C.M").HasUnscopedRefAttribute); 693Assert.False(comp3.GetMember<MethodSymbol>("C.I.M").HasUnscopedRefAttribute); 734Assert.False(m.GlobalNamespace.GetMember<MethodSymbol>("C1.M").HasUnscopedRefAttribute); 735Assert.False(m.GlobalNamespace.GetMember<MethodSymbol>("C2.I.M").HasUnscopedRefAttribute); 736Assert.False(m.GlobalNamespace.GetMember<MethodSymbol>("C3.M").HasUnscopedRefAttribute); 761Assert.False(comp5.GetMember<MethodSymbol>("C.I.M").HasUnscopedRefAttribute); 781Assert.False(m.GlobalNamespace.GetMember<MethodSymbol>("C.I.M").HasUnscopedRefAttribute); 870Assert.False(m.GlobalNamespace.GetMember<MethodSymbol>("C.M").HasUnscopedRefAttribute); 891Assert.False(m.GlobalNamespace.GetMember<MethodSymbol>("C.I.M").HasUnscopedRefAttribute); 1121Assert.False(propertySymbol.HasUnscopedRefAttribute); 1122Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 1177Assert.False(propertySymbol.HasUnscopedRefAttribute); 1178Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 1223Assert.False(c1P.HasUnscopedRefAttribute); 1224Assert.False(c1P.GetMethod.HasUnscopedRefAttribute); 1226Assert.False(c2P.HasUnscopedRefAttribute); 1227Assert.False(c2P.GetMethod.HasUnscopedRefAttribute); 1229Assert.False(c3P.HasUnscopedRefAttribute); 1230Assert.False(c3P.GetMethod.HasUnscopedRefAttribute); 1289Assert.False(propertySymbol.HasUnscopedRefAttribute); 1290Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 1311Assert.False(propertySymbol.HasUnscopedRefAttribute); 1312Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 1458Assert.False(propertySymbol.HasUnscopedRefAttribute); 1459Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 1478Assert.False(propertySymbol.HasUnscopedRefAttribute); 1479Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 1697Assert.False(propertySymbol.HasUnscopedRefAttribute); 1698Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 1753Assert.False(propertySymbol.HasUnscopedRefAttribute); 1754Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 1799Assert.False(c1P.HasUnscopedRefAttribute); 1800Assert.False(c1P.GetMethod.HasUnscopedRefAttribute); 1802Assert.False(c2P.HasUnscopedRefAttribute); 1803Assert.False(c2P.GetMethod.HasUnscopedRefAttribute); 1805Assert.False(c3P.HasUnscopedRefAttribute); 1806Assert.False(c3P.GetMethod.HasUnscopedRefAttribute); 1865Assert.False(propertySymbol.HasUnscopedRefAttribute); 1866Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 1887Assert.False(propertySymbol.HasUnscopedRefAttribute); 1888Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 2034Assert.False(propertySymbol.HasUnscopedRefAttribute); 2035Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 2054Assert.False(propertySymbol.HasUnscopedRefAttribute); 2055Assert.False(propertySymbol.GetMethod.HasUnscopedRefAttribute); 4378Assert.False(t.HasReferenceTypeConstraint); 4379Assert.False(t.HasValueTypeConstraint); 4380Assert.False(t.HasUnmanagedTypeConstraint); 4381Assert.False(t.HasNotNullConstraint); 4401Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefLikeGenerics)); 4408Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefLikeGenerics)); 4431Assert.False(t.HasReferenceTypeConstraint); 4432Assert.False(t.HasValueTypeConstraint); 4433Assert.False(t.HasUnmanagedTypeConstraint); 4434Assert.False(t.HasNotNullConstraint); 4484Assert.False(t.HasReferenceTypeConstraint); 4485Assert.False(t.HasValueTypeConstraint); 4486Assert.False(t.HasUnmanagedTypeConstraint); 4487Assert.False(t.HasNotNullConstraint); 4492Assert.False(dt.HasReferenceTypeConstraint); 4493Assert.False(dt.HasValueTypeConstraint); 4494Assert.False(dt.HasUnmanagedTypeConstraint); 4495Assert.False(dt.HasNotNullConstraint); 4518Assert.False(ct.HasReferenceTypeConstraint); 4519Assert.False(ct.HasValueTypeConstraint); 4520Assert.False(ct.HasUnmanagedTypeConstraint); 4521Assert.False(ct.HasNotNullConstraint); 4547Assert.False(t.HasReferenceTypeConstraint); 4549Assert.False(t.HasUnmanagedTypeConstraint); 4550Assert.False(t.HasNotNullConstraint); 4569Assert.False(t.HasReferenceTypeConstraint); 4571Assert.False(t.HasUnmanagedTypeConstraint); 4572Assert.False(t.HasNotNullConstraint); 4602Assert.False(t.HasValueTypeConstraint); 4603Assert.False(t.HasUnmanagedTypeConstraint); 4604Assert.False(t.HasNotNullConstraint); 4628Assert.False(t.HasValueTypeConstraint); 4629Assert.False(t.HasUnmanagedTypeConstraint); 4630Assert.False(t.HasNotNullConstraint); 4659Assert.False(t.HasReferenceTypeConstraint); 4660Assert.False(t.HasValueTypeConstraint); 4661Assert.False(t.HasUnmanagedTypeConstraint); 4662Assert.False(t.HasNotNullConstraint); 4694Assert.False(t.HasReferenceTypeConstraint); 4695Assert.False(t.HasValueTypeConstraint); 4696Assert.False(t.HasUnmanagedTypeConstraint); 4697Assert.False(t.HasNotNullConstraint); 4731Assert.False(t.HasReferenceTypeConstraint); 4732Assert.False(t.HasValueTypeConstraint); 4733Assert.False(t.HasUnmanagedTypeConstraint); 4734Assert.False(t.HasNotNullConstraint); 4757Assert.False(t.HasReferenceTypeConstraint); 4758Assert.False(t.HasValueTypeConstraint); 4759Assert.False(t.HasUnmanagedTypeConstraint); 4760Assert.False(t.HasNotNullConstraint); 4786Assert.False(t.HasReferenceTypeConstraint); 4787Assert.False(t.HasValueTypeConstraint); 4788Assert.False(t.HasUnmanagedTypeConstraint); 4789Assert.False(t.HasNotNullConstraint); 4823Assert.False(t.HasReferenceTypeConstraint); 4824Assert.False(t.HasValueTypeConstraint); 4825Assert.False(t.HasUnmanagedTypeConstraint); 4826Assert.False(t.HasNotNullConstraint); 4852Assert.False(t.HasReferenceTypeConstraint); 4853Assert.False(t.HasValueTypeConstraint); 4854Assert.False(t.HasUnmanagedTypeConstraint); 4855Assert.False(t.HasNotNullConstraint); 4874Assert.False(t.HasReferenceTypeConstraint); 4877Assert.False(t.HasNotNullConstraint); 4903Assert.False(t.HasReferenceTypeConstraint); 4904Assert.False(t.HasValueTypeConstraint); 4905Assert.False(t.HasUnmanagedTypeConstraint); 4925Assert.False(t.HasReferenceTypeConstraint); 4926Assert.False(t.HasValueTypeConstraint); 4927Assert.False(t.HasUnmanagedTypeConstraint); 4953Assert.False(t.HasReferenceTypeConstraint); 4954Assert.False(t.HasValueTypeConstraint); 4955Assert.False(t.HasUnmanagedTypeConstraint); 4956Assert.False(t.HasNotNullConstraint); 4980Assert.False(t.HasReferenceTypeConstraint); 4981Assert.False(t.HasValueTypeConstraint); 4982Assert.False(t.HasUnmanagedTypeConstraint); 4983Assert.False(t.HasNotNullConstraint); 5011Assert.False(t.HasReferenceTypeConstraint); 5012Assert.False(t.HasValueTypeConstraint); 5013Assert.False(t.HasUnmanagedTypeConstraint); 5014Assert.False(t.HasNotNullConstraint); 5040Assert.False(t.HasReferenceTypeConstraint); 5041Assert.False(t.HasValueTypeConstraint); 5042Assert.False(t.HasUnmanagedTypeConstraint); 5043Assert.False(t.HasNotNullConstraint); 5065Assert.False(t.HasReferenceTypeConstraint); 5066Assert.False(t.HasValueTypeConstraint); 5067Assert.False(t.HasUnmanagedTypeConstraint); 5068Assert.False(t.HasNotNullConstraint); 5094Assert.False(t.HasReferenceTypeConstraint); 5095Assert.False(t.HasValueTypeConstraint); 5096Assert.False(t.HasUnmanagedTypeConstraint); 5097Assert.False(t.HasNotNullConstraint); 5118Assert.False(t.HasReferenceTypeConstraint); 5119Assert.False(t.HasValueTypeConstraint); 5120Assert.False(t.HasUnmanagedTypeConstraint); 5121Assert.False(t.HasNotNullConstraint); 5212Assert.False(t.AllowsRefLikeType); 5291Assert.False(t.AllowsRefLikeType); 5349Assert.False(t.AllowsRefLikeType); 5765Assert.False(t.HasReferenceTypeConstraint); 5766Assert.False(t.HasValueTypeConstraint); 5767Assert.False(t.HasUnmanagedTypeConstraint); 5768Assert.False(t.HasNotNullConstraint); 5769Assert.False(t.AllowsRefLikeType); 5770Assert.False(t.GetPublicSymbol().AllowsRefLikeType); 5793Assert.False(t.HasReferenceTypeConstraint); 5794Assert.False(t.HasValueTypeConstraint); 5795Assert.False(t.HasUnmanagedTypeConstraint); 5796Assert.False(t.HasNotNullConstraint); 5800Assert.False(u.HasReferenceTypeConstraint); 5801Assert.False(u.HasValueTypeConstraint); 5802Assert.False(u.HasUnmanagedTypeConstraint); 5803Assert.False(u.HasNotNullConstraint); 5826Assert.False(t.HasReferenceTypeConstraint); 5827Assert.False(t.HasValueTypeConstraint); 5828Assert.False(t.HasUnmanagedTypeConstraint); 5829Assert.False(t.HasNotNullConstraint); 5833Assert.False(u.HasReferenceTypeConstraint); 5834Assert.False(u.HasValueTypeConstraint); 5835Assert.False(u.HasUnmanagedTypeConstraint); 5836Assert.False(u.HasNotNullConstraint); 5837Assert.False(u.AllowsRefLikeType); 7579Assert.False(info.IsAsynchronous); 7584Assert.False(op.Info.IsAsynchronous); 7769Assert.False(info.IsAsynchronous); 7774Assert.False(op.Info.IsAsynchronous); 7989Assert.False(info.IsAsynchronous); 7994Assert.False(op.Info.IsAsynchronous); 8179Assert.False(info.IsAsynchronous); 8184Assert.False(op.Info.IsAsynchronous); 8372Assert.False(info.IsAsynchronous); 8377Assert.False(op.Info.IsAsynchronous); 8447Assert.False(info.IsAsynchronous); 8651Assert.False(info.IsAsynchronous); 8656Assert.False(op.Info.IsAsynchronous); 9022Assert.False(info.IsAsynchronous); 9029Assert.False(op.Info.IsAsynchronous); 9226Assert.False(info.IsAsynchronous); 9233Assert.False(op.Info.IsAsynchronous); 9319Assert.False(moveNextIsPublic); 9390Assert.False(info.IsAsynchronous); 9590Assert.False(info.IsAsynchronous); 9597Assert.False(op.Info.IsAsynchronous); 9814Assert.False(info.IsAsynchronous); 9821Assert.False(op.Info.IsAsynchronous); 10023Assert.False(info.IsAsynchronous); 10030Assert.False(op.Info.IsAsynchronous); 10250Assert.False(info.IsAsynchronous); 10257Assert.False(op.Info.IsAsynchronous); 10353Assert.False(info.IsAsynchronous); 10448Assert.False(info.IsAsynchronous); 10633Assert.False(info.IsAsynchronous); 10640Assert.False(op.Info.IsAsynchronous); 10830Assert.False(info.IsAsynchronous); 10837Assert.False(op.Info.IsAsynchronous); 11071Assert.False(info.IsAsynchronous); 11078Assert.False(op.Info.IsAsynchronous); 11298Assert.False(info.IsAsynchronous); 11305Assert.False(op.Info.IsAsynchronous); 11510Assert.False(info.IsAsynchronous); 11517Assert.False(op.Info.IsAsynchronous); 11610Assert.False(info.IsAsynchronous); 11617Assert.False(op.Info.IsAsynchronous); 11623Assert.False(op.Info.NeedsDispose); 11624Assert.False(op.Info.KnownToImplementIDisposable); 11705Assert.False(info.IsAsynchronous); 11712Assert.False(op.Info.IsAsynchronous); 11718Assert.False(op.Info.NeedsDispose); 11719Assert.False(op.Info.KnownToImplementIDisposable); 15738Assert.False(info.IsAsynchronous); 17072Assert.False(op.Info.KnownToImplementIDisposable); 17164Assert.False(op.Info.NeedsDispose); 17165Assert.False(op.Info.KnownToImplementIDisposable); 17345Assert.False(op.Info.NeedsDispose); 17346Assert.False(op.Info.KnownToImplementIDisposable); 17766Assert.False(info.IsAsynchronous); 17771Assert.False(op.Info.IsAsynchronous); 17963Assert.False(info.IsAsynchronous); 17968Assert.False(op.Info.IsAsynchronous); 18187Assert.False(info.IsAsynchronous); 18192Assert.False(op.Info.IsAsynchronous); 18383Assert.False(info.IsAsynchronous); 18388Assert.False(op.Info.IsAsynchronous); 18584Assert.False(info.IsAsynchronous); 18589Assert.False(op.Info.IsAsynchronous); 18658Assert.False(info.IsAsynchronous); 18868Assert.False(info.IsAsynchronous); 18873Assert.False(op.Info.IsAsynchronous); 19203Assert.False(info.IsAsynchronous); 19210Assert.False(op.Info.IsAsynchronous); 19216Assert.False(op.Info.NeedsDispose); 19217Assert.False(op.Info.KnownToImplementIDisposable); 19374Assert.False(info.IsAsynchronous); 19381Assert.False(op.Info.IsAsynchronous); 19387Assert.False(op.Info.NeedsDispose); 19388Assert.False(op.Info.KnownToImplementIDisposable); 19460Assert.False(moveNextIsPublic); 19531Assert.False(info.IsAsynchronous); 19699Assert.False(info.IsAsynchronous); 19706Assert.False(op.Info.IsAsynchronous); 19712Assert.False(op.Info.NeedsDispose); 19713Assert.False(op.Info.KnownToImplementIDisposable); 19867Assert.False(info.IsAsynchronous); 19874Assert.False(op.Info.IsAsynchronous); 19972Assert.False(info.IsAsynchronous); 22735Assert.False(tp.AllowsRefLikeType); 22852Assert.False(m.ContainingType.TypeParameters.Single().AllowsRefLikeType); 22934Assert.False(m.ContainingType.TypeParameters.Single().AllowsRefLikeType); 22996Assert.False(m.ContainingType.TypeParameters.Single().AllowsRefLikeType); 23027Assert.False(m.ContainingType.TypeParameters.Single().AllowsRefLikeType); 23059Assert.False(m.ContainingType.TypeParameters.Single().AllowsRefLikeType); 23090Assert.False(m.ContainingType.TypeParameters.Single().AllowsRefLikeType); 23121Assert.False(m.ContainingType.TypeParameters.Single().AllowsRefLikeType); 23175Assert.False(m.ContainingType.TypeParameters.Single().AllowsRefLikeType);
Semantics\CollectionExpressionTests.cs (34)
5101Assert.False(elementType.HasType); 14251Assert.False(conversion.IsCollectionExpression); 14256Assert.False(underlyingConversion.IsNullable); 14327Assert.False(conversion.IsCollectionExpression); 14332Assert.False(underlyingConversion.IsNullable); 14398Assert.False(conversion.IsValid); 14671Assert.False(conversion.IsIdentity); 14760Assert.False(conversion.IsIdentity); 14766Assert.False(underlyingConversion.IsNullable); 19406Assert.False(collectionType.HasCollectionBuilderAttribute(out _, out _)); 19410Assert.False(originalType.HasCollectionBuilderAttribute(out _, out _)); 22712Assert.False(comp.SourceModule.UseUpdatedEscapeRules); 28636Assert.False(conversion1.IsValid); 28680Assert.False(conversion1.IsValid); 28770Assert.False(conversion1.IsValid); 28813Assert.False(conversion1.IsValid); 28856Assert.False(conversion.IsValid); 28896Assert.False(conversion.IsValid); 28962Assert.False(conversion1.IsValid); 28982Assert.False(conversion4.IsValid); 29015Assert.False(conversion1.IsValid); 29035Assert.False(conversion4.IsValid); 29081Assert.False(conversion1.IsValid); 29084Assert.False(conversion2.IsValid); 29091Assert.False(conversion3.IsValid); 29098Assert.False(conversion4.IsValid); 29142Assert.False(conversion1.IsValid); 29145Assert.False(conversion2.IsValid); 29152Assert.False(conversion3.IsValid); 29159Assert.False(conversion4.IsValid); 29218Assert.False(conversion1.IsValid); 29266Assert.False(conversion2.IsValid); 29308Assert.False(conversion.IsValid); 30148Assert.False(elementType.HasType);
Semantics\ExtensionOperatorsTests.cs (36)
452Assert.False(method.IsExtensionMethod); 453Assert.False(method.HasSpecialName); 454Assert.False(method.HasRuntimeSpecialName); 455Assert.False(method.HasUnsupportedMetadata); 491Assert.False(method.IsExtensionMethod); 492Assert.False(method.HasSpecialName); 493Assert.False(method.HasRuntimeSpecialName); 494Assert.False(method.HasUnsupportedMetadata); 532Assert.False(method.IsExtensionMethod); 533Assert.False(method.HasSpecialName); 534Assert.False(method.HasRuntimeSpecialName); 535Assert.False(method.HasUnsupportedMetadata); 4584Assert.False(method.IsExtensionMethod); 4585Assert.False(method.HasSpecialName); 4586Assert.False(method.HasRuntimeSpecialName); 4587Assert.False(method.HasUnsupportedMetadata); 4620Assert.False(method.IsExtensionMethod); 4621Assert.False(method.HasSpecialName); 4622Assert.False(method.HasRuntimeSpecialName); 4623Assert.False(method.HasUnsupportedMetadata); 4631Assert.False(method.IsExtensionMethod); 4632Assert.False(method.HasSpecialName); 4633Assert.False(method.HasRuntimeSpecialName); 4634Assert.False(method.HasUnsupportedMetadata); 11277Assert.False(method.IsExtensionMethod); 11278Assert.False(method.HasSpecialName); 11279Assert.False(method.HasRuntimeSpecialName); 11280Assert.False(method.HasUnsupportedMetadata); 11349Assert.False(method.IsExtensionMethod); 11350Assert.False(method.HasSpecialName); 11351Assert.False(method.HasRuntimeSpecialName); 11352Assert.False(method.HasUnsupportedMetadata); 20177Assert.False(method.IsExtensionMethod); 20178Assert.False(method.HasSpecialName); 20179Assert.False(method.HasRuntimeSpecialName); 20180Assert.False(method.HasUnsupportedMetadata);
Semantics\ExtensionTests.cs (55)
77Assert.False(symbol.IsValueType); 78Assert.False(symbol.IsAnonymousType); 79Assert.False(symbol.IsTupleType); 80Assert.False(symbol.IsNativeIntegerType); 82Assert.False(symbol.IsRefLikeType); 83Assert.False(symbol.IsUnmanagedType); 84Assert.False(symbol.IsReadOnly); 85Assert.False(symbol.IsRecord); 89Assert.False(symbol.IsScriptClass); 90Assert.False(symbol.IsImplicitClass); 91Assert.False(symbol.IsComImport); 92Assert.False(symbol.IsFileLocal); 96Assert.False(symbol.MightContainExtensionMethods); 99Assert.False(symbol.IsSerializable); 106Assert.False(symbol.IsStatic); 107Assert.False(symbol.IsVirtual); 108Assert.False(symbol.IsOverride); 109Assert.False(symbol.IsAbstract); 111Assert.False(symbol.IsExtern); 112Assert.False(symbol.IsImplicitlyDeclared); 113Assert.False(symbol.CanBeReferencedByName); 118Assert.False(namedTypeSymbol.IsImplicitlyDeclared); 184Assert.False(symbol.IsGenericType); 185Assert.False(symbol.IsUnboundGenericType); 278Assert.False(symbol.IsUnboundGenericType); 368Assert.False(symbol.TypeParameters.Single().IsReferenceType); 397Assert.False(symbol.IsGenericType); 2740Assert.False(symbol.IsExtension); 2756Assert.False(symbol.IsExtension); 2772Assert.False(symbol.IsExtension); 3333Assert.False(parameter.IsParams); 5229Assert.False(implementation.HasSpecialName); 5230Assert.False(implementation.HasRuntimeSpecialName); 6754Assert.False(implementation.HasSpecialName); 6755Assert.False(implementation.HasRuntimeSpecialName); 8298Assert.False(implementation.IsExtensionMethod); 8299Assert.False(implementation.HasSpecialName); 8300Assert.False(implementation.HasRuntimeSpecialName); 10094Assert.False(implementation.IsExtensionMethod); 10095Assert.False(implementation.HasSpecialName); 10096Assert.False(implementation.HasRuntimeSpecialName); 10402Assert.False(implementation.IsExtensionMethod); 10403Assert.False(implementation.HasSpecialName); 10404Assert.False(implementation.HasRuntimeSpecialName); 23710Assert.False(underlying.ExtensionParameter.HasInterpolatedStringHandlerArgumentError); 23715Assert.False(implM.Parameters[0].HasInterpolatedStringHandlerArgumentError); 23941Assert.False(underlying.ExtensionParameter.HasInterpolatedStringHandlerArgumentError); 23946Assert.False(implM.Parameters[0].HasInterpolatedStringHandlerArgumentError); 49363Assert.False(extension.GetMember<MethodSymbol>("M2").HasSpecialName); 49368Assert.False(extension.GetMember<PropertySymbol>("P2").HasSpecialName); 49372Assert.False(comp.GetMember<MethodSymbol>("E.M2").HasSpecialName); 49375Assert.False(comp.GetMember<MethodSymbol>("E.get_P").HasSpecialName); 49377Assert.False(comp.GetMember<MethodSymbol>("E.get_P2").HasSpecialName); 49402Assert.False(extension.GetMember<PropertySymbol>("P").HasSpecialName); 49465Assert.False(comp.GlobalNamespace.GetTypeMember("E").GetTypeMembers().Single().IsExtension);
Semantics\ExtensionTests2.cs (32)
931Assert.False(module.Module.HasIsReadOnlyAttribute(parameterSymbol.Handle)); 3271Assert.False(extension.IsExtension); 3814Assert.False(comp.GetTypeByMetadataName("E").GetTypeMembers().Single().IsExtension); 3872Assert.False(comp.GetTypeByMetadataName("E").GetTypeMembers().Single().IsExtension); 3928Assert.False(comp.GetTypeByMetadataName("E").GetTypeMembers().Single().IsExtension); 3989Assert.False(comp.GetTypeByMetadataName("E").GetTypeMembers().Single().IsExtension); 4141Assert.False(extension.MangleName); 21159Assert.False(comp.Assembly.RuntimeSupportsNumericIntPtr); 26302Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26590Assert.False(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)); 26591Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)); 26644Assert.False(ExtensionGroupingInfo.HaveSameILSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26645Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26673Assert.False(ExtensionGroupingInfo.HaveSameILSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26674Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26704Assert.False(ExtensionGroupingInfo.HaveSameILSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26705Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26735Assert.False(ExtensionGroupingInfo.HaveSameILSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26736Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26772Assert.False(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)); 26773Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)); 26844() => Assert.False(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)), 26845() => Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)) 26880() => Assert.False(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)), 26881() => Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)) 26922() => Assert.False(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)), 26923() => Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)) 26968() => Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)) 27105() => Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)) 27152() => Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)) 27279Assert.False(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)); 27280Assert.False(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2));
Semantics\InlineArrayTests.cs (12)
142Assert.False(buffer.HasInlineArrayAttribute(out int length)); 301Assert.False(buffer.HasInlineArrayAttribute(out int length)); 367Assert.False(buffer.HasInlineArrayAttribute(out int length)); 433Assert.False(buffer.HasInlineArrayAttribute(out int length)); 1286Assert.False(buffer.HasInlineArrayAttribute(out int length)); 1855Assert.False(buffer.HasInlineArrayAttribute(out int length)); 1881Assert.False(buffer.HasInlineArrayAttribute(out int length)); 18202Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.InlineArrayTypes)); 18205Assert.False(vbComp.SupportsRuntimeCapability(RuntimeCapability.InlineArrayTypes)); 18601Assert.False(forEachInfo.IsAsynchronous); 18927Assert.False(forEachInfo.IsAsynchronous); 19264Assert.False(forEachInfo.IsAsynchronous);
Semantics\OutVarTests.cs (40)
178Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 386Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 423Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 461Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 499Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 537Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 575Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 622Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 659Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 697Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 737Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 776Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 816Assert.False(compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any()); 970Assert.False(((ILocalSymbol)symbol).IsFixed); 1059Assert.False(conversion.Exists); 1156Assert.False(model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Any()); 1157Assert.False(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText)); 2472Assert.False(GetOutVarDeclarations(tree, "x3").Any()); 2473Assert.False(GetOutVarDeclarations(tree, "x4").Any()); 2474Assert.False(GetOutVarDeclarations(tree, "x5").Any()); 2475Assert.False(GetOutVarDeclarations(tree, "x6").Any()); 17832Assert.False(GetOutVarDeclarations(tree).Any()); 17893Assert.False(GetOutVarDeclarations(tree).Any()); 18821Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(constructorDeclaration).IsEmpty); 18822Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(constructorDeclaration.Initializer).IsEmpty); 18823Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(constructorDeclaration.Body).IsEmpty); 18824Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(constructorDeclaration.ExpressionBody).IsEmpty); 22704Assert.False(model.LookupSymbols(decl.SpanStart, name: identifierText).Any()); 22706Assert.False(model.LookupNames(decl.SpanStart).Contains(identifierText)); 22719Assert.False(model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Any()); 23056Assert.False(GetOutVarDeclarations(tree, "x3").Any()); 32391Assert.False(x1.Type.IsErrorType()); 32799Assert.False(dataFlow.VariablesDeclared.Contains(symbol, ReferenceEqualityComparer.Instance)); 32800Assert.False(dataFlow.AlwaysAssigned.Contains(symbol, ReferenceEqualityComparer.Instance)); 32801Assert.False(dataFlow.WrittenInside.Contains(symbol, ReferenceEqualityComparer.Instance)); 32802Assert.False(dataFlow.DataFlowsIn.Contains(symbol, ReferenceEqualityComparer.Instance)); 32803Assert.False(dataFlow.ReadInside.Contains(symbol, ReferenceEqualityComparer.Instance)); 32804Assert.False(dataFlow.DataFlowsOut.Contains(symbol, ReferenceEqualityComparer.Instance)); 32805Assert.False(dataFlow.ReadOutside.Contains(symbol, ReferenceEqualityComparer.Instance)); 32806Assert.False(dataFlow.WrittenOutside.Contains(symbol, ReferenceEqualityComparer.Instance));
Semantics\ParamsCollectionTests.cs (16)
4342Assert.False(parameter.IsParams); 4343Assert.False(parameter.IsParamsArray); 4344Assert.False(parameter.IsParamsCollection); 4348Assert.False(parameter.IsParams); 4349Assert.False(parameter.IsParamsArray); 4350Assert.False(parameter.IsParamsCollection); 4824Assert.False(delegateType.TypeParameters[0].HasConstructorConstraint); 9036Assert.False(module.FindTargetAttribute(p1.Handle, AttributeDescription.ScopedRefAttribute).HasValue); 9039Assert.False(expectUnscopedRefAttribute); 9044Assert.False(true); 9277Assert.False(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 9281Assert.False(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams); 9426Assert.False(comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().IsParams); 10182Assert.False(comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().IsParams); 10224Assert.False(comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().IsParams); 10266Assert.False(comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().IsParams);
Semantics\PatternMatchingTestBase.cs (13)
217Assert.False(model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Any()); 218Assert.False(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText)); 334Assert.False(dataFlow.VariablesDeclared.Contains(symbol, ReferenceEqualityComparer.Instance)); 335Assert.False(dataFlow.AlwaysAssigned.Contains(symbol, ReferenceEqualityComparer.Instance)); 336Assert.False(dataFlow.WrittenInside.Contains(symbol, ReferenceEqualityComparer.Instance)); 337Assert.False(dataFlow.DataFlowsIn.Contains(symbol, ReferenceEqualityComparer.Instance)); 338Assert.False(dataFlow.ReadInside.Contains(symbol, ReferenceEqualityComparer.Instance)); 339Assert.False(dataFlow.DataFlowsOut.Contains(symbol, ReferenceEqualityComparer.Instance)); 340Assert.False(dataFlow.ReadOutside.Contains(symbol, ReferenceEqualityComparer.Instance)); 341Assert.False(dataFlow.WrittenOutside.Contains(symbol, ReferenceEqualityComparer.Instance)); 376Assert.False(model.LookupSymbols(designation.SpanStart, name: identifierText).Any()); 378Assert.False(model.LookupNames(designation.SpanStart).Contains(identifierText)); 419Assert.False(model.LookupSymbols(reference.SpanStart, name: reference.Identifier.ValueText).Any());
Semantics\PatternMatchingTests.cs (1)
6577Assert.False(model.GetConstantValue(caseDefault.Pattern).HasValue);
Semantics\PatternMatchingTests2.cs (1)
2968Assert.False(true);
Semantics\PrimaryConstructorTests.cs (27)
557Assert.False(ctor.IsDefaultValueTypeConstructor()); 617Assert.False(ctor.IsImplicitlyDeclared); 618Assert.False(ctor.IsImplicitConstructor); 619Assert.False(ctor.IsImplicitInstanceConstructor); 620Assert.False(ctor.IsDefaultValueTypeConstructor()); 625Assert.False(m.GlobalNamespace.GetTypeMember("C").InstanceConstructors.Single().IsDefaultValueTypeConstructor()); 783Assert.False(ctor.IsDefaultValueTypeConstructor()); 2166Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativeBaseInitializer, out _)); 2174Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 2178Assert.False(model.TryGetSpeculativeSemanticModel(otherBasePosition, speculativePrimaryInitializer, out _)); 2242Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativePrimaryInitializer, out _)); 2318Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativeBaseInitializer, out _)); 2326Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 2330Assert.False(model.TryGetSpeculativeSemanticModel(otherBasePosition, speculativePrimaryInitializer, out _)); 2332Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out _)); 2333Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativePrimaryInitializer, out _)); 2381Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativePrimaryInitializer, out _)); 2482Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativeBase, out _)); 2488Assert.False(model.TryGetSpeculativeSemanticModel(baseWithoutargs.ArgumentList.OpenParenToken.SpanStart, speculativeBase, out _)); 2493Assert.False(model.TryGetSpeculativeSemanticModel(baseWithoutParens.SpanStart + 2, speculativeBase, out _)); 3283Assert.False(i.HasPrimaryConstructor); 3325Assert.False(e.HasPrimaryConstructor); 3357Assert.False(c.HasPrimaryConstructor); 3585Assert.False(c1.AnyMemberHasAttributes); 3630Assert.False(c.AnyMemberHasAttributes); 3652Assert.False(c.AnyMemberHasAttributes); 7842Assert.False(isRecord);
Semantics\RecordTests.cs (163)
118Assert.False(point.IsValueType); 3496Assert.False(clone.IsOverride); 3497Assert.False(clone.IsVirtual); 3499Assert.False(clone.IsSealed); 3527Assert.False(clone.IsOverride); 3528Assert.False(clone.IsVirtual); 3530Assert.False(clone.IsSealed); 3560Assert.False(clone.IsVirtual); 3562Assert.False(clone.IsSealed); 3587Assert.False(clone.IsVirtual); 3589Assert.False(clone.IsSealed); 4982Assert.False(print.IsOverride); 4984Assert.False(print.IsAbstract); 4985Assert.False(print.IsSealed); 4991Assert.False(toString.IsVirtual); 4992Assert.False(toString.IsAbstract); 4993Assert.False(toString.IsSealed); 5057Assert.False(print.IsOverride); 5059Assert.False(print.IsAbstract); 5060Assert.False(print.IsSealed); 5066Assert.False(toString.IsVirtual); 5067Assert.False(toString.IsAbstract); 5068Assert.False(toString.IsSealed); 5135Assert.False(print.IsVirtual); 5136Assert.False(print.IsAbstract); 5137Assert.False(print.IsSealed); 5143Assert.False(toString.IsVirtual); 5144Assert.False(toString.IsAbstract); 5145Assert.False(toString.IsSealed); 5301Assert.False(print.IsOverride); 5302Assert.False(print.IsVirtual); 5303Assert.False(print.IsAbstract); 5304Assert.False(print.IsSealed); 5310Assert.False(toString.IsVirtual); 5311Assert.False(toString.IsAbstract); 5312Assert.False(toString.IsSealed); 5485Assert.False(print.IsOverride); 5486Assert.False(print.IsVirtual); 5487Assert.False(print.IsAbstract); 5488Assert.False(print.IsSealed); 5494Assert.False(toString.IsVirtual); 5495Assert.False(toString.IsAbstract); 5496Assert.False(toString.IsSealed); 5519Assert.False(print.IsOverride); 5521Assert.False(print.IsAbstract); 5522Assert.False(print.IsSealed); 5528Assert.False(toString.IsVirtual); 5529Assert.False(toString.IsAbstract); 5530Assert.False(toString.IsSealed); 5913Assert.False(print.IsVirtual); 5914Assert.False(print.IsAbstract); 5915Assert.False(print.IsSealed); 5921Assert.False(toString.IsVirtual); 5922Assert.False(toString.IsAbstract); 5923Assert.False(toString.IsSealed); 14071Assert.False(clone.IsOverride); 14072Assert.False(clone.IsVirtual); 14073Assert.False(clone.IsAbstract); 14074Assert.False(clone.IsSealed); 14108Assert.False(clone.IsOverride); 14109Assert.False(clone.IsVirtual); 14110Assert.False(clone.IsAbstract); 14111Assert.False(clone.IsSealed); 14233Assert.False(deconstruct.IsVirtual); 14234Assert.False(deconstruct.IsStatic); 15764Assert.False(deconstruct.IsAbstract); 15765Assert.False(deconstruct.IsVirtual); 15766Assert.False(deconstruct.IsOverride); 15767Assert.False(deconstruct.IsSealed); 18195Assert.False(recordEquals.IsAbstract); 18197Assert.False(recordEquals.IsOverride); 18198Assert.False(recordEquals.IsSealed); 18265Assert.False(copyCtor.IsOverride); 18266Assert.False(copyCtor.IsVirtual); 18267Assert.False(copyCtor.IsAbstract); 18268Assert.False(copyCtor.IsSealed); 18273Assert.False(copyCtor.IsOverride); 18274Assert.False(copyCtor.IsVirtual); 18275Assert.False(copyCtor.IsAbstract); 18276Assert.False(copyCtor.IsSealed); 18304Assert.False(recordEquals.IsAbstract); 18306Assert.False(recordEquals.IsOverride); 18307Assert.False(recordEquals.IsSealed); 18417Assert.False(clone.IsOverride); 18418Assert.False(clone.IsVirtual); 18420Assert.False(clone.IsSealed); 18426Assert.False(clone.IsVirtual); 18428Assert.False(clone.IsSealed); 18434Assert.False(clone.IsVirtual); 18435Assert.False(clone.IsAbstract); 18436Assert.False(clone.IsSealed); 18568Assert.False(recordEquals.IsAbstract); 18570Assert.False(recordEquals.IsOverride); 18571Assert.False(recordEquals.IsSealed); 18728Assert.False(recordEquals.IsAbstract); 18730Assert.False(recordEquals.IsOverride); 18731Assert.False(recordEquals.IsSealed); 18767Assert.False(recordEquals.IsAbstract); 18768Assert.False(recordEquals.IsVirtual); 18769Assert.False(recordEquals.IsOverride); 18770Assert.False(recordEquals.IsSealed); 18803Assert.False(recordEquals.IsAbstract); 18804Assert.False(recordEquals.IsVirtual); 18805Assert.False(recordEquals.IsOverride); 18806Assert.False(recordEquals.IsSealed); 19021Assert.False(equalityContract.IsAbstract); 19022Assert.False(equalityContract.IsVirtual); 19024Assert.False(equalityContract.IsSealed); 19031Assert.False(equalityContractGet.IsAbstract); 19032Assert.False(equalityContractGet.IsVirtual); 19034Assert.False(equalityContractGet.IsSealed); 19137Assert.False(equalityContract.IsAbstract); 19138Assert.False(equalityContract.IsVirtual); 19140Assert.False(equalityContract.IsSealed); 19147Assert.False(equalityContractGet.IsAbstract); 19148Assert.False(equalityContractGet.IsVirtual); 19150Assert.False(equalityContractGet.IsSealed); 19210Assert.False(equalityContract.IsAbstract); 19212Assert.False(equalityContract.IsOverride); 19213Assert.False(equalityContract.IsSealed); 19220Assert.False(equalityContractGet.IsAbstract); 19222Assert.False(equalityContractGet.IsOverride); 19223Assert.False(equalityContractGet.IsSealed); 20142Assert.False(equalityContract.IsAbstract); 20143Assert.False(equalityContract.IsVirtual); 20144Assert.False(equalityContract.IsOverride); 20145Assert.False(equalityContract.IsSealed); 20173Assert.False(equalityContract.IsAbstract); 20174Assert.False(equalityContract.IsVirtual); 20176Assert.False(equalityContract.IsSealed); 20441Assert.False(op.IsAbstract); 20442Assert.False(op.IsVirtual); 20443Assert.False(op.IsOverride); 20444Assert.False(op.IsSealed); 20451Assert.False(op.IsAbstract); 20452Assert.False(op.IsVirtual); 20453Assert.False(op.IsOverride); 20454Assert.False(op.IsSealed); 20560Assert.False(op.IsAbstract); 20561Assert.False(op.IsVirtual); 20562Assert.False(op.IsOverride); 20563Assert.False(op.IsSealed); 20570Assert.False(op.IsAbstract); 20571Assert.False(op.IsVirtual); 20572Assert.False(op.IsOverride); 20573Assert.False(op.IsSealed); 22382Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativeBaseInitializer, out _)); 22390Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 22394Assert.False(model.TryGetSpeculativeSemanticModel(otherBasePosition, speculativePrimaryInitializer, out _)); 22458Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativePrimaryInitializer, out _)); 22534Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativeBaseInitializer, out _)); 22542Assert.False(model.TryGetSpeculativeSemanticModel(tree.GetRoot().DescendantNodes().OfType<ReturnStatementSyntax>().Single().SpanStart, 22546Assert.False(model.TryGetSpeculativeSemanticModel(otherBasePosition, speculativePrimaryInitializer, out _)); 22548Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out _)); 22549Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativePrimaryInitializer, out _)); 22597Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativePrimaryInitializer, out _)); 22760Assert.False(clone.IsOverride); 22762Assert.False(clone.IsAbstract); 22763Assert.False(clone.IsSealed); 24907Assert.False(p.HasPointerType); 26194Assert.False(symbol.IsRecord); 30270Assert.False(compA.Assembly.RuntimeSupportsCovariantReturnsOfClasses); 30271Assert.False(compA.SupportsRuntimeCapability(RuntimeCapability.CovariantReturnsOfClasses));
Symbols\UserDefinedCompoundAssignmentOperatorsTests.cs (385)
75Assert.False(m.IsStatic); 76Assert.False(m.IsAbstract); 78Assert.False(m.IsSealed); 79Assert.False(m.IsOverride); 81Assert.False(m.HasRuntimeSpecialName); 403Assert.False(m.IsStatic); 405Assert.False(m.IsVirtual); 406Assert.False(m.IsSealed); 407Assert.False(m.IsOverride); 409Assert.False(m.HasRuntimeSpecialName); 461Assert.False(m.IsStatic); 463Assert.False(m.IsVirtual); 464Assert.False(m.IsSealed); 465Assert.False(m.IsOverride); 467Assert.False(m.HasRuntimeSpecialName); 517Assert.False(m.IsStatic); 518Assert.False(m.IsAbstract); 519Assert.False(m.IsVirtual); 520Assert.False(m.IsSealed); 521Assert.False(m.IsOverride); 522Assert.False(m.HasSpecialName); 523Assert.False(m.HasRuntimeSpecialName); 584Assert.False(m.IsStatic); 585Assert.False(m.IsAbstract); 586Assert.False(m.IsVirtual); 587Assert.False(m.IsSealed); 588Assert.False(m.IsOverride); 589Assert.False(m.HasSpecialName); 590Assert.False(m.HasRuntimeSpecialName); 637Assert.False(m.IsStatic); 638Assert.False(m.IsAbstract); 639Assert.False(m.IsVirtual); 640Assert.False(m.IsSealed); 648Assert.False(m.IsOverride); 650Assert.False(m.HasRuntimeSpecialName); 696Assert.False(m.IsStatic); 698Assert.False(m.IsVirtual); 700Assert.False(m.IsOverride); 701Assert.False(m.HasSpecialName); 702Assert.False(m.HasRuntimeSpecialName); 926Assert.False(m.IsStatic); 927Assert.False(m.IsAbstract); 929Assert.False(m.IsSealed); 930Assert.False(m.IsOverride); 932Assert.False(m.HasRuntimeSpecialName); 960Assert.False(m.IsStatic); 961Assert.False(m.IsAbstract); 963Assert.False(m.IsSealed); 964Assert.False(m.IsOverride); 966Assert.False(m.HasRuntimeSpecialName); 1016Assert.False(m.IsStatic); 1017Assert.False(m.IsAbstract); 1018Assert.False(m.IsVirtual); 1019Assert.False(m.IsSealed); 1020Assert.False(m.IsOverride); 1021Assert.False(m.HasSpecialName); 1022Assert.False(m.HasRuntimeSpecialName); 1070Assert.False(m.IsStatic); 1071Assert.False(m.IsAbstract); 1072Assert.False(m.IsVirtual); 1073Assert.False(m.IsSealed); 1074Assert.False(m.IsOverride); 1075Assert.False(m.HasSpecialName); 1076Assert.False(m.HasRuntimeSpecialName); 1123Assert.False(m.IsStatic); 1124Assert.False(m.IsAbstract); 1125Assert.False(m.IsVirtual); 1126Assert.False(m.IsSealed); 1134Assert.False(m.IsOverride); 1136Assert.False(m.HasRuntimeSpecialName); 1425Assert.False(m.IsStatic); 1426Assert.False(m.IsAbstract); 1427Assert.False(m.IsVirtual); 1428Assert.False(m.IsSealed); 1431Assert.False(m.HasRuntimeSpecialName); 1483Assert.False(m.IsStatic); 1485Assert.False(m.IsVirtual); 1486Assert.False(m.IsSealed); 1489Assert.False(m.HasRuntimeSpecialName); 1533Assert.False(m.IsStatic); 1534Assert.False(m.IsAbstract); 1535Assert.False(m.IsVirtual); 1536Assert.False(m.IsSealed); 1539Assert.False(m.HasRuntimeSpecialName); 1741Assert.False(m.IsStatic); 1742Assert.False(m.IsAbstract); 1743Assert.False(m.IsVirtual); 1744Assert.False(m.IsSealed); 1745Assert.False(m.IsOverride); 1747Assert.False(m.HasRuntimeSpecialName); 1802Assert.False(m.IsStatic); 1803Assert.False(m.IsAbstract); 1804Assert.False(m.IsVirtual); 1808Assert.False(m.HasRuntimeSpecialName); 2335Assert.False(m.IsStatic); 2336Assert.False(m.IsAbstract); 2338Assert.False(m.IsSealed); 2339Assert.False(m.IsOverride); 2341Assert.False(m.HasRuntimeSpecialName); 2389Assert.False(m.IsStatic); 2390Assert.False(m.IsAbstract); 2391Assert.False(m.IsVirtual); 2392Assert.False(m.IsSealed); 2393Assert.False(m.IsOverride); 2395Assert.False(m.HasRuntimeSpecialName); 2443Assert.False(m.IsStatic); 2444Assert.False(m.IsAbstract); 2445Assert.False(m.IsVirtual); 2446Assert.False(m.IsSealed); 2447Assert.False(m.IsOverride); 2449Assert.False(m.HasRuntimeSpecialName); 2529Assert.False(m.IsStatic); 2530Assert.False(m.IsAbstract); 2532Assert.False(m.IsSealed); 2533Assert.False(m.IsOverride); 2535Assert.False(m.HasRuntimeSpecialName); 2569Assert.False(m.IsStatic); 2571Assert.False(m.IsVirtual); 2572Assert.False(m.IsSealed); 2573Assert.False(m.IsOverride); 2575Assert.False(m.HasRuntimeSpecialName); 2610Assert.False(m.IsStatic); 2611Assert.False(m.IsAbstract); 2613Assert.False(m.IsSealed); 2614Assert.False(m.IsOverride); 2616Assert.False(m.HasRuntimeSpecialName); 2651Assert.False(m.IsStatic); 2652Assert.False(m.IsAbstract); 2653Assert.False(m.IsVirtual); 2654Assert.False(m.IsSealed); 2655Assert.False(m.IsOverride); 2657Assert.False(m.HasRuntimeSpecialName); 5377Assert.False(decrement.IsVararg); 6897Assert.False(m.IsDeclaredReadOnly); 6898Assert.False(m.IsEffectivelyReadOnly); 6945Assert.False(m.IsDeclaredReadOnly); 7008Assert.False(m.IsDeclaredReadOnly); 7042Assert.False(m.IsDeclaredReadOnly); 7043Assert.False(m.IsEffectivelyReadOnly); 7108Assert.False(m.IsDeclaredReadOnly); 7177Assert.False(m.IsDeclaredReadOnly); 7251Assert.False(m.IsDeclaredReadOnly); 7252Assert.False(m.IsEffectivelyReadOnly); 7257Assert.False(m.IsDeclaredReadOnly); 7258Assert.False(m.IsEffectivelyReadOnly); 7263Assert.False(m.IsDeclaredReadOnly); 7264Assert.False(m.IsEffectivelyReadOnly); 7269Assert.False(m.IsDeclaredReadOnly); 7270Assert.False(m.IsEffectivelyReadOnly); 7437Assert.False(m.HasUnsupportedMetadata); 8035Assert.False(m.IsStatic); 8036Assert.False(m.IsAbstract); 8038Assert.False(m.IsSealed); 8039Assert.False(m.IsOverride); 8041Assert.False(m.HasRuntimeSpecialName); 8080Assert.False(CompoundAssignmentOperatorHasCheckedForm(op)); 8113Assert.False(m.IsStatic); 8114Assert.False(m.IsAbstract); 8116Assert.False(m.IsSealed); 8117Assert.False(m.IsOverride); 8119Assert.False(m.HasRuntimeSpecialName); 8178Assert.False(m.IsStatic); 8179Assert.False(m.IsAbstract); 8181Assert.False(m.IsSealed); 8182Assert.False(m.IsOverride); 8184Assert.False(m.HasRuntimeSpecialName); 8289Assert.False(m.IsStatic); 8291Assert.False(m.IsVirtual); 8292Assert.False(m.IsSealed); 8293Assert.False(m.IsOverride); 8295Assert.False(m.HasRuntimeSpecialName); 8453Assert.False(m.IsStatic); 8455Assert.False(m.IsVirtual); 8456Assert.False(m.IsSealed); 8457Assert.False(m.IsOverride); 8459Assert.False(m.HasRuntimeSpecialName); 8539Assert.False(m.IsStatic); 8541Assert.False(m.IsVirtual); 8542Assert.False(m.IsSealed); 8543Assert.False(m.IsOverride); 8545Assert.False(m.HasRuntimeSpecialName); 8612Assert.False(m.IsStatic); 8613Assert.False(m.IsAbstract); 8614Assert.False(m.IsVirtual); 8615Assert.False(m.IsSealed); 8616Assert.False(m.IsOverride); 8617Assert.False(m.HasSpecialName); 8618Assert.False(m.HasRuntimeSpecialName); 8698Assert.False(m.IsStatic); 8699Assert.False(m.IsAbstract); 8700Assert.False(m.IsVirtual); 8701Assert.False(m.IsSealed); 8702Assert.False(m.IsOverride); 8703Assert.False(m.HasSpecialName); 8704Assert.False(m.HasRuntimeSpecialName); 8761Assert.False(m.IsStatic); 8762Assert.False(m.IsAbstract); 8763Assert.False(m.IsVirtual); 8764Assert.False(m.IsSealed); 8772Assert.False(m.IsOverride); 8774Assert.False(m.HasRuntimeSpecialName); 8830Assert.False(m.IsStatic); 8832Assert.False(m.IsVirtual); 8834Assert.False(m.IsOverride); 8835Assert.False(m.HasSpecialName); 8836Assert.False(m.HasRuntimeSpecialName); 9106Assert.False(m.IsStatic); 9107Assert.False(m.IsAbstract); 9109Assert.False(m.IsSealed); 9110Assert.False(m.IsOverride); 9112Assert.False(m.HasRuntimeSpecialName); 9152Assert.False(m.IsStatic); 9153Assert.False(m.IsAbstract); 9155Assert.False(m.IsSealed); 9156Assert.False(m.IsOverride); 9158Assert.False(m.HasRuntimeSpecialName); 9225Assert.False(m.IsStatic); 9226Assert.False(m.IsAbstract); 9227Assert.False(m.IsVirtual); 9228Assert.False(m.IsSealed); 9229Assert.False(m.IsOverride); 9230Assert.False(m.HasSpecialName); 9231Assert.False(m.HasRuntimeSpecialName); 9289Assert.False(m.IsStatic); 9290Assert.False(m.IsAbstract); 9291Assert.False(m.IsVirtual); 9292Assert.False(m.IsSealed); 9293Assert.False(m.IsOverride); 9294Assert.False(m.HasSpecialName); 9295Assert.False(m.HasRuntimeSpecialName); 9352Assert.False(m.IsStatic); 9353Assert.False(m.IsAbstract); 9354Assert.False(m.IsVirtual); 9355Assert.False(m.IsSealed); 9363Assert.False(m.IsOverride); 9365Assert.False(m.HasRuntimeSpecialName); 9638Assert.False(m.IsStatic); 9639Assert.False(m.IsAbstract); 9640Assert.False(m.IsVirtual); 9641Assert.False(m.IsSealed); 9644Assert.False(m.HasRuntimeSpecialName); 9687Assert.False(m.IsStatic); 9688Assert.False(m.IsAbstract); 9689Assert.False(m.IsVirtual); 9690Assert.False(m.IsSealed); 9693Assert.False(m.HasRuntimeSpecialName); 9745Assert.False(m.IsStatic); 9747Assert.False(m.IsVirtual); 9748Assert.False(m.IsSealed); 9751Assert.False(m.HasRuntimeSpecialName); 9804Assert.False(m.IsStatic); 9806Assert.False(m.IsVirtual); 9807Assert.False(m.IsSealed); 9810Assert.False(m.HasRuntimeSpecialName); 9851Assert.False(m.IsStatic); 9852Assert.False(m.IsAbstract); 9853Assert.False(m.IsVirtual); 9854Assert.False(m.IsSealed); 9857Assert.False(m.HasRuntimeSpecialName); 9887Assert.False(m.IsStatic); 9888Assert.False(m.IsAbstract); 9889Assert.False(m.IsVirtual); 9890Assert.False(m.IsSealed); 9893Assert.False(m.HasRuntimeSpecialName); 10080Assert.False(m.IsStatic); 10081Assert.False(m.IsAbstract); 10082Assert.False(m.IsVirtual); 10083Assert.False(m.IsSealed); 10084Assert.False(m.IsOverride); 10086Assert.False(m.HasRuntimeSpecialName); 10129Assert.False(m.IsStatic); 10130Assert.False(m.IsAbstract); 10131Assert.False(m.IsVirtual); 10132Assert.False(m.IsSealed); 10133Assert.False(m.IsOverride); 10135Assert.False(m.HasRuntimeSpecialName); 10186Assert.False(m.IsStatic); 10187Assert.False(m.IsAbstract); 10188Assert.False(m.IsVirtual); 10192Assert.False(m.HasRuntimeSpecialName); 10243Assert.False(m.IsStatic); 10244Assert.False(m.IsAbstract); 10245Assert.False(m.IsVirtual); 10249Assert.False(m.HasRuntimeSpecialName); 10822Assert.False(m.IsStatic); 10823Assert.False(m.IsAbstract); 10825Assert.False(m.IsSealed); 10826Assert.False(m.IsOverride); 10828Assert.False(m.HasRuntimeSpecialName); 10869Assert.False(m.IsStatic); 10870Assert.False(m.IsAbstract); 10872Assert.False(m.IsSealed); 10873Assert.False(m.IsOverride); 10875Assert.False(m.HasRuntimeSpecialName); 10923Assert.False(m.IsStatic); 10924Assert.False(m.IsAbstract); 10925Assert.False(m.IsVirtual); 10926Assert.False(m.IsSealed); 10927Assert.False(m.IsOverride); 10929Assert.False(m.HasRuntimeSpecialName); 10970Assert.False(m.IsStatic); 10971Assert.False(m.IsAbstract); 10972Assert.False(m.IsVirtual); 10973Assert.False(m.IsSealed); 10974Assert.False(m.IsOverride); 10976Assert.False(m.HasRuntimeSpecialName); 11024Assert.False(m.IsStatic); 11025Assert.False(m.IsAbstract); 11026Assert.False(m.IsVirtual); 11027Assert.False(m.IsSealed); 11028Assert.False(m.IsOverride); 11030Assert.False(m.HasRuntimeSpecialName); 11071Assert.False(m.IsStatic); 11072Assert.False(m.IsAbstract); 11073Assert.False(m.IsVirtual); 11074Assert.False(m.IsSealed); 11075Assert.False(m.IsOverride); 11077Assert.False(m.HasRuntimeSpecialName); 11193Assert.False(m.IsStatic); 11194Assert.False(m.IsAbstract); 11196Assert.False(m.IsSealed); 11197Assert.False(m.IsOverride); 11199Assert.False(m.HasRuntimeSpecialName); 11228Assert.False(m.IsStatic); 11229Assert.False(m.IsAbstract); 11231Assert.False(m.IsSealed); 11232Assert.False(m.IsOverride); 11234Assert.False(m.HasRuntimeSpecialName); 11268Assert.False(m.IsStatic); 11270Assert.False(m.IsVirtual); 11271Assert.False(m.IsSealed); 11272Assert.False(m.IsOverride); 11274Assert.False(m.HasRuntimeSpecialName); 11304Assert.False(m.IsStatic); 11306Assert.False(m.IsVirtual); 11307Assert.False(m.IsSealed); 11308Assert.False(m.IsOverride); 11310Assert.False(m.HasRuntimeSpecialName); 11345Assert.False(m.IsStatic); 11346Assert.False(m.IsAbstract); 11348Assert.False(m.IsSealed); 11349Assert.False(m.IsOverride); 11351Assert.False(m.HasRuntimeSpecialName); 11381Assert.False(m.IsStatic); 11382Assert.False(m.IsAbstract); 11384Assert.False(m.IsSealed); 11385Assert.False(m.IsOverride); 11387Assert.False(m.HasRuntimeSpecialName); 11422Assert.False(m.IsStatic); 11423Assert.False(m.IsAbstract); 11424Assert.False(m.IsVirtual); 11425Assert.False(m.IsSealed); 11426Assert.False(m.IsOverride); 11428Assert.False(m.HasRuntimeSpecialName); 11458Assert.False(m.IsStatic); 11459Assert.False(m.IsAbstract); 11460Assert.False(m.IsVirtual); 11461Assert.False(m.IsSealed); 11462Assert.False(m.IsOverride); 11464Assert.False(m.HasRuntimeSpecialName); 16869Assert.False(method.IsVararg); 18508Assert.False(m.IsDeclaredReadOnly); 18539Assert.False(m.IsDeclaredReadOnly); 18630Assert.False(m.IsDeclaredReadOnly); 18657Assert.False(m.IsDeclaredReadOnly); 18759Assert.False(m.IsDeclaredReadOnly); 18784Assert.False(m.IsDeclaredReadOnly); 18893Assert.False(m.IsDeclaredReadOnly); 18925Assert.False(m.IsDeclaredReadOnly); 18999Assert.False(m.IsDeclaredReadOnly); 19000Assert.False(m.IsEffectivelyReadOnly); 19005Assert.False(m.IsDeclaredReadOnly); 19006Assert.False(m.IsEffectivelyReadOnly); 19011Assert.False(m.IsDeclaredReadOnly); 19012Assert.False(m.IsEffectivelyReadOnly); 19017Assert.False(m.IsDeclaredReadOnly); 19018Assert.False(m.IsEffectivelyReadOnly); 19074Assert.False(m.IsDeclaredReadOnly); 19075Assert.False(m.IsEffectivelyReadOnly); 19080Assert.False(m.IsDeclaredReadOnly); 19081Assert.False(m.IsEffectivelyReadOnly); 19086Assert.False(m.IsDeclaredReadOnly); 19087Assert.False(m.IsEffectivelyReadOnly); 19092Assert.False(m.IsDeclaredReadOnly); 19093Assert.False(m.IsEffectivelyReadOnly);
Microsoft.CodeAnalysis.CSharp.Features.UnitTests (25)
Diagnostics\Configuration\ConfigureSeverity\VarForBuiltInTypesSeverityConfigurationTests.cs (1)
36Assert.False(CSharpCodeStyleOptions.VarForBuiltInTypes.DefaultValue.Value);
Diagnostics\Suppression\SuppressionTests.cs (3)
1184Assert.All(Regex.Split(expected, "\r?\n"), line => Assert.False(HasTrailingWhitespace(line))); 1221Assert.False(string.IsNullOrWhiteSpace(lines.First())); 1255Assert.False(string.IsNullOrWhiteSpace(lines[^2]));
EditAndContinue\BreakpointSpansTests.cs (1)
51Assert.False(hasBreakpoint);
EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (18)
371Assert.False(result.HasBlockingRudeEdits); 394Assert.False(result.HasChanges); 395Assert.False(result.AnalysisBlocked); 397Assert.False(result.HasBlockingRudeEdits); 432Assert.False(result.HasChanges); 433Assert.False(result.AnalysisBlocked); 435Assert.False(result.HasBlockingRudeEdits); 465Assert.False(result.HasChanges); 466Assert.False(result.AnalysisBlocked); 467Assert.False(result.HasBlockingRudeEdits); 516Assert.False(result.HasBlockingRudeEdits); 544Assert.False(result.HasChanges); 545Assert.False(result.HasBlockingRudeEdits); 546Assert.False(result.AnalysisBlocked); 587Assert.False(result.HasBlockingRudeEdits); 588Assert.False(result.AnalysisBlocked); 628Assert.False(result.AnalysisBlocked); 629Assert.False(result.HasBlockingRudeEdits);
EditAndContinue\SyntaxUtilitiesTests.cs (1)
199Assert.False(SyntaxUtilities.IsAsyncDeclaration(m3));
ExtractClass\ExtractClassTests.cs (1)
2973Assert.False(_isClassDeclarationSelection);
Microsoft.CodeAnalysis.CSharp.IOperation.UnitTests (4)
IOperation\IOperationTests.cs (3)
468Assert.False(operation1 is ISimpleAssignmentOperation); 474Assert.False(operation2 is ISimpleAssignmentOperation); 480Assert.False(operation3 is ISimpleAssignmentOperation);
IOperation\IOperationTests_IArgument.cs (1)
4100Assert.False(conversion.Conversion.IsImplicit);
Microsoft.CodeAnalysis.CSharp.Scripting.Desktop.UnitTests (3)
CsiTests.cs (3)
39Assert.False(result.ContainsErrors); 114Assert.False(result.ContainsErrors); 139Assert.False(result.ContainsErrors);
Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests (7)
CommandLineRunnerTests.cs (1)
486Assert.False(PathUtilities.IsAbsolute(scriptPath));
InteractiveSessionReferencesTests.cs (1)
152Assert.False(m.ReferencedAssemblies.Any(a => a.Name == "libB"));
InteractiveSessionTests.cs (2)
676Assert.False(state3.ReturnValue); 1668Assert.False(true);
ObjectFormatterTests.cs (1)
1039Assert.False(true);
ScriptTests.cs (2)
440Assert.False(state.GetVariable("x").IsReadOnly); 631Assert.False(result.HasValue);
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (964)
Semantics\AccessCheckTests.cs (45)
777Assert.False(Symbol.IsSymbolAccessible(privField.GetSymbol(), classB.GetSymbol())); 778Assert.False(compilation.IsSymbolAccessibleWithin(privField, classB)); 779Assert.False(Symbol.IsSymbolAccessible(karrayType.GetSymbol(), classB.GetSymbol())); 780Assert.False(compilation.IsSymbolAccessibleWithin(karrayType, classB)); 783Assert.False(Symbol.IsSymbolAccessible(kptrType.GetSymbol(), classB.GetSymbol())); 784Assert.False(compilation.IsSymbolAccessibleWithin(kptrType, classB)); 787Assert.False(Symbol.IsSymbolAccessible(kinreturnfuncptrType.GetSymbol(), classB.GetSymbol())); 788Assert.False(compilation.IsSymbolAccessibleWithin(kinreturnfuncptrType, classB)); 789Assert.False(Symbol.IsSymbolAccessible(kinparamfuncptr1Type.GetSymbol(), classB.GetSymbol())); 790Assert.False(compilation.IsSymbolAccessibleWithin(kinparamfuncptr1Type, classB)); 791Assert.False(Symbol.IsSymbolAccessible(kinparamfuncptr2Type.GetSymbol(), classB.GetSymbol())); 792Assert.False(compilation.IsSymbolAccessibleWithin(kinparamfuncptr2Type, classB)); 795Assert.False(Symbol.IsSymbolAccessible(kdiscard.GetSymbol(), classB.GetSymbol())); 796Assert.False(compilation.IsSymbolAccessibleWithin(kdiscard, classB)); 799Assert.False(Symbol.IsSymbolAccessible(kenumType.GetSymbol(), classB.GetSymbol())); 800Assert.False(compilation.IsSymbolAccessibleWithin(kenumType, classB)); 811Assert.False(Symbol.IsSymbolAccessible(protField.GetSymbol(), classB.GetSymbol())); 812Assert.False(compilation.IsSymbolAccessibleWithin(protField, classB)); 813Assert.False(Symbol.IsSymbolAccessible(protField.GetSymbol(), classB.GetSymbol(), classADerived.GetSymbol())); 814Assert.False(compilation.IsSymbolAccessibleWithin(protField, classB, classADerived)); 819Assert.False(Symbol.IsSymbolAccessible(protField.GetSymbol(), classADerived.GetSymbol(), classADerived2.GetSymbol())); 820Assert.False(compilation.IsSymbolAccessibleWithin(protField, classADerived, classADerived2)); 828Assert.False(Symbol.IsSymbolAccessible(karrayType.GetSymbol(), sourceAssem.GetSymbol())); 829Assert.False(compilation.IsSymbolAccessibleWithin(karrayType, sourceAssem)); 834Assert.False(Symbol.IsSymbolAccessible(kptrType.GetSymbol(), sourceAssem.GetSymbol())); 835Assert.False(compilation.IsSymbolAccessibleWithin(kptrType, sourceAssem)); 836Assert.False(Symbol.IsSymbolAccessible(kinreturnfuncptrType.GetSymbol(), sourceAssem.GetSymbol())); 837Assert.False(compilation.IsSymbolAccessibleWithin(kinreturnfuncptrType, sourceAssem)); 838Assert.False(Symbol.IsSymbolAccessible(kinparamfuncptr1Type.GetSymbol(), sourceAssem.GetSymbol())); 839Assert.False(compilation.IsSymbolAccessibleWithin(kinparamfuncptr1Type, sourceAssem)); 840Assert.False(Symbol.IsSymbolAccessible(kinparamfuncptr2Type.GetSymbol(), sourceAssem.GetSymbol())); 841Assert.False(compilation.IsSymbolAccessibleWithin(kinparamfuncptr2Type, sourceAssem)); 844Assert.False(Symbol.IsSymbolAccessible(kdiscard.GetSymbol(), sourceAssem.GetSymbol())); 845Assert.False(compilation.IsSymbolAccessibleWithin(kdiscard, sourceAssem)); 846Assert.False(Symbol.IsSymbolAccessible(classA.GetSymbol(), mscorlibAssem.GetSymbol())); 847Assert.False(compilation.IsSymbolAccessibleWithin(classA, mscorlibAssem)); 848Assert.False(Symbol.IsSymbolAccessible(aliasA.GetSymbol(), mscorlibAssem.GetSymbol())); 849Assert.False(compilation.IsSymbolAccessibleWithin(aliasA, mscorlibAssem)); 916Assert.False(compilation1.IsSymbolAccessibleWithin(Outer_Pointer.Type, Other)); 919Assert.False(compilation1.IsSymbolAccessibleWithin(Private, Other)); 920Assert.False(compilation1.IsSymbolAccessibleWithin(Private, sourceAssem)); 921Assert.False(compilation1.IsSymbolAccessibleWithin(Outer_Inner_Field, Other)); 922Assert.False(compilation1.IsSymbolAccessibleWithin(Outer_Protected, Derived, Outer)); 924Assert.False(compilation1.IsSymbolAccessibleWithin(Outer_PrivateProtected, Derived, Outer)); 928Assert.False(compilation1.IsSymbolAccessibleWithin(Outer_Protected, sourceAssem));
Semantics\AnonymousFunctionTests.cs (5)
53Assert.False(method.IsStatic); 1025Assert.False(anonymousMethod.IsStatic); 1026Assert.False(simpleLambda.IsStatic); 1027Assert.False(parenthesizedLambda.IsStatic); 1225Assert.False(method.IsStatic);
Semantics\AwaitExpressionTests.cs (1)
321Assert.False(info.IsDynamic);
Semantics\BindingTests.cs (8)
3384Assert.False(names.Contains("MathMin")); 3387Assert.False(names.Contains("F2")); 3388Assert.False(names.Contains("MathMax2")); 3389Assert.False(names.Contains("MathMax3")); 3399Assert.False(symbols.Where(s => s.Name == "MathMin").Any()); 3402Assert.False(symbols.Where(s => s.Name == "F2").Any()); 3403Assert.False(symbols.Where(s => s.Name == "MathMax2").Any()); 3404Assert.False(symbols.Where(s => s.Name == "MathMax3").Any());
Semantics\ConstantTests.cs (2)
2952Assert.False(((FieldSymbol)symbol).HasConstantValue); 2955Assert.False(((FieldSymbol)symbol).HasConstantValue);
Semantics\DeconstructionTests.cs (1)
5130Assert.False(tree.GetCompilationUnitRoot().DescendantNodes().OfType<DeclarationExpressionSyntax>().Any());
Semantics\DelegateTypeTests.cs (14)
13513Assert.False(dm.Parameters.Single().HasExplicitDefaultValue); 13552Assert.False(cm.Parameters.Single().HasExplicitDefaultValue); 13660Assert.False(cm.Parameters.Single().IsParams); 13662Assert.False(dm.Parameters.Single().IsParams); 13684Assert.False(dm.Parameters.Single().IsParams); 13801Assert.False(dm.Parameters.Single().IsParams); 13948Assert.False(dm.Parameters.Single().IsParams); 13987Assert.False(cm.Parameters.Single().IsParams); 13989Assert.False(dm.Parameters.Single().IsParams); 14059Assert.False(cm.Parameters.Single().IsParams); 15690Assert.False(functionTypeStringNotNullable.Equals(functionTypeStringNullable, TypeCompareKind.ConsiderEverything)); 15691Assert.False(functionTypeNullA.Equals(functionTypeStringNullable, TypeCompareKind.AllIgnoreOptions)); 15692Assert.False(functionTypeStringNullable.Equals(functionTypeNullA, TypeCompareKind.AllIgnoreOptions)); 15694Assert.False(functionTypeNullA.Equals(functionTypeNullB, TypeCompareKind.ConsiderEverything));
Semantics\DynamicTests.cs (5)
7511Assert.False(typeInfo.Type.IsErrorType()); 7526Assert.False(typeInfo.Type.IsErrorType()); 7535Assert.False(operation.Type.IsErrorType()); 7902Assert.False(typeInfo.Type.IsErrorType()); 7918Assert.False(typeInfo.Type.IsErrorType());
Semantics\ExpressionBodiedMemberTests.cs (9)
50Assert.False(gooDef.IsPartialImplementation); 58Assert.False(gooImpl.IsPartialDefinition); 91Assert.False(semanticInfo.IsCompileTimeConstant); 143Assert.False(semanticInfo.IsCompileTimeConstant); 161Assert.False(semanticInfo.IsCompileTimeConstant); 176Assert.False(semanticInfo.IsCompileTimeConstant); 243Assert.False(semanticInfo.IsCompileTimeConstant); 299Assert.False(semanticInfo.IsCompileTimeConstant); 332Assert.False(semanticInfo.IsCompileTimeConstant);
Semantics\ForEachTests.cs (4)
1340Assert.False(info.NeedsDisposal); // Definitely not disposable 1880Assert.False(info.NeedsDisposal); // Definitely not disposable 2132Assert.False(loopInfo.IsAsynchronous); 3242Assert.False(info.NeedsDisposal);
Semantics\FunctionPointerTests.cs (5)
357Assert.False(conversion.IsImplicit); 365Assert.False(underlying.IsImplicit); 460Assert.False(conversion.IsImplicit); 510Assert.False(conversion.IsImplicit); 3945Assert.False(type.Signature.IsVararg);
Semantics\GenericConstraintsTests.cs (68)
452Assert.False(typeParameter.IsValueType); 453Assert.False(typeParameter.IsReferenceType); 454Assert.False(typeParameter.HasValueTypeConstraint); 455Assert.False(typeParameter.HasReferenceTypeConstraint); 471Assert.False(typeParameter.IsReferenceType); 473Assert.False(typeParameter.HasReferenceTypeConstraint); 474Assert.False(typeParameter.HasConstructorConstraint); 489Assert.False(typeParameter.IsValueType); 491Assert.False(typeParameter.HasValueTypeConstraint); 493Assert.False(typeParameter.HasConstructorConstraint); 508Assert.False(typeParameter.IsValueType); 509Assert.False(typeParameter.IsReferenceType); 510Assert.False(typeParameter.HasValueTypeConstraint); 511Assert.False(typeParameter.HasReferenceTypeConstraint); 978Assert.False(typeParameter.HasValueTypeConstraint); 979Assert.False(typeParameter.HasReferenceTypeConstraint); 999Assert.False(typeParameter.HasReferenceTypeConstraint); 1000Assert.False(typeParameter.HasConstructorConstraint); 1012Assert.False(typeParameter.HasValueTypeConstraint); 1014Assert.False(typeParameter.HasConstructorConstraint); 1029Assert.False(typeParameter.HasValueTypeConstraint); 1030Assert.False(typeParameter.HasReferenceTypeConstraint); 1463Assert.False(typeParameter.HasValueTypeConstraint); 1464Assert.False(typeParameter.HasReferenceTypeConstraint); 1484Assert.False(typeParameter.HasReferenceTypeConstraint); 1485Assert.False(typeParameter.HasConstructorConstraint); 1497Assert.False(typeParameter.HasValueTypeConstraint); 1499Assert.False(typeParameter.HasConstructorConstraint); 1514Assert.False(typeParameter.HasValueTypeConstraint); 1515Assert.False(typeParameter.HasReferenceTypeConstraint); 1836Assert.False(typeParameter.HasUnmanagedTypeConstraint); 1837Assert.False(typeParameter.HasValueTypeConstraint); 1839Assert.False(typeParameter.HasConstructorConstraint); 1854Assert.False(typeParameter.HasUnmanagedTypeConstraint); 1856Assert.False(typeParameter.HasReferenceTypeConstraint); 1857Assert.False(typeParameter.HasConstructorConstraint); 2121Assert.False(typeParameter.IsReferenceType); 2124Assert.False(typeParameter.HasReferenceTypeConstraint); 2125Assert.False(typeParameter.HasConstructorConstraint); 2146Assert.False(typeParameter.IsReferenceType); 2149Assert.False(typeParameter.HasReferenceTypeConstraint); 2150Assert.False(typeParameter.HasConstructorConstraint); 2167Assert.False(typeParameter.IsReferenceType); 2170Assert.False(typeParameter.HasReferenceTypeConstraint); 2171Assert.False(typeParameter.HasConstructorConstraint); 2197Assert.False(typeParameter.IsReferenceType); 2200Assert.False(typeParameter.HasReferenceTypeConstraint); 2201Assert.False(typeParameter.HasConstructorConstraint); 2943Assert.False(typeParameter.HasReferenceTypeConstraint); 2944Assert.False(typeParameter.HasConstructorConstraint); 2949Assert.False(typeParameter.IsReferenceType); 3560Assert.False(compilation.GetMember<NamedTypeSymbol>("MyStruct").IsManagedTypeNoUseSiteDiagnostics); 3561Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3580Assert.False(compilation.GetMember<NamedTypeSymbol>("MyStruct").IsManagedTypeNoUseSiteDiagnostics); 3581Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3605Assert.False(compilation.GetMember<NamedTypeSymbol>("MyStruct").IsManagedTypeNoUseSiteDiagnostics); 3606Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3635Assert.False(compilation.GetMember<NamedTypeSymbol>("MyStruct").IsManagedTypeNoUseSiteDiagnostics); 3636Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3661Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3689Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3717Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3745Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3773Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3809Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3844Assert.False(compilation.GetMember<NamedTypeSymbol>("YourStruct").IsManagedTypeNoUseSiteDiagnostics); 3982Assert.False(compilation.GetMember<NamedTypeSymbol>("X").IsManagedTypeNoUseSiteDiagnostics); 3983Assert.False(compilation.GetMember<NamedTypeSymbol>("Z").IsManagedTypeNoUseSiteDiagnostics);
Semantics\ImplicitObjectCreationTests.cs (8)
1872Assert.False(model.GetConstantValue(def).HasValue); 1902Assert.False(model.GetConstantValue(def).HasValue); 1932Assert.False(model.GetConstantValue(def).HasValue); 2043Assert.False(model.GetConstantValue(@new).HasValue); 2078Assert.False(model.GetConstantValue(@new).HasValue); 2224Assert.False(model.GetConstantValue(def).HasValue); 2572Assert.False(model.GetConstantValue(def).HasValue); 4188Assert.False(modifiedNode.HasErrors);
Semantics\InheritanceBindingTests.cs (4)
8499Assert.False(tuple.TupleElements[0].Type.IsNullableType()); 8583Assert.False(tuple.TupleElements[0].Type.IsNullableType()); 8652Assert.False(tuple.TupleElements[0].Type.IsNullableType()); 8721Assert.False(tuple.TupleElements[0].Type.IsNullableType());
Semantics\InitOnlyMemberTests.cs (73)
48Assert.False(property.GetMethod.IsInitOnly); 51Assert.False(publicProperty.GetMethod.IsInitOnly); 415Assert.False(property.SetMethod.IsInitOnly); 416Assert.False(property.GetPublicSymbol().SetMethod.IsInitOnly); 612Assert.False(property.GetMethod.IsInitOnly); 613Assert.False(property.GetPublicSymbol().GetMethod.IsInitOnly); 643Assert.False(property.GetMethod.IsInitOnly); 644Assert.False(property.GetPublicSymbol().GetMethod.IsInitOnly); 902Assert.False(property.GetMethod.IsInitOnly); 903Assert.False(property.GetPublicSymbol().GetMethod.IsInitOnly); 1157Assert.False(property.GetMethod.IsInitOnly); 1158Assert.False(property.GetPublicSymbol().GetMethod.IsInitOnly); 1159Assert.False(property.SetMethod.IsInitOnly); 1160Assert.False(property.GetPublicSymbol().SetMethod.IsInitOnly); 1463Assert.False(getter.IsInitOnly); 1464Assert.False(getter.GetPublicSymbol().IsInitOnly); 1481Assert.False(modifier.IsOptional); 2452Assert.False(eventSymbol.AddMethod.IsInitOnly); 2453Assert.False(eventSymbol.GetPublicSymbol().AddMethod.IsInitOnly); 2454Assert.False(eventSymbol.RemoveMethod.IsInitOnly); 2455Assert.False(eventSymbol.GetPublicSymbol().RemoveMethod.IsInitOnly); 2472Assert.False(constructor.IsInitOnly); 2473Assert.False(constructor.GetPublicSymbol().IsInitOnly); 2476Assert.False(destructor.IsInitOnly); 2477Assert.False(destructor.GetPublicSymbol().IsInitOnly); 2494Assert.False(conversion.IsInitOnly); 2495Assert.False(conversion.GetPublicSymbol().IsInitOnly); 2498Assert.False(addition.IsInitOnly); 2499Assert.False(addition.GetPublicSymbol().IsInitOnly); 2524Assert.False(method.IsInitOnly); 3278Assert.False(property0.MustCallMethodsDirectly); 3285Assert.False(property1.SetMethod.HasUseSiteError); 3286Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3290Assert.False(property2.SetMethod.HasUseSiteError); 3291Assert.False(property2.SetMethod.Parameters[0].Type.IsErrorType()); 3375Assert.False(property1.HasUseSiteError); 3377Assert.False(property1.SetMethod.HasUseSiteError); 3378Assert.False(property1.SetMethod.Parameters[0].Type.IsErrorType()); 3381Assert.False(property2.HasUseSiteError); 3383Assert.False(property2.SetMethod.HasUseSiteError); 3384Assert.False(property2.SetMethod.Parameters[0].Type.IsErrorType()); 3582Assert.False(property0.HasUseSiteError); 3583Assert.False(property0.MustCallMethodsDirectly); 3637Assert.False(method.IsInitOnly); 3638Assert.False(method.GetPublicSymbol().IsInitOnly); 3696Assert.False(method.IsInitOnly); 3697Assert.False(method.GetPublicSymbol().IsInitOnly); 3820Assert.False(property0.HasUseSiteError); 3822Assert.False(property0.GetMethod.HasUseSiteError); 3825Assert.False(property0.SetMethod.IsInitOnly); 3826Assert.False(property0.GetPublicSymbol().SetMethod.IsInitOnly); 3913Assert.False(property0.SetMethod.IsInitOnly); 3914Assert.False(property0.GetPublicSymbol().SetMethod.IsInitOnly); 4002Assert.False(property0.SetMethod.IsInitOnly); 4003Assert.False(property0.GetPublicSymbol().SetMethod.IsInitOnly); 4063Assert.False(property.GetMethod.IsInitOnly); 4064Assert.False(property.GetPublicSymbol().GetMethod.IsInitOnly); 4067Assert.False(property.SetMethod.IsInitOnly); 4068Assert.False(property.GetPublicSymbol().SetMethod.IsInitOnly); 4069Assert.False(property.SetMethod.HasUseSiteError); 4145Assert.False(localFunctionSymbol.IsInitOnly); 4146Assert.False(localFunctionSymbol.GetPublicSymbol().IsInitOnly); 4155Assert.False(method.IsInitOnly); 4156Assert.False(method.GetPublicSymbol().IsInitOnly); 4261Assert.False(i.SetMethod.IsReadOnly); 4300Assert.False(i.SetMethod.IsReadOnly); 4340Assert.False(i.SetMethod.IsReadOnly); 4382Assert.False(i.SetMethod.IsReadOnly); 4405Assert.False(i.SetMethod.IsReadOnly); 4436Assert.False(i1.SetMethod.IsReadOnly); 4438Assert.False(i2.SetMethod.IsReadOnly); 4823Assert.False(modifier.Modifier.IsFileLocal); 4835Assert.False(modifier.Modifier.IsFileLocal);
Semantics\InteractiveSemanticModelTests.cs (4)
169Assert.False(semanticInfo.IsCompileTimeConstant); 194Assert.False(semanticInfo.IsCompileTimeConstant); 220Assert.False(semanticInfo.IsCompileTimeConstant); 253Assert.False(semanticInfo.IsCompileTimeConstant);
Semantics\InterceptorsTests.cs (2)
6838Assert.False(EM.HasComplete(CompletionPart.Attributes)); 7392Assert.False(locationSpecifier!.Equals(null));
Semantics\InterpolationTests.cs (6)
4618Assert.False(semanticInfo.ConstantValue.HasValue); 6898Assert.False(cParam.HasInterpolatedStringHandlerArgumentError); 7732Assert.False(cParam.HasInterpolatedStringHandlerArgumentError); 7826Assert.False(cParam.HasInterpolatedStringHandlerArgumentError); 7938Assert.False(cParam.HasInterpolatedStringHandlerArgumentError); 8136Assert.False(cParam.HasInterpolatedStringHandlerArgumentError);
Semantics\IteratorTests.cs (8)
125Assert.False(i1.IsIterator); 126Assert.False(i1.GetPublicSymbol().IsIterator); 129Assert.False(i2.IsIterator); 130Assert.False(i2.GetPublicSymbol().IsIterator); 157Assert.False(i1.IsIterator); 158Assert.False(i1.GetPublicSymbol().IsIterator); 161Assert.False(i2.IsIterator); 162Assert.False(i2.GetPublicSymbol().IsIterator);
Semantics\LambdaDiscardParametersTests.cs (2)
571Assert.False(parameterSymbol1.IsDiscard); 575Assert.False(parameterSymbol2.IsDiscard);
Semantics\LambdaTests.cs (31)
2667Assert.False(parameter.Type.IsErrorType()); 2670Assert.False(parameter.Type.IsErrorType()); 2680Assert.False(parameter.Type.IsErrorType()); 8011Assert.False(lambdas[0].Symbol.Parameters[0].IsOptional); 8012Assert.False(lambdas[0].Symbol.Parameters[0].HasExplicitDefaultValue); 8022Assert.False(lambdas[2].Symbol.Parameters[0].HasExplicitDefaultValue); 8028Assert.False(lambdas[2].Symbol.Parameters[0].IsOptional); 8029Assert.False(lambdas[2].Symbol.Parameters[0].HasExplicitDefaultValue); 8358Assert.False(((SourceParameterSymbol)lambdas[0].Parameters.Single()).IsParamsCollection); 8360Assert.False(((SourceParameterSymbol)lambdas[1].Parameters.Single()).IsParams); 8361Assert.False(((SourceParameterSymbol)lambdas[1].Parameters.Single()).IsParamsArray); 8362Assert.False(((SourceParameterSymbol)lambdas[1].Parameters.Single()).IsParamsCollection); 8366Assert.False(((SourceParameterSymbol)lambdas[2].Parameters[0]).IsParams); 8367Assert.False(((SourceParameterSymbol)lambdas[2].Parameters[0]).IsParamsArray); 8368Assert.False(((SourceParameterSymbol)lambdas[2].Parameters[0]).IsParamsCollection); 8371Assert.False(((SourceParameterSymbol)lambdas[2].Parameters[1]).IsParamsCollection); 8393Assert.False(((SourceParameterSymbol)lambdas[0].Parameters[0]).IsParamsCollection); 8396Assert.False(((SourceParameterSymbol)lambdas[0].Parameters[1]).IsParamsCollection); 8397Assert.False(((SourceParameterSymbol)lambdas[0].Parameters[2]).IsParams); 8398Assert.False(((SourceParameterSymbol)lambdas[0].Parameters[2]).IsParamsArray); 8399Assert.False(((SourceParameterSymbol)lambdas[0].Parameters[2]).IsParamsCollection); 8405Assert.False(((SourceParameterSymbol)lambdas[1].Parameters[0]).IsParamsCollection); 8406Assert.False(((SourceParameterSymbol)lambdas[1].Parameters[1]).IsParams); 8407Assert.False(((SourceParameterSymbol)lambdas[1].Parameters[1]).IsParamsArray); 8408Assert.False(((SourceParameterSymbol)lambdas[1].Parameters[1]).IsParamsCollection); 8411Assert.False(((SourceParameterSymbol)lambdas[1].Parameters[2]).IsParamsCollection); 8435Assert.False(lam1.DelegateParameters().Single().IsParamsCollection); 8441Assert.False(lam3Parameters[0].IsParams); 8442Assert.False(lam3Parameters[0].IsParamsArray); 8443Assert.False(lam3Parameters[0].IsParamsCollection); 8446Assert.False(lam3Parameters[1].IsParamsCollection);
Semantics\LocalFunctionTests.cs (7)
1727Assert.False(attrs[2].AttributeClass.IsErrorType()); 1932Assert.False(attrs[2].AttributeClass.IsErrorType()); 2596Assert.False(methods[0].Parameters[2].IsParams); 2600Assert.False(methods[1].Parameters[1].IsParams); 8784Assert.False(model.LookupSymbols(nameofExpression.ArgumentList.CloseParenToken.SpanStart).ToTestDisplayStrings().Contains("parameter")); 10792Assert.False(i1Symbol.IsIterator); 10796Assert.False(i2Symbol.IsIterator);
Semantics\LookupTests.cs (4)
1865Assert.False(symbols.Any(s => s.Kind == SymbolKind.TypeParameter)); 1887Assert.False(symbols.Any(s => s.Kind == SymbolKind.TypeParameter)); 1910Assert.False(symbols.Any(s => s.Kind == SymbolKind.TypeParameter)); 1932Assert.False(symbols.Any(s => s.Kind == SymbolKind.TypeParameter));
Semantics\MultiDimensionalArrayTests.cs (19)
544Assert.False(mdArray.IsSZArray); 1095Assert.False(array.IsSZArray); 1102Assert.False(array.IsSZArray); 1109Assert.False(array.IsSZArray); 1116Assert.False(array.IsSZArray); 1123Assert.False(array.IsSZArray); 1130Assert.False(array.IsSZArray); 1137Assert.False(array.IsSZArray); 1144Assert.False(array.IsSZArray); 1151Assert.False(array.IsSZArray); 1158Assert.False(array.IsSZArray); 1165Assert.False(array.IsSZArray); 1172Assert.False(array.IsSZArray); 1179Assert.False(array.IsSZArray); 1186Assert.False(array.IsSZArray); 1193Assert.False(array.IsSZArray); 1200Assert.False(array.IsSZArray); 1207Assert.False(array.IsSZArray); 1689Assert.False(a2.IsSZArray);
Semantics\NamedAndOptionalTests.cs (35)
2052Assert.False(parameters[0].IsOptional); 2053Assert.False(parameters[0].HasExplicitDefaultValue); 2071Assert.False(parameters[3].HasExplicitDefaultValue); 2076Assert.False(parameters[4].IsOptional); 2077Assert.False(parameters[4].HasExplicitDefaultValue); 2083Assert.False(parameters[5].IsOptional); 2084Assert.False(parameters[5].HasExplicitDefaultValue); 2134Assert.False(parameters[0].IsOptional); 2135Assert.False(parameters[0].HasExplicitDefaultValue); 2147Assert.False(parameters[2].HasExplicitDefaultValue); 2185Assert.False(parameters[0].IsOptional); 2186Assert.False(parameters[0].HasExplicitDefaultValue); 2204Assert.False(parameters[3].HasExplicitDefaultValue); 2209Assert.False(parameters[4].IsOptional); 2210Assert.False(parameters[4].HasExplicitDefaultValue); 2222Assert.False(parameters[6].IsOptional); 2223Assert.False(parameters[6].HasExplicitDefaultValue); 2268Assert.False(parameters[0].IsOptional); 2269Assert.False(parameters[0].HasExplicitDefaultValue); 2287Assert.False(parameters[3].HasExplicitDefaultValue); 2292Assert.False(parameters[4].IsOptional); 2293Assert.False(parameters[4].HasExplicitDefaultValue); 2295Assert.False(parameters[4].HasMetadataConstantValue); 2299Assert.False(parameters[5].IsOptional); 2300Assert.False(parameters[5].HasExplicitDefaultValue); 2302Assert.False(parameters[5].HasMetadataConstantValue); 2350Assert.False(parameters[0].IsOptional); 2351Assert.False(parameters[0].HasExplicitDefaultValue); 2363Assert.False(parameters[2].HasExplicitDefaultValue); 2368Assert.False(parameters[3].IsOptional); 2369Assert.False(parameters[3].HasExplicitDefaultValue); 2371Assert.False(parameters[3].HasMetadataConstantValue); 2375Assert.False(parameters[4].IsOptional); 2376Assert.False(parameters[4].HasExplicitDefaultValue); 2378Assert.False(parameters[4].HasMetadataConstantValue);
Semantics\NameOfTests.cs (2)
3061Assert.False(nameofType.IsUnboundGenericType()); 3063Assert.False(typeofType.IsDefinition);
Semantics\NativeIntegerTests.cs (40)
76Assert.False(comp.Assembly.RuntimeSupportsNumericIntPtr); 77Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 91Assert.False(comp.Assembly.RuntimeSupportsNumericIntPtr); 92Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 181Assert.False(comp.Assembly.RuntimeSupportsNumericIntPtr); 182Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 187Assert.False(comp.Assembly.RuntimeSupportsNumericIntPtr); 188Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 194Assert.False(comp.Assembly.RuntimeSupportsNumericIntPtr); 195Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 200Assert.False(comp.Assembly.RuntimeSupportsNumericIntPtr); 201Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 271Assert.False(underlyingType.Equals(nativeIntegerType)); 272Assert.False(((IEquatable<ISymbol>)underlyingType).Equals(nativeIntegerType)); 273Assert.False(underlyingType.Equals(nativeIntegerType, SymbolEqualityComparer.Default)); 274Assert.False(underlyingType.Equals(nativeIntegerType, SymbolEqualityComparer.IncludeNullability)); 275Assert.False(underlyingType.Equals(nativeIntegerType, SymbolEqualityComparer.ConsiderEverything)); 382Assert.False(underlyingType.Equals(nativeIntegerType, TypeCompareKind.ConsiderEverything)); 383Assert.False(nativeIntegerType.Equals(underlyingType, TypeCompareKind.ConsiderEverything)); 487Assert.False(members.IsDefaultOrEmpty); 528Assert.False(members.IsDefaultOrEmpty); 558Assert.False(member.Equals(underlyingMember, TypeCompareKind.ConsiderEverything)); 600Assert.False(containsType(fromMember, useNativeInteger: false)); 602Assert.False(containsType(fromUnderlyingMember, useNativeInteger: true)); 1160Assert.False(type1.IsErrorType()); 1180Assert.False(type2.IsNativeIntegerWrapperType); 1235Assert.False(typeA.IsErrorType()); 1252Assert.False(typeB.IsNativeIntegerWrapperType); 3649Assert.False(underlyingType0.IsNativeIntegerWrapperType); 3691Assert.False(underlyingType0.IsNativeIntegerWrapperType); 3693Assert.False(underlyingType1.IsNativeIntegerWrapperType); 3725Assert.False(underlyingType0.IsNativeIntegerWrapperType); 3759Assert.False(underlyingType0.IsNativeIntegerWrapperType); 4130Assert.False(type.IsNativeIntegerType); 7829Assert.False(IsNoConversion(expectedConversions)); 14743Assert.False(TypeUnification.CanUnify(type1, type2)); 15348Assert.False(nintSymbol.IsNativeIntegerType); 15371Assert.False(symbol.IsNativeIntegerType); 15422Assert.False(symbol.IsNativeIntegerType); 15452Assert.False(symbol.IsNativeIntegerType);
Semantics\NullableContextTests.cs (8)
116Assert.False(NullableContextOptions.Annotations.WarningsEnabled()); 118Assert.False(NullableContextOptions.Warnings.AnnotationsEnabled()); 121Assert.False(NullableContextOptions.Disable.AnnotationsEnabled()); 122Assert.False(NullableContextOptions.Disable.WarningsEnabled()); 137Assert.False(context.WarningsInherited()); 138Assert.False(context.AnnotationsInherited()); 144Assert.False(warningsInherited.AnnotationsInherited()); 149Assert.False(annotationsInherited.WarningsInherited());
Semantics\NullableReferenceTypesTests.cs (99)
5763Assert.False(((CSharpSyntaxTree)source1).IsGeneratedCode(null, cancellationToken: default)); 5777Assert.False(((CSharpSyntaxTree)source2).IsGeneratedCode(null, cancellationToken: default)); 5790Assert.False(((CSharpSyntaxTree)source3).IsGeneratedCode(null, cancellationToken: default)); 5802Assert.False(((CSharpSyntaxTree)source4).IsGeneratedCode(null, cancellationToken: default)); 9450Assert.False(comp.GetMember("Microsoft.CodeAnalysis.EmbeddedAttribute").IsImplicitlyDeclared); 11507Assert.False(m1.Parameters[0].Type.IsReferenceType); 11512Assert.False(m2.ReturnType.IsReferenceType); 11513Assert.False(m2.OverriddenMethod.ReturnType.IsNullableType()); 11573Assert.False(m2.Parameters[0].Type.IsNullableType()); 11574Assert.False(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 11769Assert.False(m1.Parameters[0].Type.StrippedType().IsValueType); 11770Assert.False(m1.Parameters[0].Type.StrippedType().IsReferenceType); 12016Assert.False(m1.ReturnType.IsNullableType()); 12017Assert.False(m1.OverriddenMethod.ReturnType.IsNullableType()); 12020Assert.False(m4.ReturnType.IsNullableType()); 12024Assert.False(m5.ReturnType.IsNullableType()); 12099Assert.False(m1.Parameters[0].Type.IsNullableType()); 12102Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 12105Assert.False(m4.Parameters[0].Type.IsNullableType()); 12109Assert.False(m5.Parameters[0].Type.IsNullableType()); 12188Assert.False(b.GetMember<MethodSymbol>("M3").ReturnType.IsNullableType()); 12260Assert.False(b.GetMember<MethodSymbol>("M3").Parameters[0].Type.IsNullableType()); 12334Assert.False(member.TypeWithAnnotations.Equals(member.OverriddenEvent.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions)); 12695Assert.False(impl.TypeWithAnnotations.Equals(member.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions)); 12788Assert.False(impl.TypeWithAnnotations.Equals(member.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions)); 12885Assert.False(member.TypeWithAnnotations.Equals(member.OverriddenProperty.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions)); 13036Assert.False(impl.TypeWithAnnotations.Equals(member.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions)); 13127Assert.False(impl.TypeWithAnnotations.Equals(member.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions)); 13208Assert.False(member.ReturnTypeWithAnnotations.Equals(member.OverriddenMethod.ConstructIfGeneric(member.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).ReturnTypeWithAnnotations, 13327Assert.False(implementing.ReturnTypeWithAnnotations.Equals(implemented.ReturnTypeWithAnnotations, 13414Assert.False(implementing.ReturnTypeWithAnnotations.Equals(implemented.ReturnTypeWithAnnotations, 13688Assert.False(m1.Parameters[0].TypeWithAnnotations.Equals(m1.OverriddenMethod.ConstructIfGeneric(m1.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).Parameters[0].TypeWithAnnotations, 13898Assert.False(m1.Parameters[0].Type.IsNullableType()); 13901Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 13904Assert.False(m2.ReturnType.IsNullableType()); 13907Assert.False(m2.OverriddenMethod.ReturnType.IsNullableType()); 13973Assert.False(((NamedTypeSymbol)m5.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 13974Assert.False(((NamedTypeSymbol)m5.OverriddenMethod.Parameters[0].Type).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].IsNullableType()); 14028Assert.False(member.ReturnTypeWithAnnotations.Equals(member.OverriddenMethod.ConstructIfGeneric(member.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).ReturnTypeWithAnnotations, 14135Assert.False(member.Parameters[0].TypeWithAnnotations.Equals(member.OverriddenMethod.ConstructIfGeneric(member.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).Parameters[0].TypeWithAnnotations, 14229Assert.False(m1.Parameters[0].Type.IsNullableType()); 14230Assert.False(m1.OverriddenMethod.Parameters[0].Type.IsNullableType()); 14234Assert.False(m2.Parameters[0].Type.IsNullableType()); 14235Assert.False(m2.OverriddenMethod.Parameters[0].Type.IsNullableType()); 16504Assert.False(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 16635Assert.False(member.Parameters[0].TypeWithAnnotations.Equals(member.OverriddenProperty.Parameters[0].TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions)); 16720Assert.False(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions)); 16805Assert.False(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions)); 17734Assert.False(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, 17802Assert.False(implementing.ReturnTypeWithAnnotations.Equals(implemented.ReturnTypeWithAnnotations, 17840Assert.False(tp.IsNullableType()); 17881Assert.False(m1Impl.Parameters[i].TypeWithAnnotations.Equals(m1Def.Parameters[i].TypeWithAnnotations, 98530Assert.False(t11.IsReferenceType); 100344Assert.False(t1.IsReferenceType); 100382Assert.False(t1.IsReferenceType); 100426Assert.False(t1.IsReferenceType); 100433Assert.False(t2.IsReferenceType); 100465Assert.False(t1.IsReferenceType); 100485Assert.False(t1.IsReferenceType); 100718Assert.False(at1.IsReferenceType); 100748Assert.False(tf1.IsReferenceType); 103256Assert.False(tf1.HasNotNullConstraint); 103330Assert.False(tf1.HasNotNullConstraint); 103381Assert.False(tf1.HasNotNullConstraint); 112935Assert.False(b.BaseTypeNoUseSiteDiagnostics.IsDefinition); 112974Assert.False(b.BaseTypeNoUseSiteDiagnostics.IsDefinition); 113051Assert.False(b.BaseTypeNoUseSiteDiagnostics.IsDefinition); 113131Assert.False(b.BaseTypeNoUseSiteDiagnostics.IsDefinition); 113189Assert.False(method1.Equals(method2, SymbolEqualityComparer.IncludeNullability.CompareKind)); 113190Assert.False(method2.Equals(method1, SymbolEqualityComparer.IncludeNullability.CompareKind)); 115789Assert.False(type2.IsDefinition); 115812Assert.False(type2.IsDefinition); 115839Assert.False(c2.IsDefinition); 115845Assert.False(i2.IsDefinition); 115851Assert.False(c3.IsDefinition); 115857Assert.False(i3.IsDefinition); 115922Assert.False(c4.IsDefinition); 115923Assert.False(cDefinition.Equals(c4, TypeCompareKind.ConsiderEverything)); 115924Assert.False(cDefinition.Equals(c4, TypeCompareKind.CLRSignatureCompareOptions)); 115931Assert.False(iDefinition.Equals(i4, TypeCompareKind.ConsiderEverything)); 115932Assert.False(iDefinition.Equals(i4, TypeCompareKind.CLRSignatureCompareOptions)); 115941Assert.False(c.Equals(c2, SymbolEqualityComparer.ConsiderEverything.CompareKind)); 138557Assert.False(c.HasUnsupportedMetadata); 139463Assert.False(dGoo.Parameters[0].Type.IsNullableType()); 144375Assert.False(IsNullableAnalysisEnabled(comp, "C.M")); 150583Assert.False(comp.GetMember<MethodSymbol>("B2.F").TypeParameters[0].IsValueType); 157658Assert.False(field2.Equals(field3, SymbolEqualityComparer.IncludeNullability)); 157660Assert.False(field3.Equals(field2, SymbolEqualityComparer.IncludeNullability)); 157664Assert.False(field1.Equals(field2, SymbolEqualityComparer.IncludeNullability)); 157666Assert.False(field2.Equals(field1, SymbolEqualityComparer.IncludeNullability)); 157702Assert.False(method2.IsDefinition); 157709Assert.False(method2.Equals(method3, SymbolEqualityComparer.Default)); 157710Assert.False(method2.Equals(method3, SymbolEqualityComparer.IncludeNullability)); 157711Assert.False(method3.Equals(method2, SymbolEqualityComparer.Default)); 157712Assert.False(method3.Equals(method2, SymbolEqualityComparer.IncludeNullability)); 157715Assert.False(method1.Equals(method2, SymbolEqualityComparer.Default)); 157716Assert.False(method1.Equals(method2, SymbolEqualityComparer.IncludeNullability)); 157717Assert.False(method2.Equals(method1, SymbolEqualityComparer.Default)); 157718Assert.False(method2.Equals(method1, SymbolEqualityComparer.IncludeNullability));
Semantics\OperatorTests.cs (27)
53Assert.False(insideEnumDefinition.IsEmpty); 54Assert.False(insideMethodBody.IsEmpty); 7651Assert.False(symbol1.IsGenericMethod); 7652Assert.False(symbol1.IsExtensionMethod); 7653Assert.False(symbol1.IsExtern); 7654Assert.False(symbol1.CanBeReferencedByName); 7665Assert.False(symbol1.HidesBaseMethodsByName); 7666Assert.False(symbol1.IsOverride); 7667Assert.False(symbol1.IsVirtual); 7668Assert.False(symbol1.IsAbstract); 7669Assert.False(symbol1.IsSealed); 7714Assert.False(symbol1.IsCheckedBuiltin); 8196Assert.False(leftType.IsStringType() && rightType.IsStringType()); 8291Assert.False(symbol1.IsImplicitlyDeclared); 8425Assert.False(symbol1.IsGenericMethod); 8426Assert.False(symbol1.IsExtensionMethod); 8427Assert.False(symbol1.IsExtern); 8428Assert.False(symbol1.CanBeReferencedByName); 8460Assert.False(symbol1.HidesBaseMethodsByName); 8461Assert.False(symbol1.IsOverride); 8462Assert.False(symbol1.IsVirtual); 8463Assert.False(symbol1.IsAbstract); 8464Assert.False(symbol1.IsSealed); 8597Assert.False(symbol1.IsCheckedBuiltin); 8643Assert.False(symbol1.IsCheckedBuiltin); 8654Assert.False(symbol2.IsCheckedBuiltin); 8693Assert.False(symbol1.IsCheckedBuiltin);
Semantics\QueryTests.cs (2)
2607Assert.False(CreateCompilationWithMscorlib40AndSystemCore(sourceCode).Emit(output).Success); 2629Assert.False(CreateCompilationWithMscorlib40AndSystemCore(sourceCode).Emit(output).Success);
Semantics\RawInterpolationTests_Handler.cs (4)
2919Assert.False(semanticInfo.ConstantValue.HasValue); 5157Assert.False(cParam.HasInterpolatedStringHandlerArgumentError); 5990Assert.False(cParam.HasInterpolatedStringHandlerArgumentError); 6116Assert.False(cParam.HasInterpolatedStringHandlerArgumentError);
Semantics\ReadOnlyStructsTests.cs (17)
422Assert.False(method.IsDeclaredReadOnly); 423Assert.False(method.IsEffectivelyReadOnly); 1192Assert.False(getMethod(s1, "M1").IsReadOnly); 1197Assert.False(getProperty(s1, "P1").SetMethod.IsReadOnly); 1205Assert.False(getProperty(s1, "P5").GetMethod.IsReadOnly); 1206Assert.False(getProperty(s1, "P5").SetMethod.IsReadOnly); 1213Assert.False(getMethod(s2, "M2").IsReadOnly); 1221Assert.False(getProperty(s2, "P4").GetMethod.IsReadOnly); 1222Assert.False(getProperty(s2, "P4").SetMethod.IsReadOnly); 1289Assert.False(symbol.GetSymbol().IsDeclaredReadOnly); 1290Assert.False(reducedFrom.GetSymbol().IsDeclaredReadOnly); 1291Assert.False(reducedFrom.GetSymbol().IsEffectivelyReadOnly); 1292Assert.False(((IMethodSymbol)reducedFrom).IsReadOnly); 1460Assert.False(method.IsEffectivelyReadOnly); 1614Assert.False(moduleGetter.IsDeclaredReadOnly); 1642Assert.False(moduleGetter.IsDeclaredReadOnly); 1647Assert.False(dllGetter.IsDeclaredReadOnly);
Semantics\RecordStructTests.cs (56)
392Assert.False(point.IsReferenceType); 393Assert.False(point.IsRecord); 408Assert.False(point.IsRecordStruct); 409Assert.False(point.GetPublicSymbol().IsRecord); 482Assert.False(point.IsReferenceType); 483Assert.False(point.IsRecord); 497Assert.False(point.IsRecordStruct); 498Assert.False(point.GetPublicSymbol().IsRecord); 539Assert.False(type.IsRecord); 559Assert.False(type.IsRecord); 579Assert.False(type.IsRecord); 601Assert.False(type.IsRecord); 1835Assert.False(c.IsReadOnly); 1839Assert.False(x.SetMethod!.IsInitOnly); 1843Assert.False(xBackingField.IsReadOnly); 2790Assert.False(p.HasPointerType); 3520Assert.False(deconstruct.IsVirtual); 3521Assert.False(deconstruct.IsStatic); 3915Assert.False(method.IsDeclaredReadOnly); 4412Assert.False(recordEquals.IsAbstract); 4413Assert.False(recordEquals.IsVirtual); 4414Assert.False(recordEquals.IsOverride); 4415Assert.False(recordEquals.IsSealed); 4421Assert.False(objectEquals.IsAbstract); 4422Assert.False(objectEquals.IsVirtual); 4424Assert.False(objectEquals.IsSealed); 4430Assert.False(gethashCode.IsStatic); 4431Assert.False(gethashCode.IsAbstract); 4432Assert.False(gethashCode.IsVirtual); 4434Assert.False(gethashCode.IsSealed); 4980Assert.False(op.IsAbstract); 4981Assert.False(op.IsVirtual); 4982Assert.False(op.IsOverride); 4983Assert.False(op.IsSealed); 4990Assert.False(op.IsAbstract); 4991Assert.False(op.IsVirtual); 4992Assert.False(op.IsOverride); 4993Assert.False(op.IsSealed); 5215Assert.False(print.IsOverride); 5216Assert.False(print.IsVirtual); 5217Assert.False(print.IsAbstract); 5218Assert.False(print.IsSealed); 5224Assert.False(toString.IsVirtual); 5225Assert.False(toString.IsAbstract); 5226Assert.False(toString.IsSealed); 5419Assert.False(print.IsOverride); 5420Assert.False(print.IsVirtual); 5421Assert.False(print.IsAbstract); 5422Assert.False(print.IsSealed); 5428Assert.False(toString.IsVirtual); 5429Assert.False(toString.IsAbstract); 5430Assert.False(toString.IsSealed); 5899Assert.False(method.IsDeclaredReadOnly); 10851Assert.False(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativeBase, out _)); 10857Assert.False(model.TryGetSpeculativeSemanticModel(baseWithoutargs.ArgumentList.OpenParenToken.SpanStart, speculativeBase, out _)); 10862Assert.False(model.TryGetSpeculativeSemanticModel(baseWithoutParens.SpanStart + 2, speculativeBase, out _));
Semantics\RefEscapingTests.cs (12)
53Assert.False(getLocalType("s1").IsRefLikeType); 55Assert.False(getLocalType("i0").IsRefLikeType); 56Assert.False(getLocalType("t1").IsRefLikeType); 57Assert.False(getLocalType("e1").IsRefLikeType); 58Assert.False(getLocalType("o1").IsRefLikeType); 59Assert.False(getLocalType("c1").IsRefLikeType); 60Assert.False(getLocalType("t1").IsRefLikeType); 61Assert.False(getLocalType("u1").IsRefLikeType); 62Assert.False(getLocalType("p1").IsRefLikeType); 63Assert.False(getLocalType("a1").IsRefLikeType); 64Assert.False(getLocalType("a2").IsRefLikeType); 65Assert.False(getLocalType("t2").IsRefLikeType);
Semantics\RefFieldTests.cs (11)
2237Assert.False(comp.Assembly.RuntimeSupportsByRefFields); 2238Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefFields)); 2253Assert.False(comp.Assembly.RuntimeSupportsByRefFields); 2254Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefFields)); 27088Assert.False(method.ContainingModule.UseUpdatedEscapeRules); 27127Assert.False(method.ContainingModule.UseUpdatedEscapeRules); 27235Assert.False(module.UseUpdatedEscapeRules); 27281Assert.False(module.UseUpdatedEscapeRules); 27301Assert.False(module.UseUpdatedEscapeRules); 27348Assert.False(module.UseUpdatedEscapeRules); 27349Assert.False(((SourceModuleSymbol)module).RequiresRefSafetyRulesAttribute());
Semantics\ScriptSemanticsTests.cs (5)
419Assert.False(cls.IsImplicitClass); 424Assert.False(cls.IsScriptClass); 600Assert.False(type.IsScriptClass); 601Assert.False(type.IsSubmissionClass); 606Assert.False(symbols.Any(s => s.Name == "Roslyn"));
Semantics\SemanticErrorTests.cs (8)
16777Assert.False(comp.GetDiagnostics().Any()); 25166Assert.False(comp.SourceAssembly.HasComplete(CompletionPart.AssemblySymbolAll)); 25169Assert.False(bSymbol.HasComplete(CompletionPart.MembersCompleted)); 25236Assert.False(comp.SourceAssembly.HasComplete(CompletionPart.AssemblySymbolAll)); 25237Assert.False(aSymbol.HasComplete(CompletionPart.MembersCompleted)); 25240Assert.False(eSymbol.HasComplete(CompletionPart.MembersCompleted)); 25331Assert.False(comp.SourceAssembly.HasComplete(CompletionPart.AssemblySymbolAll)); 25334Assert.False(bSymbol.HasComplete(CompletionPart.MembersCompleted));
Semantics\StructConstructorTests.cs (4)
3581Assert.False((bool)g1.Parameters[0].ExplicitDefaultValue); 3582Assert.False(g1.Parameters[0].ExplicitDefaultConstantValue.IsNull); 3586Assert.False((bool)g2.Parameters[0].ExplicitDefaultValue); 3587Assert.False(g2.Parameters[0].ExplicitDefaultConstantValue.BooleanValue);
Semantics\SyntaxTreeRootTests.cs (1)
48Assert.False(tree.HasCompilationUnitRoot);
Semantics\SynthesizedStaticConstructorTests.cs (20)
28Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 44Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 61Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 95Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 111Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 112Assert.False(IsBeforeFieldInit(typeSymbol)); 129Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 130Assert.False(IsBeforeFieldInit(typeSymbol)); 148Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 149Assert.False(IsBeforeFieldInit(typeSymbol)); 167Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 168Assert.False(IsBeforeFieldInit(typeSymbol)); 186Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 187Assert.False(IsBeforeFieldInit(typeSymbol)); 201Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 218Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 219Assert.False(IsBeforeFieldInit(typeSymbol)); 233Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 250Assert.False(HasSynthesizedStaticConstructor(typeSymbol)); 251Assert.False(IsBeforeFieldInit(typeSymbol));
Semantics\TargetTypedDefaultTests.cs (30)
49Assert.False(model.GetConversion(def).IsNullLiteral); 149Assert.False(model.GetConversion(def).IsNullLiteral); 250Assert.False(model.GetConversion(def).IsNullLiteral); 287Assert.False(model.GetConversion(def).IsNullLiteral); 525Assert.False(model.GetConstantValue(def).HasValue); 526Assert.False(model.GetConversion(def).IsNullLiteral); 527Assert.False(model.GetConversion(def).IsDefaultLiteral); 571Assert.False(model.GetConstantValue(def).HasValue); 572Assert.False(model.GetConversion(def).IsNullLiteral); 573Assert.False(model.GetConversion(def).IsDefaultLiteral); 614Assert.False(model.GetConstantValue(def).HasValue); 615Assert.False(model.GetConversion(def).IsNullLiteral); 616Assert.False(model.GetConversion(def).IsDefaultLiteral); 672Assert.False(model.GetConstantValue(def).HasValue); 673Assert.False(model.GetConversion(def).IsNullLiteral); 753Assert.False(model.GetConstantValue(def).HasValue); 754Assert.False(model.GetConversion(def).IsNullLiteral); 755Assert.False(model.GetConversion(def).IsDefaultLiteral); 841Assert.False(model.GetConstantValue(def).HasValue); 842Assert.False(model.GetConversion(def).IsNullLiteral); 870Assert.False(model.GetConstantValue(def).HasValue); 871Assert.False(model.GetConversion(def).IsNullLiteral); 3059Assert.False(model.GetConstantValue(def).HasValue); 3060Assert.False(model.GetConversion(def).IsNullLiteral); 3579Assert.False(model.GetConstantValue(default1).HasValue); 3580Assert.False(model.GetConversion(default1).IsNullLiteral); 3587Assert.False(model.GetConstantValue(default2).HasValue); 3594Assert.False(model.GetConstantValue(default3).HasValue); 3677Assert.False(model.GetConstantValue(value).HasValue); 3718Assert.False(model.GetConstantValue(defaultValue).HasValue);
Semantics\TopLevelStatementsTests.cs (66)
51Assert.False(entryPoint.CanBeReferencedByName); 81Assert.False(entryPoint.ReturnsVoid); 479Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 531Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 571Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 695Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 708Assert.False(local.ContainingSymbol.IsImplicitlyDeclared); 711Assert.False(local.ContainingSymbol.ContainingSymbol.IsImplicitlyDeclared); 868Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 982Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 1037Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 1090Assert.False(entryPoint.ReturnType.IsErrorType()); 1404Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 1422Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 1682Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 1705Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 1855Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 1878Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 2081Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 2245Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 2423Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 2915Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 3938Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 3953Assert.False(symbols.Any(s => s.Kind == SymbolKind.Parameter)); 4087Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 4102Assert.False(symbols.Any(s => s.Kind == SymbolKind.Parameter)); 4137Assert.False(symbols.Any(s => s.Kind == SymbolKind.Parameter)); 4142Assert.False(symbols.Any(s => s.Kind == SymbolKind.Parameter)); 4212Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 4225Assert.False(local.ContainingSymbol.IsImplicitlyDeclared); 4227Assert.False(local.ContainingSymbol.ContainingSymbol.IsImplicitlyDeclared); 4507Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 4571Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 4620Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 4890Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 4903Assert.False(label.ContainingSymbol.IsImplicitlyDeclared); 4905Assert.False(label.ContainingSymbol.ContainingSymbol.IsImplicitlyDeclared); 4947Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 4975Assert.False(IsNullableAnalysisEnabled(comp)); // To make sure we test incremental binding for SemanticModel 4988Assert.False(label.ContainingSymbol.IsImplicitlyDeclared); 4990Assert.False(label.ContainingSymbol.ContainingSymbol.IsImplicitlyDeclared); 6227Assert.False(program.IsImplicitlyDeclared); 6239Assert.False(method.IsImplicitlyDeclared); 6515Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(globalStatement.Statement).IsEmpty); 6993Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(unit).IsEmpty); 7061Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(unit).IsEmpty); 7147Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(node).IsEmpty); 7547Assert.False(entryPoint.ReturnsVoid); 7569Assert.False(entryPoint.ReturnsVoid); 7607Assert.False(entryPoint.ReturnsVoid); 7634Assert.False(entryPoint.ReturnsVoid); 7728Assert.False(entryPoint.ReturnsVoid); 7775Assert.False(entryPoint.ReturnsVoid); 7844Assert.False(entryPoint.ReturnsVoid); 7909Assert.False(entryPoint.ReturnsVoid); 8008Assert.False(entryPoint.ReturnsVoid); 8030Assert.False(entryPoint.ReturnsVoid); 8087Assert.False(entryPoint.ReturnsVoid); 8107Assert.False(entryPoint.ReturnsVoid); 9108Assert.False(entryPoint.CanBeReferencedByName); 9119Assert.False(program.IsImplicitlyDeclared); 9163Assert.False(entryPoint.CanBeReferencedByName); 9174Assert.False(program.IsImplicitlyDeclared); 9205Assert.False(entryPoint.CanBeReferencedByName); 9382Assert.False(entryPoint.ContainingType.IsStatic); 9559Assert.False(field.ContainingType.IsImplicitlyDeclared);
Semantics\UnsafeTests.cs (64)
2675Assert.False(fieldTypes[2].Type.IsPointerOrFunctionPointer()); 2677Assert.False(fieldTypes[3].Type.IsPointerOrFunctionPointer()); 2680Assert.False(fieldTypes[4].Type.IsPointerOrFunctionPointer()); 2682Assert.False(fieldTypes[5].Type.IsPointerOrFunctionPointer()); 2684Assert.False(fieldTypes[6].Type.IsPointerOrFunctionPointer()); 2686Assert.False(fieldTypes[7].Type.IsPointerOrFunctionPointer()); 5490Assert.False(method.ReturnType.IsManagedTypeNoUseSiteDiagnostics); 5521Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("E").IsManagedTypeNoUseSiteDiagnostics); 5522Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<NamedTypeSymbol>("E").IsManagedTypeNoUseSiteDiagnostics); 5523Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("D").GetMember<NamedTypeSymbol>("E").IsManagedTypeNoUseSiteDiagnostics); 5524Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S").GetMember<NamedTypeSymbol>("E").IsManagedTypeNoUseSiteDiagnostics); 5525Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("R").GetMember<NamedTypeSymbol>("E").IsManagedTypeNoUseSiteDiagnostics); 5558Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S").IsManagedTypeNoUseSiteDiagnostics); 5560Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("P").IsManagedTypeNoUseSiteDiagnostics); 5562Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("C").GetMember<NamedTypeSymbol>("S").IsManagedTypeNoUseSiteDiagnostics); 5563Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("D").GetMember<NamedTypeSymbol>("S").IsManagedTypeNoUseSiteDiagnostics); 5564Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("Q").GetMember<NamedTypeSymbol>("S").IsManagedTypeNoUseSiteDiagnostics); 5565Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("R").GetMember<NamedTypeSymbol>("S").IsManagedTypeNoUseSiteDiagnostics); 5590Assert.False(type.GetMember<FieldSymbol>("f1").Type.IsManagedTypeNoUseSiteDiagnostics); 5592Assert.False(type.GetMember<FieldSymbol>("f2").Type.IsManagedTypeNoUseSiteDiagnostics); 5601Assert.False(type.GetMember<FieldSymbol>("f5").Type.IsManagedTypeNoUseSiteDiagnostics); 5603Assert.False(type.GetMember<FieldSymbol>("f6").Type.IsManagedTypeNoUseSiteDiagnostics); 5626Assert.False(type.GetMember<FieldSymbol>("f2").Type.IsManagedTypeNoUseSiteDiagnostics); 5681Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S1").IsManagedTypeNoUseSiteDiagnostics); 5683Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S3").IsManagedTypeNoUseSiteDiagnostics); 5725Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S1").IsManagedTypeNoUseSiteDiagnostics); 5727Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S3").IsManagedTypeNoUseSiteDiagnostics); 5764Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S1").IsManagedTypeNoUseSiteDiagnostics); 5766Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S3").IsManagedTypeNoUseSiteDiagnostics); 5808Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S1").IsManagedTypeNoUseSiteDiagnostics); 5810Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S3").IsManagedTypeNoUseSiteDiagnostics); 5832Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S2").IsManagedTypeNoUseSiteDiagnostics); 5845Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("W").IsManagedTypeNoUseSiteDiagnostics); 5866Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S").IsManagedTypeNoUseSiteDiagnostics); 5888Assert.False(globalNamespace.GetMember<NamedTypeSymbol>("S").IsManagedTypeNoUseSiteDiagnostics); 5898Assert.False(compilation.GetSpecialType(SpecialType.System_ArgIterator).IsManagedTypeNoUseSiteDiagnostics); 5899Assert.False(compilation.GetSpecialType(SpecialType.System_RuntimeArgumentHandle).IsManagedTypeNoUseSiteDiagnostics); 6311Assert.False(getLocalType("s3").IsUnmanagedType); 6313Assert.False(getLocalType("s4_1").IsUnmanagedType); 6318Assert.False(getLocalType("o1").IsUnmanagedType); 6319Assert.False(getLocalType("c1").IsUnmanagedType); 6320Assert.False(getLocalType("t1").IsUnmanagedType); 6323Assert.False(getLocalType("a1").IsUnmanagedType); 6324Assert.False(getLocalType("a2").IsUnmanagedType); 6383Assert.False(getLocalType("bad").IsUnmanagedType); 6384Assert.False(getLocalType("bad2").IsUnmanagedType); 8887Assert.False(summary.IsCompileTimeConstant); 8888Assert.False(summary.ConstantValue.HasValue); 8922Assert.False(summary.IsCompileTimeConstant); 8923Assert.False(summary.ConstantValue.HasValue); 9349Assert.False(summary.IsCompileTimeConstant); 9350Assert.False(summary.ConstantValue.HasValue); 10641Assert.False(typeSummary.IsCompileTimeConstant); 10642Assert.False(typeSummary.ConstantValue.HasValue); 10703Assert.False(typeSummary.IsCompileTimeConstant); 10704Assert.False(typeSummary.ConstantValue.HasValue); 10763Assert.False(typeSummary.IsCompileTimeConstant); 10764Assert.False(typeSummary.ConstantValue.HasValue); 10776Assert.False(sizeOfSummary.IsCompileTimeConstant); 10777Assert.False(sizeOfSummary.ConstantValue.HasValue); 11319Assert.False(stackAllocSummary.IsCompileTimeConstant); 11320Assert.False(stackAllocSummary.ConstantValue.HasValue); 11331Assert.False(typeSummary.IsCompileTimeConstant); 11332Assert.False(typeSummary.ConstantValue.HasValue);
Semantics\UseSiteErrorTests.cs (1)
2779Assert.False(s3.IsManagedType(ref managedKindUseSiteInfo));
Semantics\Utf8StringsLiteralsTests.cs (6)
640Assert.False(type.IsSZArray); 2979Assert.False(model.GetConversion(node).Exists); 3035Assert.False(model.GetConversion(node).Exists); 3091Assert.False(model.GetConversion(node).Exists); 3147Assert.False(model.GetConversion(node).Exists); 3203Assert.False(model.GetConversion(node).Exists);
SourceGeneration\GeneratorDriverTests.cs (5)
1144Assert.False(tree.TryGetRoot(out _)); 4175Assert.False(gen1Called); // Generator 1 did not re-run 4527Assert.False(initWasCalled); 4543Assert.False(stepRan); 4554Assert.False(stepRan);
SourceGeneration\GeneratorDriverTests_Attributes_FullyQualifiedName.cs (16)
124Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 971Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1007Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1674Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1721Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1767Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1801Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1813Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1849Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1863Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1902Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1915Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1961Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1978Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 2013Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 2026Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute"));
SourceGeneration\GeneratorDriverTests_Attributes_SimpleName.cs (19)
111Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 136Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 225Assert.False(step.Outputs.Any(o => o.Value is ClassDeclarationSyntax { Identifier.ValueText: "D" })); 256Assert.False(step.Outputs.Any(o => o.Value is ClassDeclarationSyntax { Identifier.ValueText: "C" })); 487Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 514Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 642Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 670Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 698Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 726Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 753Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 780Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 899Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 927Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 1026Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1066Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1206Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 1420Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute")); 1465Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttribute"));
SourceGeneration\SyntaxAwareGeneratorTests.cs (1)
792Assert.False(dType.IsErrorType());
Utilities\ValueSetTests.cs (70)
323Assert.False(none.IsEmpty); 338Assert.False(none.IsEmpty); 359Assert.False(neg.Any(GreaterThan, double.MaxValue)); 366Assert.False(mi.All(GreaterThan, 0.0)); 367Assert.False(mi.Any(GreaterThan, 0.0)); 368Assert.False(mi.All(GreaterThanOrEqual, 0.0)); 369Assert.False(mi.Any(GreaterThanOrEqual, 0.0)); 372Assert.False(i.All(LessThan, 0.0)); 373Assert.False(i.Any(LessThan, 0.0)); 374Assert.False(i.All(LessThanOrEqual, 0.0)); 375Assert.False(i.Any(LessThanOrEqual, 0.0)); 388Assert.False(intersect.Any(Equal, "c")); 423Assert.False(s1.Union(s2).All(Equal, "a")); 447Assert.False(s1.All(GreaterThan, 0)); 448Assert.False(s1.All(GreaterThanOrEqual, 0)); 449Assert.False(s1.All(Equal, 0)); 451Assert.False(s1.All(LessThan, -10)); 452Assert.False(s1.All(LessThanOrEqual, -10)); 453Assert.False(s1.All(GreaterThan, -10)); 454Assert.False(s1.All(GreaterThanOrEqual, -10)); 455Assert.False(s1.All(Equal, -10)); 458Assert.False(s1.All(GreaterThan, 10)); 459Assert.False(s1.All(GreaterThanOrEqual, 10)); 460Assert.False(s1.All(Equal, 10)); 464Assert.False(s2.All(LessThan, -10)); 465Assert.False(s2.All(LessThanOrEqual, -10)); 468Assert.False(s2.All(Equal, -10)); 471Assert.False(s2.All(GreaterThan, 10)); 472Assert.False(s2.All(GreaterThanOrEqual, 10)); 473Assert.False(s2.All(Equal, 10)); 582Assert.False(ForDecimal.Related(LessThan, d).Any(Equal, d)); 584Assert.False(ForDecimal.Related(GreaterThan, d).Any(Equal, d)); 632Assert.False(s1.Any(Equal, value)); 634Assert.False(s2.Any(LessThan, value)); 636Assert.False(s1.Any(GreaterThanOrEqual, value)); 643Assert.False(s1.Any(Equal, value)); 645Assert.False(s2.Any(GreaterThan, value)); 647Assert.False(s1.Any(LessThanOrEqual, value)); 723Assert.False(s1.Any(LessThan, i)); 724Assert.False(s1.Any(LessThan, i - 1)); 727Assert.False(s1.Any(LessThanOrEqual, i - 1)); 728Assert.False(s1.Any(GreaterThan, i + 1)); 729Assert.False(s1.Any(GreaterThan, i)); 731Assert.False(s1.Any(GreaterThanOrEqual, i + 1)); 745Assert.False(s1.Any(LessThan, j)); 746Assert.False(s1.Any(LessThan, j - 1)); 749Assert.False(s1.Any(LessThanOrEqual, j - 1)); 750Assert.False(s1.Any(GreaterThan, j + 1)); 751Assert.False(s1.Any(GreaterThan, j)); 753Assert.False(s1.Any(GreaterThanOrEqual, j + 1)); 767Assert.False(s1.All(LessThan, i - 1)); 771Assert.False(s1.All(LessThanOrEqual, i - 2)); 773Assert.False(s1.All(GreaterThan, i + 1)); 776Assert.False(s1.All(GreaterThanOrEqual, i + 2)); 792Assert.False(s1.All(LessThan, j - 1)); 796Assert.False(s1.All(LessThanOrEqual, j - 2)); 798Assert.False(s1.All(GreaterThan, j + 1)); 801Assert.False(s1.All(GreaterThanOrEqual, j + 2)); 815Assert.False(s1.All(LessThan, i)); 816Assert.False(s1.All(LessThan, i - 1)); 819Assert.False(s1.All(LessThanOrEqual, i - 1)); 820Assert.False(s1.All(GreaterThan, i + 1)); 821Assert.False(s1.All(GreaterThan, i)); 823Assert.False(s1.All(GreaterThanOrEqual, i + 1)); 837Assert.False(s1.All(LessThan, j)); 838Assert.False(s1.All(LessThan, j - 1)); 841Assert.False(s1.All(LessThanOrEqual, j - 1)); 842Assert.False(s1.All(GreaterThan, j + 1)); 843Assert.False(s1.All(GreaterThan, j)); 845Assert.False(s1.All(GreaterThanOrEqual, j + 1));
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (4648)
Compilation\CompilationAPITests.cs (36)
419Assert.False(result.Success); 804Assert.False(comp.SyntaxTrees.Contains(SyntaxFactory.ParseSyntaxTree(s1))); 1498Assert.False(comp.SyntaxTrees.Contains(null)); 1978Assert.False(c1.ReferenceManagerEquals(c2)); 1983Assert.False(c1.ReferenceManagerEquals(c2)); 1986Assert.False(c1.ReferenceManagerEquals(c2)); 1989Assert.False(c1.ReferenceManagerEquals(c2)); 2002Assert.False(c1.ReferenceManagerEquals(c2)); 2014Assert.False(c1.ReferenceManagerEquals(c2)); 2026Assert.False(c1.ReferenceManagerEquals(c2)); 2032Assert.False(c1.ReferenceManagerEquals(c4)); 2044Assert.False(c1.ReferenceManagerEquals(c2)); 2047Assert.False(c3.ReferenceManagerEquals(c2)); 2050Assert.False(c3.ReferenceManagerEquals(c2)); 2053Assert.False(c3.ReferenceManagerEquals(c2)); 2056Assert.False(c3.ReferenceManagerEquals(c2)); 2059Assert.False(c3.ReferenceManagerEquals(c2)); 2093Assert.False(a.ReferenceManagerEquals(ar)); 2104Assert.False(arc.ReferenceManagerEquals(c)); 2110Assert.False(arc.ReferenceManagerEquals(none2)); 2118Assert.False(arc.ReferenceManagerEquals(asc)); 2124Assert.False(arc.ReferenceManagerEquals(abc)); 2127Assert.False(arc.ReferenceManagerEquals(ars)); 2153Assert.False(c5.ReferenceManagerEquals(c4)); 2159Assert.False(c7.ReferenceManagerEquals(c6)); 2162Assert.False(c8.ReferenceManagerEquals(c7)); 2429Assert.False(CSharpCompilation.CreateScriptCompilation("sub").HasSubmissionResult()); 2431Assert.False(CreateSubmission("1;", parseOptions: TestOptions.Script).HasSubmissionResult()); 2432Assert.False(CreateSubmission("void goo() { }", parseOptions: TestOptions.Script).HasSubmissionResult()); 2433Assert.False(CreateSubmission("using System;", parseOptions: TestOptions.Script).HasSubmissionResult()); 2434Assert.False(CreateSubmission("int i;", parseOptions: TestOptions.Script).HasSubmissionResult()); 2435Assert.False(CreateSubmission("System.Console.WriteLine();", parseOptions: TestOptions.Script).HasSubmissionResult()); 2436Assert.False(CreateSubmission("System.Console.WriteLine()", parseOptions: TestOptions.Script).HasSubmissionResult()); 3186Assert.False(script.HasSubmissionResult()); 3214Assert.False(script.HasSubmissionResult()); 3311Assert.False(script.HasSubmissionResult());
Compilation\CSharpCompilationOptionsTests.cs (1)
61Assert.False(newOpt1.Equals(oldOptions));
Compilation\GetSemanticInfoBrokenCodeTests.cs (2)
186Assert.False(member.IsImplicitlyDeclared); 188Assert.False(member.IsImplicitlyDeclared);
Compilation\GetSemanticInfoTests.cs (53)
671Assert.False(conv.Exists); 672Assert.False(conv.IsImplicit); 673Assert.False(conv.IsExplicit); 678Assert.False(conv.IsExplicit); 684Assert.False(conv.IsExplicit); 690Assert.False(conv.IsExplicit); 696Assert.False(conv.IsExplicit); 702Assert.False(conv.IsExplicit); 708Assert.False(conv.IsExplicit); 714Assert.False(conv.IsExplicit); 720Assert.False(conv.IsExplicit); 726Assert.False(conv.IsImplicit); 732Assert.False(conv.IsExplicit); 738Assert.False(conv.IsExplicit); 744Assert.False(conv.IsExplicit); 750Assert.False(conv.IsExplicit); 755Assert.False(conv.IsImplicit); 761Assert.False(conv.IsImplicit); 767Assert.False(conv.IsImplicit); 773Assert.False(conv.IsImplicit); 779Assert.False(conv.IsImplicit); 785Assert.False(conv.IsImplicit); 792Assert.False(conv.IsExplicit); 793Assert.False(conv.IsUserDefined); 799Assert.False(conv.IsExplicit); 800Assert.False(conv.IsUserDefined); 805Assert.False(conv.IsImplicit); 807Assert.False(conv.IsUserDefined); 812Assert.False(conv.IsImplicit); 814Assert.False(conv.IsUserDefined); 819Assert.False(conv.IsImplicit); 821Assert.False(conv.IsUserDefined); 826Assert.False(conv.IsImplicit); 828Assert.False(conv.IsUserDefined); 829Assert.False(conv.IsPointer); 1427Assert.False(bindInfo.IsCompileTimeConstant); 1468Assert.False(bindInfo.IsCompileTimeConstant); 1502Assert.False(bindInfo.IsCompileTimeConstant); 2737Assert.False(model.GetConstantValue(expr).HasValue); 2808Assert.False(model.GetConstantValue(expr).HasValue); 3295Assert.False(sawWrongConversionKind); 3479Assert.False(argConversion.IsValid); 4298Assert.False(info.ConstantValue.HasValue); 4301Assert.False(info.IsCompileTimeConstant); 4789Assert.False(lambda.ReturnsVoid); 4832Assert.False(methodSymbol.ReturnsVoid); 4958Assert.False(symbolInfo.Symbol.Equals(null)); 5406Assert.False(type.IsGenericType); 5407Assert.False(type.IsErrorType()); 5412Assert.False(type.IsGenericType); 5419Assert.False(type.IsErrorType()); 5993Assert.False(foreachSymbolInfo.CurrentConversion.IsImplicit); 6047Assert.False(symbol.IsReferenceType);
Compilation\ReferenceManagerTests.cs (4)
910Assert.False(dr1.Properties.EmbedInteropTypes); 911Assert.False(dr2.Properties.EmbedInteropTypes); 912Assert.False(dr3.Properties.EmbedInteropTypes); 1458Assert.False(withCircularReference1.ReferenceManagerEquals(withCircularReference2));
Compilation\SemanticModelAPITests.cs (25)
338Assert.False(ReferenceEquals(symbol1, symbol2)); 1414Assert.False(model.IsSpeculativeSemanticModel); 1468Assert.False(speculativeModel.IgnoresAccessibility); 1673Assert.False(model.IsSpeculativeSemanticModel); 2020Assert.False(model.IsSpeculativeSemanticModel); 2147Assert.False(success); 2321Assert.False(success); 2698Assert.False(model.IsSpeculativeSemanticModel); 2706Assert.False(speculativeModel.IgnoresAccessibility); 3095Assert.False(success); 3098Assert.False(success); 3658Assert.False(((NamedTypeSymbol)newSymbol).TypeArguments().Single().IsErrorType()); 3955Assert.False(value1.HasValue); 3962Assert.False(value2.HasValue); 4141Assert.False(model.GetConstantValue(actual[1]).HasValue); 4182Assert.False(model.GetConstantValue(actual[2]).HasValue); 4222Assert.False(model.GetConstantValue(actual[1]).HasValue); 4317Assert.False(model.GetConstantValue(actual[2]).HasValue); 4414Assert.False(semanticModel.IsAccessible(positionInN, fieldY)); 4415Assert.False(semanticModel.IsAccessible(positionInN, fieldZ)); 4423Assert.False(semanticModel.IsAccessible(positionInCGoo, fieldY)); 4424Assert.False(semanticModel.IsAccessible(positionInCGoo, fieldZ)); 4541Assert.False(symbolInfo.IsEmpty); 4619Assert.False(symbolInfo.IsEmpty); 4637Assert.False(alias1.Equals(alias2));
Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (13)
4010Assert.False(boundType.IsUnboundGenericType()); 4016Assert.False(boundType.IsUnboundGenericType()); 4028Assert.False(boundType.IsUnboundGenericType()); 4034Assert.False(boundType.IsUnboundGenericType()); 4051Assert.False(boundType.IsUnboundGenericType()); 4057Assert.False(boundType.IsUnboundGenericType()); 4063Assert.False(boundType.IsUnboundGenericType()); 4672Assert.False(model.IsEventUsableAsField(enclosingTypePosition, fieldLikeEvent)); 4675Assert.False(model.IsEventUsableAsField(otherTypePosition, fieldLikeEvent)); 4677Assert.False(model.IsEventUsableAsField(enclosingTypePosition, customEvent)); 4678Assert.False(model.IsEventUsableAsField(declaringTypePosition, customEvent)); 4679Assert.False(model.IsEventUsableAsField(nestedTypePosition, customEvent)); 4680Assert.False(model.IsEventUsableAsField(otherTypePosition, customEvent));
Compilation\SemanticModelGetSemanticInfoTests.cs (311)
65Assert.False(semanticInfo.IsCompileTimeConstant); 96Assert.False(semanticInfo.IsCompileTimeConstant); 130Assert.False(semanticInfo.IsCompileTimeConstant); 164Assert.False(semanticInfo.IsCompileTimeConstant); 205Assert.False(semanticInfo.IsCompileTimeConstant); 246Assert.False(semanticInfo.IsCompileTimeConstant); 281Assert.False(semanticInfo.IsCompileTimeConstant); 318Assert.False(semanticInfo.IsCompileTimeConstant); 471Assert.False(semanticInfo.IsCompileTimeConstant); 511Assert.False(semanticInfo.IsCompileTimeConstant); 556Assert.False(semanticInfo.IsCompileTimeConstant); 604Assert.False(semanticInfo.IsCompileTimeConstant); 652Assert.False(semanticInfo.IsCompileTimeConstant); 705Assert.False(semanticInfo.IsCompileTimeConstant); 735Assert.False(semanticInfo.IsCompileTimeConstant); 769Assert.False(semanticInfo.IsCompileTimeConstant); 806Assert.False(semanticInfo.IsCompileTimeConstant); 1649Assert.False(semanticInfo.IsCompileTimeConstant); 1693Assert.False(semanticInfo.IsCompileTimeConstant); 1725Assert.False(semanticInfo.IsCompileTimeConstant); 1784Assert.False(semanticInfo.IsCompileTimeConstant); 1903Assert.False(semanticInfo.IsCompileTimeConstant); 1932Assert.False(semanticInfo.IsCompileTimeConstant); 1962Assert.False(semanticInfo.IsCompileTimeConstant); 1992Assert.False(semanticInfo.IsCompileTimeConstant); 2022Assert.False(semanticInfo.IsCompileTimeConstant); 2054Assert.False(semanticInfo.IsCompileTimeConstant); 2086Assert.False(semanticInfo.IsCompileTimeConstant); 2124Assert.False(semanticInfo.IsCompileTimeConstant); 2157Assert.False(semanticInfo.IsCompileTimeConstant); 2197Assert.False(semanticInfo.IsCompileTimeConstant); 2224Assert.False(semanticInfo.IsCompileTimeConstant); 2269Assert.False(semanticInfo.IsCompileTimeConstant); 2304Assert.False(semanticInfo.IsCompileTimeConstant); 2354Assert.False(semanticInfo.IsCompileTimeConstant); 2400Assert.False(semanticInfo.IsCompileTimeConstant); 2443Assert.False(semanticInfo.IsCompileTimeConstant); 2498Assert.False(semanticInfo.IsCompileTimeConstant); 2550Assert.False(semanticInfo.IsCompileTimeConstant); 2583Assert.False(semanticInfo.IsCompileTimeConstant); 2618Assert.False(semanticInfo.IsCompileTimeConstant); 2658Assert.False(semanticInfo.IsCompileTimeConstant); 2701Assert.False(semanticInfo.IsCompileTimeConstant); 2745Assert.False(semanticInfo.IsCompileTimeConstant); 2795Assert.False(semanticInfo.IsCompileTimeConstant); 2838Assert.False(semanticInfo.IsCompileTimeConstant); 2876Assert.False(semanticInfo.IsCompileTimeConstant); 2915Assert.False(semanticInfo.IsCompileTimeConstant); 3078Assert.False(semanticInfo.IsCompileTimeConstant); 3123Assert.False(semanticInfo.IsCompileTimeConstant); 3165Assert.False(semanticInfo.IsCompileTimeConstant); 3208Assert.False(semanticInfo.IsCompileTimeConstant); 3253Assert.False(semanticInfo.IsCompileTimeConstant); 3292Assert.False(semanticInfo.IsCompileTimeConstant); 3328Assert.False(semanticInfo.IsCompileTimeConstant); 3365Assert.False(semanticInfo.IsCompileTimeConstant); 3400Assert.False(semanticInfo.IsCompileTimeConstant); 3431Assert.False(semanticInfo.IsCompileTimeConstant); 3498Assert.False(semanticInfo.IsCompileTimeConstant); 3532Assert.False(semanticInfo.IsCompileTimeConstant); 3561Assert.False(semanticInfo.IsCompileTimeConstant); 3595Assert.False(semanticInfo.IsCompileTimeConstant); 3633Assert.False(semanticInfo.IsCompileTimeConstant); 3677Assert.False(semanticInfo.IsCompileTimeConstant); 3711Assert.False(semanticInfo.IsCompileTimeConstant); 3745Assert.False(semanticInfo.IsCompileTimeConstant); 3779Assert.False(semanticInfo.IsCompileTimeConstant); 3809Assert.False(semanticInfo.IsCompileTimeConstant); 3843Assert.False(semanticInfo.IsCompileTimeConstant); 3871Assert.False(semanticInfo.IsCompileTimeConstant); 3905Assert.False(semanticInfo.IsCompileTimeConstant); 3978Assert.False(semanticInfo.IsCompileTimeConstant); 4013Assert.False(semanticInfo.IsCompileTimeConstant); 4044Assert.False(semanticInfo.IsCompileTimeConstant); 4079Assert.False(semanticInfo.IsCompileTimeConstant); 4112Assert.False(semanticInfo.IsCompileTimeConstant); 4141Assert.False(semanticInfo.IsCompileTimeConstant); 4165Assert.False(semanticInfo.IsCompileTimeConstant); 4191Assert.False(semanticInfo.IsCompileTimeConstant); 4222Assert.False(semanticInfo.IsCompileTimeConstant); 4254Assert.False(semanticInfo.IsCompileTimeConstant); 4291Assert.False(semanticInfo.IsCompileTimeConstant); 4324Assert.False(semanticInfo.IsCompileTimeConstant); 4378Assert.False(semanticInfo.IsCompileTimeConstant); 4415Assert.False(semanticInfo.IsCompileTimeConstant); 4453Assert.False(semanticInfo.IsCompileTimeConstant); 4480Assert.False(semanticInfo.IsCompileTimeConstant); 4581Assert.False(symbol.IsForEach); 4582Assert.False(symbol.IsUsing); 4649Assert.False(semanticInfo.IsCompileTimeConstant); 4717Assert.False(semanticInfo.IsCompileTimeConstant); 4723Assert.False(symbol.HasConstantValue); 4753Assert.False(semanticInfo.IsCompileTimeConstant); 4759Assert.False(symbol.HasConstantValue); 4789Assert.False(semanticInfo.IsCompileTimeConstant); 4795Assert.False(symbol.HasConstantValue); 4857Assert.False(semanticInfo.IsCompileTimeConstant); 4885Assert.False(semanticInfo.IsCompileTimeConstant); 4931Assert.False(semanticInfo.IsCompileTimeConstant); 4984Assert.False(semanticInfo.IsCompileTimeConstant); 5036Assert.False(semanticInfo.IsCompileTimeConstant); 5073Assert.False(semanticInfo.IsCompileTimeConstant); 5120Assert.False(semanticInfo.IsCompileTimeConstant); 5166Assert.False(semanticInfo.IsCompileTimeConstant); 5208Assert.False(semanticInfo.IsCompileTimeConstant); 5245Assert.False(semanticInfo.IsCompileTimeConstant); 5287Assert.False(semanticInfo.IsCompileTimeConstant); 5329Assert.False(semanticInfo.IsCompileTimeConstant); 5414Assert.False(semanticInfo.IsCompileTimeConstant); 5457Assert.False(semanticInfo.IsCompileTimeConstant); 5486Assert.False(semanticInfo.IsCompileTimeConstant); 5515Assert.False(semanticInfo.IsCompileTimeConstant); 5548Assert.False(semanticInfo.IsCompileTimeConstant); 5668Assert.False(semanticInfo.IsCompileTimeConstant); 5704Assert.False(semanticInfo.IsCompileTimeConstant); 5734Assert.False(semanticInfo.IsCompileTimeConstant); 5801Assert.False(semanticInfo.IsCompileTimeConstant); 5868Assert.False(semanticInfo.IsCompileTimeConstant); 5937Assert.False(semanticInfo.IsCompileTimeConstant); 6004Assert.False(semanticInfo.IsCompileTimeConstant); 6097Assert.False(semanticInfo.IsCompileTimeConstant); 6123Assert.False(semanticInfo.IsCompileTimeConstant); 6150Assert.False(semanticInfo.IsCompileTimeConstant); 6183Assert.False(semanticInfo.IsCompileTimeConstant); 6335Assert.False(semanticInfo.IsCompileTimeConstant); 6377Assert.False(semanticInfo.IsCompileTimeConstant); 6407Assert.False(semanticInfo.IsCompileTimeConstant); 6445Assert.False(semanticInfo.IsCompileTimeConstant); 6468Assert.False(semanticInfo.ImplicitConversion.IsExtensionMethod); 6525Assert.False(semanticInfo.IsCompileTimeConstant); 6560Assert.False(semanticInfo.IsCompileTimeConstant); 6597Assert.False(semanticInfo.IsCompileTimeConstant); 6647Assert.False(semanticInfo.IsCompileTimeConstant); 6685Assert.False(semanticInfo.IsCompileTimeConstant); 6735Assert.False(semanticInfo.IsCompileTimeConstant); 6755Assert.False(semanticInfo.IsCompileTimeConstant); 6881Assert.False(semanticInfo.IsCompileTimeConstant); 6926Assert.False(semanticInfo.IsCompileTimeConstant); 7053Assert.False(semanticInfo.IsCompileTimeConstant); 7086Assert.False(semanticInfo.IsCompileTimeConstant); 7114Assert.False(semanticInfo.IsCompileTimeConstant); 7145Assert.False(semanticInfo.IsCompileTimeConstant); 7175Assert.False(semanticInfo.IsCompileTimeConstant); 7207Assert.False(semanticInfo.IsCompileTimeConstant); 7239Assert.False(semanticInfo.IsCompileTimeConstant); 7268Assert.False(semanticInfo.IsCompileTimeConstant); 7295Assert.False(semanticInfo.IsCompileTimeConstant); 7322Assert.False(semanticInfo.IsCompileTimeConstant); 7378Assert.False(semanticInfo.IsCompileTimeConstant); 7431Assert.False(semanticInfo.IsCompileTimeConstant); 7459Assert.False(semanticInfo.IsCompileTimeConstant); 7482Assert.False(semanticInfo.ImplicitConversion.IsIdentity); 7526Assert.False(semanticInfo.IsCompileTimeConstant); 7558Assert.False(semanticInfo.IsCompileTimeConstant); 7596Assert.False(semanticInfo.IsCompileTimeConstant); 7629Assert.False(semanticInfo.IsCompileTimeConstant); 7666Assert.False(semanticInfo.IsCompileTimeConstant); 7824Assert.False(semanticInfo.IsCompileTimeConstant); 7857Assert.False(semanticInfo.IsCompileTimeConstant); 7889Assert.False(semanticInfo.IsCompileTimeConstant); 7923Assert.False(semanticInfo.IsCompileTimeConstant); 7955Assert.False(semanticInfo.IsCompileTimeConstant); 7989Assert.False(semanticInfo.IsCompileTimeConstant); 8026Assert.False(semanticInfo.IsCompileTimeConstant); 8043Assert.False(semanticInfo.IsCompileTimeConstant); 8079Assert.False(semanticInfo.IsCompileTimeConstant); 8096Assert.False(semanticInfo.IsCompileTimeConstant); 8380Assert.False(semanticInfo.IsCompileTimeConstant); 8414Assert.False(semanticInfo.IsCompileTimeConstant); 8611Assert.False(semanticInfo.IsCompileTimeConstant); 8650Assert.False(semanticInfo.IsCompileTimeConstant); 8692Assert.False(semanticInfo.IsCompileTimeConstant); 8899Assert.False(semanticInfo.IsCompileTimeConstant); 9070Assert.False(semanticInfo.IsCompileTimeConstant); 9132Assert.False(semanticInfo.IsCompileTimeConstant); 9156Assert.False((type as INamedTypeSymbol).IsErrorType()); 9180Assert.False((type as INamedTypeSymbol).IsErrorType()); 9207Assert.False((type as INamedTypeSymbol).IsUnboundGenericType); 9208Assert.False((type as INamedTypeSymbol).IsErrorType()); 9233Assert.False((type as INamedTypeSymbol).IsErrorType()); 9263Assert.False(type.IsErrorType()); 9272Assert.False(constructedFrom.TypeArguments[0].IsErrorType()); 9274Assert.False(constructedFrom.IsUnboundGenericType); 9284Assert.False(a.ConstructedFrom.IsUnboundGenericType); 9369Assert.False(semanticInfo.IsCompileTimeConstant); 9428Assert.False(semanticInfo.IsCompileTimeConstant); 9472Assert.False(semanticInfo.IsCompileTimeConstant); 9501Assert.False(semanticInfo.IsCompileTimeConstant); 9625Assert.False(semanticInfo.IsCompileTimeConstant); 9676Assert.False(semanticInfo.IsCompileTimeConstant); 9727Assert.False(semanticInfo.IsCompileTimeConstant); 9791Assert.False(semanticInfo.IsCompileTimeConstant); 9842Assert.False(semanticInfo.IsCompileTimeConstant); 9897Assert.False(semanticInfo.IsCompileTimeConstant); 9925Assert.False(semanticInfo.IsCompileTimeConstant); 9961Assert.False(semanticInfo.IsCompileTimeConstant); 9997Assert.False(semanticInfo.IsCompileTimeConstant); 10033Assert.False(semanticInfo.IsCompileTimeConstant); 10069Assert.False(semanticInfo.IsCompileTimeConstant); 10109Assert.False(semanticInfo.IsCompileTimeConstant); 10146Assert.False(semanticInfo.IsCompileTimeConstant); 10188Assert.False(semanticInfo.IsCompileTimeConstant); 10227Assert.False(semanticInfo.IsCompileTimeConstant); 10258Assert.False(semanticInfo.IsCompileTimeConstant); 10293Assert.False(semanticInfo.IsCompileTimeConstant); 10328Assert.False(semanticInfo.IsCompileTimeConstant); 10362Assert.False(semanticInfo.IsCompileTimeConstant); 10396Assert.False(semanticInfo.IsCompileTimeConstant); 10474Assert.False(semanticInfo.IsCompileTimeConstant); 10502Assert.False(semanticInfo.IsCompileTimeConstant); 10532Assert.False(semanticInfo.IsCompileTimeConstant); 10566Assert.False(semanticInfo.IsCompileTimeConstant); 10609Assert.False(semanticInfo.IsCompileTimeConstant); 10646Assert.False(semanticInfo.IsCompileTimeConstant); 10683Assert.False(semanticInfo.IsCompileTimeConstant); 10722Assert.False(semanticInfo.IsCompileTimeConstant); 10765Assert.False(semanticInfo.IsCompileTimeConstant); 10807Assert.False(semanticInfo.IsCompileTimeConstant); 10846Assert.False(semanticInfo.IsCompileTimeConstant); 10910Assert.False(semanticInfo.IsCompileTimeConstant); 11161Assert.False(semanticInfo.IsCompileTimeConstant); 11194Assert.False(semanticInfo.IsCompileTimeConstant); 11236Assert.False(semanticInfo.IsCompileTimeConstant); 11433Assert.False(semanticInfo.IsCompileTimeConstant); 11546Assert.False(semanticInfo.IsCompileTimeConstant); 11581Assert.False(semanticInfo.IsCompileTimeConstant); 11615Assert.False(semanticInfo.IsCompileTimeConstant); 11648Assert.False(aliasInfo.IsExtern); 11650Assert.False(semanticInfo.IsCompileTimeConstant); 11682Assert.False(aliasInfo.IsExtern); 11684Assert.False(semanticInfo.IsCompileTimeConstant); 11765Assert.False(semanticInfo.IsCompileTimeConstant); 11801Assert.False(semanticInfo.IsCompileTimeConstant); 11837Assert.False(semanticInfo.IsCompileTimeConstant); 11872Assert.False(semanticInfo.IsCompileTimeConstant); 11907Assert.False(semanticInfo.IsCompileTimeConstant); 11943Assert.False(semanticInfo.IsCompileTimeConstant); 11979Assert.False(semanticInfo.IsCompileTimeConstant); 12014Assert.False(semanticInfo.IsCompileTimeConstant); 12049Assert.False(semanticInfo.IsCompileTimeConstant); 12085Assert.False(semanticInfo.IsCompileTimeConstant); 12159Assert.False(semanticInfo.IsCompileTimeConstant); 12192Assert.False(semanticInfo.IsCompileTimeConstant); 12228Assert.False(semanticInfo.IsCompileTimeConstant); 12263Assert.False(semanticInfo.IsCompileTimeConstant); 12296Assert.False(semanticInfo.IsCompileTimeConstant); 12329Assert.False(semanticInfo.IsCompileTimeConstant); 12459Assert.False(semanticInfo.IsCompileTimeConstant); 12490Assert.False(semanticInfo.IsCompileTimeConstant); 12533Assert.False(semanticInfo.IsCompileTimeConstant); 12572Assert.False(semanticInfo.IsCompileTimeConstant); 12616Assert.False(semanticInfo.IsCompileTimeConstant); 12650Assert.False(semanticInfo.IsCompileTimeConstant); 12683Assert.False(semanticInfo.IsCompileTimeConstant); 12713Assert.False(semanticInfo.IsCompileTimeConstant); 12745Assert.False(semanticInfo.IsCompileTimeConstant); 12777Assert.False(semanticInfo.IsCompileTimeConstant); 12809Assert.False(semanticInfo.IsCompileTimeConstant); 12852Assert.False(semanticInfo.IsCompileTimeConstant); 12889Assert.False(semanticInfo.IsCompileTimeConstant); 12928Assert.False(semanticInfo.IsCompileTimeConstant); 12967Assert.False(semanticInfo.IsCompileTimeConstant); 13005Assert.False(semanticInfo.IsCompileTimeConstant); 13046Assert.False(semanticInfo.IsCompileTimeConstant); 13074Assert.False(semanticInfo.IsCompileTimeConstant); 13104Assert.False(semanticInfo.IsCompileTimeConstant); 13138Assert.False(semanticInfo.IsCompileTimeConstant); 13172Assert.False(semanticInfo.IsCompileTimeConstant); 13206Assert.False(semanticInfo.IsCompileTimeConstant); 13239Assert.False(semanticInfo.IsCompileTimeConstant); 13269Assert.False(semanticInfo.IsCompileTimeConstant); 13330Assert.False(semanticInfo.IsCompileTimeConstant); 13388Assert.False(semanticInfo.IsCompileTimeConstant); 13509Assert.False(semanticInfo.IsCompileTimeConstant); 13567Assert.False(semanticInfo.IsCompileTimeConstant); 13597Assert.False(semanticInfo.IsCompileTimeConstant); 13662Assert.False(semanticInfo.IsCompileTimeConstant); 13691Assert.False(semanticInfo.IsCompileTimeConstant); 13747Assert.False(semanticInfo.IsCompileTimeConstant); 13780Assert.False(semanticInfo.IsCompileTimeConstant); 13811Assert.False(semanticInfo.IsCompileTimeConstant); 13845Assert.False(semanticInfo.IsCompileTimeConstant); 13884Assert.False(semanticInfo.IsCompileTimeConstant); 13923Assert.False(semanticInfo.IsCompileTimeConstant); 13957Assert.False(semanticInfo.IsCompileTimeConstant); 13984Assert.False(semanticInfo.IsCompileTimeConstant); 14011Assert.False(semanticInfo.IsCompileTimeConstant); 14048Assert.False(semanticInfo.IsCompileTimeConstant); 14087Assert.False(semanticInfo.IsCompileTimeConstant); 14126Assert.False(semanticInfo.IsCompileTimeConstant); 14165Assert.False(semanticInfo.IsCompileTimeConstant); 14207Assert.False(semanticInfo.IsCompileTimeConstant); 14253Assert.False(semanticInfo.IsCompileTimeConstant); 14297Assert.False(semanticInfo.IsCompileTimeConstant); 14347Assert.False(semanticInfo.IsCompileTimeConstant); 14387Assert.False(semanticInfo.IsCompileTimeConstant); 14427Assert.False(semanticInfo.IsCompileTimeConstant); 14516Assert.False(semanticInfo.IsCompileTimeConstant); 14548Assert.False(semanticInfo.IsCompileTimeConstant); 14632Assert.False(semanticInfo.IsCompileTimeConstant); 14673Assert.False(semanticInfo.IsCompileTimeConstant); 15090Assert.False(semanticInfo.IsCompileTimeConstant); 15127Assert.False(semanticInfo.IsCompileTimeConstant); 15158Assert.False(semanticInfo.IsCompileTimeConstant); 15189Assert.False(semanticInfo.IsCompileTimeConstant); 15220Assert.False(semanticInfo.IsCompileTimeConstant); 15251Assert.False(semanticInfo.IsCompileTimeConstant); 15282Assert.False(semanticInfo.IsCompileTimeConstant); 15309Assert.False(semanticInfo.IsCompileTimeConstant); 15344Assert.False(semanticInfo.IsCompileTimeConstant); 15411Assert.False(semanticInfo.IsCompileTimeConstant);
Compilation\SemanticModelGetSemanticInfoTests_LateBound.cs (24)
45Assert.False(semanticInfo.IsCompileTimeConstant); 91Assert.False(semanticInfo.IsCompileTimeConstant); 122Assert.False(semanticInfo.IsCompileTimeConstant); 148Assert.False(semanticInfo.IsCompileTimeConstant); 174Assert.False(semanticInfo.IsCompileTimeConstant); 209Assert.False(semanticInfo.IsCompileTimeConstant); 233Assert.False(semanticInfo.IsCompileTimeConstant); 273Assert.False(semanticInfo.IsCompileTimeConstant); 296Assert.False(semanticInfo.IsCompileTimeConstant); 325Assert.False(semanticInfo.IsCompileTimeConstant); 354Assert.False(semanticInfo.IsCompileTimeConstant); 434Assert.False(semanticInfo.IsCompileTimeConstant); 525Assert.False(semanticInfo.IsCompileTimeConstant); 560Assert.False(semanticInfo.IsCompileTimeConstant); 594Assert.False(semanticInfo.IsCompileTimeConstant); 622Assert.False(semanticInfo.IsCompileTimeConstant); 659Assert.False(semanticInfo.IsCompileTimeConstant); 686Assert.False(semanticInfo.IsCompileTimeConstant); 722Assert.False(semanticInfo.IsCompileTimeConstant); 752Assert.False(semanticInfo.IsCompileTimeConstant); 778Assert.False(semanticInfo.IsCompileTimeConstant); 805Assert.False(semanticInfo.IsCompileTimeConstant); 833Assert.False(semanticInfo.IsCompileTimeConstant); 864Assert.False(semanticInfo.IsCompileTimeConstant);
CrossLanguageTests.cs (1)
39Assert.False(t.GetMembersUnordered().Where(x => x.Kind == SymbolKind.Property).First().CanBeReferencedByName); //there's only one.
DocumentationComments\CrefTests.cs (6)
1667Assert.False(actualWinner.IsDefinition); 1705Assert.False(actualWinner.IsDefinition); 3013Assert.False(actualTypeA.IsDefinition); 3025Assert.False(actualTypeB.IsDefinition); 3040Assert.False(actualMethod.IsDefinition); 5853Assert.False(symbol.IsDefinition);
DocumentationComments\DocumentationCommentCompilerTests.cs (1)
4407Assert.False(XmlCharType.IsWhiteSpace(ch));
SymbolDisplay\SymbolDisplayTests.cs (18)
5162Assert.False(type is Symbol); 5163Assert.False(method is Symbol); 5164Assert.False(property is Symbol); 5165Assert.False(field is Symbol); 5166Assert.False(@event is Symbol); 5167Assert.False(@delegate is Symbol); 5168Assert.False(error is Symbol); 5431Assert.False(new FormattedSymbol(sA, f1).Equals((object)sA)); 5432Assert.False(new FormattedSymbol(sA, f1).Equals(null)); 5435Assert.False(new FormattedSymbol(sA, f1).Equals(new FormattedSymbol(sA, f2))); 5436Assert.False(new FormattedSymbol(sA, f1).Equals(new FormattedSymbol(sB, f1))); 5437Assert.False(new FormattedSymbol(sA, f1).Equals(new FormattedSymbol(sB, f2))); 5439Assert.False(new FormattedSymbol(sC, f1).Equals(new FormattedSymbol(sC.Construct(sA), f1))); 5442Assert.False(new FormattedSymbol(sA, new SymbolDisplayFormat()).Equals(new FormattedSymbol(sA, new SymbolDisplayFormat()))); 6437Assert.False(formatWithoutAllowDefaultLiteral.MiscellaneousOptions.IncludesOption(SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral)); 6564Assert.False(formatWithoutAllowDefaultLiteral.MiscellaneousOptions.IncludesOption(SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral)); 6608Assert.False(formatWithoutAllowDefaultLiteral.MiscellaneousOptions.IncludesOption(SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral)); 6970Assert.False(local.IsRef);
Symbols\AccessorOverriddenOrHiddenMembersTests.cs (2)
326Assert.False(compilation.GetDiagnostics().Any()); 359Assert.False(compilation.GetDiagnostics().Any());
Symbols\AnonymousTypesSemanticsTests.cs (2)
81Assert.False(((INamedTypeSymbol)info0.Type).IsSerializable); 1989Assert.False(type.CanBeReferencedByName);
Symbols\AnonymousTypesSymbolTests.cs (13)
1026Assert.False(type.IsStatic); 1097Assert.False(property.IsAbstract); 1098Assert.False(property.IsIndexer); 1099Assert.False(property.IsOverride); 1101Assert.False(property.IsStatic); 1102Assert.False(property.IsSealed); 1103Assert.False(property.IsVirtual); 1104Assert.False(property.IsWriteOnly); 1127Assert.False(method.IsAbstract); 1129Assert.False(method.IsStatic); 1130Assert.False(method.IsSealed); 1131Assert.False(method.IsVararg); 1132Assert.False(method.IsVirtual);
Symbols\AssemblyAndNamespaceTests.cs (11)
39Assert.False(sym.IsStatic); 40Assert.False(sym.IsVirtual); 41Assert.False(sym.IsOverride); 42Assert.False(sym.IsAbstract); 43Assert.False(sym.IsSealed); 44Assert.False(sym.IsExtern); 66Assert.False(sym.IsStatic); 67Assert.False(sym.IsVirtual); 68Assert.False(sym.IsOverride); 69Assert.False(sym.IsAbstract); 70Assert.False(sym.IsSealed);
Symbols\CheckedUserDefinedOperatorsTests.cs (3)
59Assert.False(opSymbol.HasRuntimeSpecialName); 1301Assert.False(opSymbol.HasRuntimeSpecialName); 2535Assert.False(opSymbol.HasRuntimeSpecialName);
Symbols\CompilationCreationTests.cs (37)
89Assert.False(type.IsErrorType()); 2355Assert.False(x1.HasExplicitDefaultValue); 2356Assert.False(x1.IsOptional); 2376Assert.False(foo2.HidesBaseMethodsByName); 2377Assert.False(foo2.IsAbstract); 2378Assert.False(foo2.IsExtern); 2379Assert.False(foo2.IsGenericMethod); 2380Assert.False(foo2.IsOverride); 2381Assert.False(foo2.IsSealed); 2382Assert.False(foo2.IsStatic); 2383Assert.False(foo2.IsVararg); 2384Assert.False(foo2.IsVirtual); 2390Assert.False(bar.ReturnsVoid); 2442Assert.False(type3.IsAbstract); 2445Assert.False(type3.IsSealed); 2446Assert.False(type3.IsStatic); 2472Assert.False(foo3TypeParam.HasConstructorConstraint); 2476Assert.False(foo3TypeParam.HasReferenceTypeConstraint); 2477Assert.False(foo3TypeParam.HasValueTypeConstraint); 2503Assert.False(ns1.IsGlobalNamespace); 2619Assert.False(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32")); 2622Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Linq.Enumerable")); 2625Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Uri")); 2627Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Linq.Enumerable")); 2630Assert.False(HasSingleTypeOfKind(c, TypeKind.Class, "System.Uri")); 2633Assert.False(HasSingleTypeOfKind(c, TypeKind.Struct, "System.Int32")); 3009Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.ByRefFields)); 3010Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.CovariantReturnsOfClasses)); 3011Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 3012Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.UnmanagedSignatureCallingConvention)); 3013Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 3014Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.DefaultImplementationsOfInterfaces)); 3017Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.ByRefFields)); 3019Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 3021Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 3025Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.ByRefFields)); 3027Assert.False(compilation.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr));
Symbols\ConversionTests.cs (12)
247Assert.False(f1Type.Equals(f2Type)); 253Assert.False(f3Type.Equals(f4Type)); 256Assert.False(f4Type.Equals(f5Type, TypeCompareKind.AllIgnoreOptions)); 257Assert.False(f5Type.Equals(f4Type, TypeCompareKind.AllIgnoreOptions)); 259Assert.False(f6Type.Equals(f7Type)); 260Assert.False(f6Type.Equals(f8Type)); 261Assert.False(f7Type.Equals(f8Type)); 275Assert.False(f9Type.Equals(f10Type, TypeCompareKind.AllIgnoreOptions)); 276Assert.False(f10Type.Equals(f9Type, TypeCompareKind.AllIgnoreOptions)); 278Assert.False(g1Type.Equals(g2Type)); 410Assert.False(conversion.Exists); 422Assert.False(conversion.Exists);
Symbols\CorLibrary\Choosing.cs (1)
43Assert.False(obj.IsErrorType());
Symbols\CorLibrary\CorTypes.cs (6)
104Assert.False(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 133Assert.False(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 179Assert.False(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 231Assert.False(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 298Assert.False(comp.GetSpecialType(InternalSpecialType.System_Type).IsErrorType()); 435Assert.False(comp.GetSpecialType(InternalSpecialType.System_Type).IsErrorType());
Symbols\CovariantReturnTests.cs (12)
264Assert.False(method.IsVirtual); 322Assert.False(setMethod.IsMetadataNewSlot(ignoreInterfaceImplementationChanges: true)); 323Assert.False(setMethod.RequiresExplicitOverride(out _)); 4359Assert.False(shouldWarn); 4600Assert.False(shouldWarn); 4648Assert.False(shouldWarn); 4696Assert.False(shouldWarn); 4759Assert.False(shouldWarn); 4822Assert.False(shouldWarn); 4879Assert.False(shouldWarn); 4943Assert.False(shouldWarn); 5007Assert.False(shouldWarn);
Symbols\CSharpCompilerFeatureRequiredTests.cs (22)
149Assert.False(onMethod!.HasUnsupportedMetadata); 153Assert.False(onMethodReturn!.HasUnsupportedMetadata); 157Assert.False(onParameter!.HasUnsupportedMetadata); 163Assert.False(onField!.HasUnsupportedMetadata); 167Assert.False(onProperty!.HasUnsupportedMetadata); 171Assert.False(onPropertyGetter!.HasUnsupportedMetadata); 173Assert.False(onPropertyGetterProperty.HasUnsupportedMetadata); 174Assert.False(onPropertyGetterProperty.SetMethod.HasUnsupportedMetadata); 178Assert.False(onPropertySetter!.HasUnsupportedMetadata); 180Assert.False(onPropertySetterProperty.HasUnsupportedMetadata); 182Assert.False(onPropertySetterProperty.GetMethod.HasUnsupportedMetadata); 185Assert.False(onEvent!.HasUnsupportedMetadata); 189Assert.False(onEventAdder!.HasUnsupportedMetadata); 191Assert.False(onEventAdderEvent.HasUnsupportedMetadata); 193Assert.False(onEventAdderEvent.RemoveMethod!.HasUnsupportedMetadata); 196Assert.False(onEventRemover!.HasUnsupportedMetadata); 198Assert.False(onEventRemoverEvent.HasUnsupportedMetadata); 199Assert.False(onEventRemoverEvent.AddMethod!.HasUnsupportedMetadata); 206Assert.False(onEnumMember!.HasUnsupportedMetadata); 214Assert.False(onMethodTypeParameter!.HasUnsupportedMetadata); 223Assert.False(onIndexedPropertyParameter!.HasUnsupportedMetadata); 228Assert.False(onThisParameterIndexer!.HasUnsupportedMetadata);
Symbols\CustomModifiersTests.cs (5)
297Assert.False(HasTypeArgumentsCustomModifiers(withoutModifiers)); 2485Assert.False(t1.Equals(t2, TypeCompareKind.ConsiderEverything)); 2486Assert.False(t2.Equals(t1, TypeCompareKind.ConsiderEverything)); 2487Assert.False(t1.Type.Equals(t2.Type)); 2488Assert.False(t2.Type.Equals(t1.Type));
Symbols\DefaultInterfaceImplementationTests.cs (1943)
204Assert.False(m1.IsAbstract); 206Assert.False(m1.IsSealed); 208Assert.False(m1.IsExtern); 209Assert.False(m1.IsAsync); 210Assert.False(m1.IsOverride); 1593Assert.False(m1.IsAbstract); 1750Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 1784Assert.False(m1.IsAbstract); 1881Assert.False(m1.IsAbstract); 1979Assert.False(m1.IsAbstract); 2024Assert.False(m1.IsAbstract); 2025Assert.False(m1.IsVirtual); 2039Assert.False(m1.IsMetadataVirtual()); 2112Assert.False(m1.IsAbstract); 2131Assert.False(result.IsAbstract); 2694Assert.False(accessor.IsAbstract); 2697Assert.False(accessor.IsSealed); 2699Assert.False(accessor.IsExtern); 2700Assert.False(accessor.IsAsync); 2701Assert.False(accessor.IsOverride); 2705Assert.False(p1.IsAbstract); 2707Assert.False(p1.IsSealed); 2709Assert.False(p1.IsExtern); 2710Assert.False(p1.IsOverride); 2994Assert.False(p1.IsVirtual); 2995Assert.False(p1.IsStatic); 3030Assert.False(p1.IsVirtual); 3065Assert.False(p1.IsAbstract); 3100Assert.False(p1.IsReadOnly); 3101Assert.False(p1.IsWriteOnly); 3125Assert.False(p1.IsReadOnly); 3126Assert.False(p1.IsWriteOnly); 3150Assert.False(p1.IsReadOnly); 3151Assert.False(p1.IsWriteOnly); 3287Assert.False(p1.IsReadOnly); 3288Assert.False(p1.IsWriteOnly); 3312Assert.False(p1.IsReadOnly); 3313Assert.False(p1.IsWriteOnly); 3333Assert.False(p1.IsReadOnly); 3334Assert.False(p1.IsWriteOnly); 3408Assert.False(p1.IsReadOnly); 3409Assert.False(p1.IsWriteOnly); 3414Assert.False(p1.IsAbstract); 3416Assert.False(getP1.IsAbstract); 3418Assert.False(setP1.IsAbstract); 3478Assert.False(p1.IsReadOnly); 3479Assert.False(p1.IsWriteOnly); 3484Assert.False(p1.IsAbstract); 3485Assert.False(p1.IsVirtual); 3486Assert.False(getP1.IsAbstract); 3487Assert.False(getP1.IsVirtual); 3488Assert.False(setP1.IsAbstract); 3489Assert.False(setP1.IsVirtual); 3497Assert.False(getP1.IsMetadataVirtual()); 3498Assert.False(setP1.IsMetadataVirtual()); 3567Assert.False(p1.IsReadOnly); 3568Assert.False(p1.IsWriteOnly); 3573Assert.False(p1.IsAbstract); 3575Assert.False(getP1.IsAbstract); 3577Assert.False(setP1.IsAbstract); 3633Assert.False(p1.IsReadOnly); 3634Assert.False(p1.IsWriteOnly); 3639Assert.False(p1.IsAbstract); 3640Assert.False(p1.IsVirtual); 3641Assert.False(getP1.IsAbstract); 3642Assert.False(getP1.IsVirtual); 3643Assert.False(setP1.IsAbstract); 3644Assert.False(setP1.IsVirtual); 3652Assert.False(getP1.IsMetadataVirtual()); 3653Assert.False(setP1.IsMetadataVirtual()); 4352Assert.False(p1.IsAbstract); 4353Assert.False(p3.IsAbstract); 4354Assert.False(p5.IsAbstract); 4355Assert.False(p7.IsAbstract); 4374Assert.False(p1.GetMethod.IsAbstract); 4375Assert.False(p3.GetMethod.IsAbstract); 4376Assert.False(p5.SetMethod.IsAbstract); 4377Assert.False(p7.GetMethod.IsAbstract); 4378Assert.False(p7.SetMethod.IsAbstract); 4503Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 4547Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 4593Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 4912Assert.False(p1.IsVirtual); 4913Assert.False(p3.IsVirtual); 4914Assert.False(p5.IsVirtual); 4915Assert.False(p7.IsVirtual); 4917Assert.False(p1.IsAbstract); 4918Assert.False(p3.IsAbstract); 4919Assert.False(p5.IsAbstract); 4920Assert.False(p7.IsAbstract); 4933Assert.False(p1.GetMethod.IsVirtual); 4934Assert.False(p3.GetMethod.IsVirtual); 4935Assert.False(p5.SetMethod.IsVirtual); 4936Assert.False(p7.GetMethod.IsVirtual); 4937Assert.False(p7.SetMethod.IsVirtual); 4939Assert.False(p1.GetMethod.IsMetadataVirtual()); 4940Assert.False(p3.GetMethod.IsMetadataVirtual()); 4941Assert.False(p5.SetMethod.IsMetadataVirtual()); 4942Assert.False(p7.GetMethod.IsMetadataVirtual()); 4943Assert.False(p7.SetMethod.IsMetadataVirtual()); 4945Assert.False(p1.GetMethod.IsAbstract); 4946Assert.False(p3.GetMethod.IsAbstract); 4947Assert.False(p5.SetMethod.IsAbstract); 4948Assert.False(p7.GetMethod.IsAbstract); 4949Assert.False(p7.SetMethod.IsAbstract); 5165Assert.False(p1.IsReadOnly); 5166Assert.False(p1.IsWriteOnly); 5230Assert.False(p1.IsReadOnly); 5231Assert.False(p1.IsWriteOnly); 5271Assert.False(p1.IsReadOnly); 5272Assert.False(p1.IsWriteOnly); 5274Assert.False(p1.IsAbstract); 5276Assert.False(getP1.IsAbstract); 5278Assert.False(setP1.IsAbstract); 5324Assert.False(p1.IsReadOnly); 5325Assert.False(p1.IsWriteOnly); 5327Assert.False(p1.IsAbstract); 5329Assert.False(getP1.IsAbstract); 5331Assert.False(setP1.IsAbstract); 5839Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 5869Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 5909Assert.False(p1.IsAbstract); 5910Assert.False(p3.IsAbstract); 5911Assert.False(p5.IsAbstract); 5912Assert.False(p7.IsAbstract); 5931Assert.False(p1.GetMethod.IsAbstract); 5932Assert.False(p3.GetMethod.IsAbstract); 5933Assert.False(p5.SetMethod.IsAbstract); 5934Assert.False(p7.GetMethod.IsAbstract); 5935Assert.False(p7.SetMethod.IsAbstract); 5979Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 6044Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 6094Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 6140Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 6422Assert.False(accessor.IsAbstract); 6425Assert.False(accessor.IsSealed); 6427Assert.False(accessor.IsExtern); 6428Assert.False(accessor.IsAsync); 6429Assert.False(accessor.IsOverride); 6433Assert.False(e1.IsAbstract); 6435Assert.False(e1.IsSealed); 6437Assert.False(e1.IsExtern); 6438Assert.False(e1.IsOverride); 7393Assert.False(e7.IsAbstract); 7403Assert.False(e7.AddMethod.IsAbstract); 7404Assert.False(e7.RemoveMethod.IsAbstract); 7545Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 7573Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 7788Assert.False(e7.IsVirtual); 7789Assert.False(e7.IsAbstract); 7794Assert.False(e7.AddMethod.IsVirtual); 7795Assert.False(e7.RemoveMethod.IsVirtual); 7797Assert.False(e7.AddMethod.IsMetadataVirtual()); 7798Assert.False(e7.RemoveMethod.IsMetadataVirtual()); 7800Assert.False(e7.AddMethod.IsAbstract); 7801Assert.False(e7.RemoveMethod.IsAbstract); 8447Assert.False(m01.IsVirtual); 8449Assert.False(m01.IsSealed); 8450Assert.False(m01.IsStatic); 8451Assert.False(m01.IsExtern); 8452Assert.False(m01.IsAsync); 8453Assert.False(m01.IsOverride); 8459Assert.False(m02.IsVirtual); 8461Assert.False(m02.IsSealed); 8462Assert.False(m02.IsStatic); 8463Assert.False(m02.IsExtern); 8464Assert.False(m02.IsAsync); 8465Assert.False(m02.IsOverride); 8471Assert.False(m03.IsVirtual); 8473Assert.False(m03.IsSealed); 8474Assert.False(m03.IsStatic); 8475Assert.False(m03.IsExtern); 8476Assert.False(m03.IsAsync); 8477Assert.False(m03.IsOverride); 8483Assert.False(m04.IsVirtual); 8485Assert.False(m04.IsSealed); 8486Assert.False(m04.IsStatic); 8487Assert.False(m04.IsExtern); 8488Assert.False(m04.IsAsync); 8489Assert.False(m04.IsOverride); 8494Assert.False(m05.IsAbstract); 8495Assert.False(m05.IsVirtual); 8496Assert.False(m05.IsMetadataVirtual()); 8497Assert.False(m05.IsSealed); 8498Assert.False(m05.IsStatic); 8499Assert.False(m05.IsExtern); 8500Assert.False(m05.IsAsync); 8501Assert.False(m05.IsOverride); 8506Assert.False(m06.IsAbstract); 8507Assert.False(m06.IsVirtual); 8508Assert.False(m06.IsMetadataVirtual()); 8509Assert.False(m06.IsSealed); 8511Assert.False(m06.IsExtern); 8512Assert.False(m06.IsAsync); 8513Assert.False(m06.IsOverride); 8518Assert.False(m07.IsAbstract); 8521Assert.False(m07.IsSealed); 8522Assert.False(m07.IsStatic); 8523Assert.False(m07.IsExtern); 8524Assert.False(m07.IsAsync); 8525Assert.False(m07.IsOverride); 8530Assert.False(m08.IsAbstract); 8531Assert.False(m08.IsVirtual); 8532Assert.False(m08.IsMetadataVirtual()); 8533Assert.False(m08.IsSealed); 8534Assert.False(m08.IsStatic); 8535Assert.False(m08.IsExtern); 8536Assert.False(m08.IsAsync); 8537Assert.False(m08.IsOverride); 8543Assert.False(m09.IsVirtual); 8545Assert.False(m09.IsSealed); 8546Assert.False(m09.IsStatic); 8547Assert.False(m09.IsExtern); 8548Assert.False(m09.IsAsync); 8549Assert.False(m09.IsOverride); 8555Assert.False(m10.IsVirtual); 8557Assert.False(m10.IsSealed); 8558Assert.False(m10.IsStatic); 8559Assert.False(m10.IsExtern); 8560Assert.False(m10.IsAsync); 8561Assert.False(m10.IsOverride); 8566Assert.False(m11.IsAbstract); 8569Assert.False(m11.IsSealed); 8570Assert.False(m11.IsStatic); 8572Assert.False(m11.IsAsync); 8573Assert.False(m11.IsOverride); 8579Assert.False(m12.IsVirtual); 8581Assert.False(m12.IsSealed); 8582Assert.False(m12.IsStatic); 8583Assert.False(m12.IsExtern); 8585Assert.False(m12.IsOverride); 8591Assert.False(m13.IsVirtual); 8593Assert.False(m13.IsSealed); 8594Assert.False(m13.IsStatic); 8595Assert.False(m13.IsExtern); 8596Assert.False(m13.IsAsync); 8597Assert.False(m13.IsOverride); 8693Assert.False(compilation2.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 8800Assert.False(m1.IsVirtual); 8802Assert.False(m1.IsSealed); 8803Assert.False(m1.IsStatic); 8804Assert.False(m1.IsExtern); 8805Assert.False(m1.IsAsync); 8806Assert.False(m1.IsOverride); 8839Assert.False(m1.IsVirtual); 8841Assert.False(m1.IsSealed); 8842Assert.False(m1.IsStatic); 8843Assert.False(m1.IsExtern); 8844Assert.False(m1.IsAsync); 8845Assert.False(m1.IsOverride); 8901Assert.False(m1.IsAbstract); 8902Assert.False(m1.IsVirtual); 8903Assert.False(m1.IsMetadataVirtual()); 8904Assert.False(m1.IsSealed); 8906Assert.False(m1.IsExtern); 8907Assert.False(m1.IsAsync); 8908Assert.False(m1.IsOverride); 8987Assert.False(m1.IsVirtual); 8989Assert.False(m1.IsSealed); 8991Assert.False(m1.IsExtern); 8992Assert.False(m1.IsAsync); 8993Assert.False(m1.IsOverride); 8999Assert.False(m2.IsAbstract); 9002Assert.False(m2.IsSealed); 9004Assert.False(m2.IsExtern); 9005Assert.False(m2.IsAsync); 9006Assert.False(m2.IsOverride); 9012Assert.False(m3.IsAbstract); 9013Assert.False(m3.IsVirtual); 9014Assert.False(m3.IsMetadataVirtual()); 9015Assert.False(m3.IsSealed); 9017Assert.False(m3.IsExtern); 9018Assert.False(m3.IsAsync); 9019Assert.False(m3.IsOverride); 9068Assert.False(m1.IsAbstract); 9069Assert.False(m1.IsVirtual); 9070Assert.False(m1.IsMetadataVirtual()); 9071Assert.False(m1.IsSealed); 9072Assert.False(m1.IsStatic); 9073Assert.False(m1.IsExtern); 9074Assert.False(m1.IsAsync); 9075Assert.False(m1.IsOverride); 9127Assert.False(m1.IsVirtual); 9129Assert.False(m1.IsSealed); 9130Assert.False(m1.IsStatic); 9131Assert.False(m1.IsExtern); 9132Assert.False(m1.IsAsync); 9133Assert.False(m1.IsOverride); 9139Assert.False(m2.IsAbstract); 9142Assert.False(m2.IsSealed); 9143Assert.False(m2.IsStatic); 9144Assert.False(m2.IsExtern); 9145Assert.False(m2.IsAsync); 9146Assert.False(m2.IsOverride); 9152Assert.False(m3.IsAbstract); 9153Assert.False(m3.IsVirtual); 9154Assert.False(m3.IsMetadataVirtual()); 9156Assert.False(m3.IsStatic); 9157Assert.False(m3.IsExtern); 9158Assert.False(m3.IsAsync); 9159Assert.False(m3.IsOverride); 9378Assert.False(m1.IsVirtual); 9380Assert.False(m1.IsSealed); 9382Assert.False(m1.IsExtern); 9383Assert.False(m1.IsAsync); 9384Assert.False(m1.IsOverride); 10106Assert.False(m1.IsVirtual); 10108Assert.False(m1.IsSealed); 10109Assert.False(m1.IsStatic); 10110Assert.False(m1.IsExtern); 10111Assert.False(m1.IsAsync); 10112Assert.False(m1.IsOverride); 10155Assert.False(m1.IsAbstract); 10156Assert.False(m1.IsVirtual); 10157Assert.False(m1.IsMetadataVirtual()); 10158Assert.False(m1.IsSealed); 10159Assert.False(m1.IsStatic); 10160Assert.False(m1.IsExtern); 10161Assert.False(m1.IsAsync); 10162Assert.False(m1.IsOverride); 10236Assert.False(m1.IsAbstract); 10237Assert.False(m1.IsVirtual); 10238Assert.False(m1.IsMetadataVirtual()); 10239Assert.False(m1.IsSealed); 10240Assert.False(m1.IsStatic); 10241Assert.False(m1.IsExtern); 10242Assert.False(m1.IsAsync); 10243Assert.False(m1.IsOverride); 10251Assert.False(m2.IsVirtual); 10254Assert.False(m2.IsStatic); 10255Assert.False(m2.IsExtern); 10256Assert.False(m2.IsAsync); 10257Assert.False(m2.IsOverride); 10264Assert.False(m3.IsAbstract); 10268Assert.False(m3.IsStatic); 10269Assert.False(m3.IsExtern); 10270Assert.False(m3.IsAsync); 10271Assert.False(m3.IsOverride); 10278Assert.False(m4.IsAbstract); 10279Assert.False(m4.IsVirtual); 10280Assert.False(m4.IsMetadataVirtual()); 10281Assert.False(m4.IsSealed); 10282Assert.False(m4.IsStatic); 10283Assert.False(m4.IsExtern); 10284Assert.False(m4.IsAsync); 10285Assert.False(m4.IsOverride); 10347Assert.False(m2.IsSealed); 10348Assert.False(m2.IsStatic); 10349Assert.False(m2.IsExtern); 10350Assert.False(m2.IsAsync); 10351Assert.False(m2.IsOverride); 10398Assert.False(m1.IsAbstract); 10401Assert.False(m1.IsSealed); 10402Assert.False(m1.IsStatic); 10404Assert.False(m1.IsAsync); 10405Assert.False(m1.IsOverride); 10412Assert.False(m2.IsAbstract); 10415Assert.False(m2.IsSealed); 10416Assert.False(m2.IsStatic); 10418Assert.False(m2.IsAsync); 10419Assert.False(m2.IsOverride); 10426Assert.False(m3.IsAbstract); 10427Assert.False(m3.IsVirtual); 10428Assert.False(m3.IsMetadataVirtual()); 10429Assert.False(m3.IsSealed); 10432Assert.False(m3.IsAsync); 10433Assert.False(m3.IsOverride); 10440Assert.False(m4.IsAbstract); 10441Assert.False(m4.IsVirtual); 10442Assert.False(m4.IsMetadataVirtual()); 10443Assert.False(m4.IsSealed); 10444Assert.False(m4.IsStatic); 10446Assert.False(m4.IsAsync); 10447Assert.False(m4.IsOverride); 10454Assert.False(m5.IsAbstract); 10455Assert.False(m5.IsVirtual); 10456Assert.False(m5.IsMetadataVirtual()); 10457Assert.False(m5.IsSealed); 10458Assert.False(m5.IsStatic); 10460Assert.False(m5.IsAsync); 10461Assert.False(m5.IsOverride); 10520Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 10625Assert.False(m1.IsVirtual); 10627Assert.False(m1.IsSealed); 10628Assert.False(m1.IsStatic); 10630Assert.False(m1.IsAsync); 10631Assert.False(m1.IsOverride); 10638Assert.False(m2.IsAbstract); 10641Assert.False(m2.IsSealed); 10642Assert.False(m2.IsStatic); 10644Assert.False(m2.IsAsync); 10645Assert.False(m2.IsOverride); 10745Assert.False(m1.IsVirtual); 10747Assert.False(m1.IsSealed); 10748Assert.False(m1.IsStatic); 10749Assert.False(m1.IsExtern); 10750Assert.False(m1.IsAsync); 10751Assert.False(m1.IsOverride); 10759Assert.False(m2.IsVirtual); 10761Assert.False(m2.IsSealed); 10762Assert.False(m2.IsStatic); 10763Assert.False(m2.IsExtern); 10764Assert.False(m2.IsAsync); 10765Assert.False(m2.IsOverride); 10773Assert.False(m3.IsVirtual); 10775Assert.False(m3.IsSealed); 10777Assert.False(m3.IsExtern); 10778Assert.False(m3.IsAsync); 10779Assert.False(m3.IsOverride); 10786Assert.False(m4.IsAbstract); 10787Assert.False(m4.IsVirtual); 10788Assert.False(m4.IsMetadataVirtual()); 10789Assert.False(m4.IsSealed); 10792Assert.False(m4.IsAsync); 10793Assert.False(m4.IsOverride); 10800Assert.False(m5.IsAbstract); 10801Assert.False(m5.IsVirtual); 10802Assert.False(m5.IsMetadataVirtual()); 10803Assert.False(m5.IsSealed); 10804Assert.False(m5.IsStatic); 10805Assert.False(m5.IsExtern); 10806Assert.False(m5.IsAsync); 10807Assert.False(m5.IsOverride); 10852Assert.False(m1.IsAbstract); 10853Assert.False(m1.IsVirtual); 10854Assert.False(m1.IsMetadataVirtual()); 10855Assert.False(m1.IsSealed); 10857Assert.False(m1.IsExtern); 10859Assert.False(m1.IsOverride); 10915Assert.False(m1.IsAbstract); 10918Assert.False(m1.IsSealed); 10919Assert.False(m1.IsStatic); 10920Assert.False(m1.IsExtern); 10921Assert.False(m1.IsAsync); 10922Assert.False(m1.IsOverride); 11079Assert.False(m1.IsAbstract); 11080Assert.False(m1.IsVirtual); 11081Assert.False(m1.IsMetadataVirtual()); 11082Assert.False(m1.IsSealed); 11084Assert.False(m1.IsExtern); 11085Assert.False(m1.IsAsync); 11086Assert.False(m1.IsOverride); 11093Assert.False(m2.IsAbstract); 11094Assert.False(m2.IsVirtual); 11095Assert.False(m2.IsMetadataVirtual()); 11096Assert.False(m2.IsSealed); 11098Assert.False(m2.IsExtern); 11099Assert.False(m2.IsAsync); 11100Assert.False(m2.IsOverride); 11110Assert.False(m2Impl.IsAbstract); 11111Assert.False(m2Impl.IsVirtual); 11112Assert.False(m2Impl.IsMetadataVirtual()); 11113Assert.False(m2Impl.IsSealed); 11115Assert.False(m2Impl.IsExtern); 11116Assert.False(m2Impl.IsAsync); 11117Assert.False(m2Impl.IsOverride); 11186Assert.False(m1.IsAbstract); 11187Assert.False(m1.IsVirtual); 11188Assert.False(m1.IsMetadataVirtual()); 11189Assert.False(m1.IsSealed); 11190Assert.False(m1.IsStatic); 11191Assert.False(m1.IsExtern); 11192Assert.False(m1.IsAsync); 11193Assert.False(m1.IsOverride); 11200Assert.False(m2.IsAbstract); 11201Assert.False(m2.IsVirtual); 11202Assert.False(m2.IsMetadataVirtual()); 11203Assert.False(m2.IsSealed); 11204Assert.False(m2.IsStatic); 11205Assert.False(m2.IsExtern); 11206Assert.False(m2.IsAsync); 11207Assert.False(m2.IsOverride); 11217Assert.False(m2Impl.IsAbstract); 11218Assert.False(m2Impl.IsVirtual); 11219Assert.False(m2Impl.IsMetadataVirtual()); 11220Assert.False(m2Impl.IsSealed); 11221Assert.False(m2Impl.IsStatic); 11222Assert.False(m2Impl.IsExtern); 11223Assert.False(m2Impl.IsAsync); 11224Assert.False(m2Impl.IsOverride); 11816Assert.False(m1.IsAbstract); 11817Assert.False(m1.IsVirtual); 11818Assert.False(m1.IsMetadataVirtual()); 11819Assert.False(m1.IsSealed); 11821Assert.False(m1.IsExtern); 11822Assert.False(m1.IsAsync); 11823Assert.False(m1.IsOverride); 12672Assert.False(m1.IsAbstract); 12675Assert.False(m1.IsSealed); 12676Assert.False(m1.IsStatic); 12677Assert.False(m1.IsExtern); 12678Assert.False(m1.IsAsync); 12679Assert.False(m1.IsOverride); 12760Assert.False(m1.IsAbstract); 12763Assert.False(m1.IsSealed); 12764Assert.False(m1.IsStatic); 12765Assert.False(m1.IsExtern); 12766Assert.False(m1.IsAsync); 12767Assert.False(m1.IsOverride); 12848Assert.False(m1.IsAbstract); 12851Assert.False(m1.IsSealed); 12852Assert.False(m1.IsStatic); 12853Assert.False(m1.IsExtern); 12854Assert.False(m1.IsAsync); 12855Assert.False(m1.IsOverride); 13131Assert.False(p01.IsVirtual); 13132Assert.False(p01.IsSealed); 13133Assert.False(p01.IsStatic); 13134Assert.False(p01.IsExtern); 13135Assert.False(p01.IsOverride); 13143Assert.False(accessor.IsVirtual); 13145Assert.False(accessor.IsSealed); 13146Assert.False(accessor.IsStatic); 13147Assert.False(accessor.IsExtern); 13148Assert.False(accessor.IsAsync); 13149Assert.False(accessor.IsOverride); 13157Assert.False(p02.IsVirtual); 13158Assert.False(p02.IsSealed); 13159Assert.False(p02.IsStatic); 13160Assert.False(p02.IsExtern); 13161Assert.False(p02.IsOverride); 13165Assert.False(p02get.IsVirtual); 13167Assert.False(p02get.IsSealed); 13168Assert.False(p02get.IsStatic); 13169Assert.False(p02get.IsExtern); 13170Assert.False(p02get.IsAsync); 13171Assert.False(p02get.IsOverride); 13178Assert.False(p03.IsVirtual); 13179Assert.False(p03.IsSealed); 13180Assert.False(p03.IsStatic); 13181Assert.False(p03.IsExtern); 13182Assert.False(p03.IsOverride); 13186Assert.False(p03set.IsVirtual); 13188Assert.False(p03set.IsSealed); 13189Assert.False(p03set.IsStatic); 13190Assert.False(p03set.IsExtern); 13191Assert.False(p03set.IsAsync); 13192Assert.False(p03set.IsOverride); 13199Assert.False(p04.IsVirtual); 13200Assert.False(p04.IsSealed); 13201Assert.False(p04.IsStatic); 13202Assert.False(p04.IsExtern); 13203Assert.False(p04.IsOverride); 13207Assert.False(p04get.IsVirtual); 13209Assert.False(p04get.IsSealed); 13210Assert.False(p04get.IsStatic); 13211Assert.False(p04get.IsExtern); 13212Assert.False(p04get.IsAsync); 13213Assert.False(p04get.IsOverride); 13219Assert.False(p05.IsAbstract); 13220Assert.False(p05.IsVirtual); 13221Assert.False(p05.IsSealed); 13222Assert.False(p05.IsStatic); 13223Assert.False(p05.IsExtern); 13224Assert.False(p05.IsOverride); 13227Assert.False(p05set.IsAbstract); 13228Assert.False(p05set.IsVirtual); 13229Assert.False(p05set.IsMetadataVirtual()); 13230Assert.False(p05set.IsSealed); 13231Assert.False(p05set.IsStatic); 13232Assert.False(p05set.IsExtern); 13233Assert.False(p05set.IsAsync); 13234Assert.False(p05set.IsOverride); 13240Assert.False(p06.IsAbstract); 13241Assert.False(p06.IsVirtual); 13242Assert.False(p06.IsSealed); 13244Assert.False(p06.IsExtern); 13245Assert.False(p06.IsOverride); 13248Assert.False(p06get.IsAbstract); 13249Assert.False(p06get.IsVirtual); 13250Assert.False(p06get.IsMetadataVirtual()); 13251Assert.False(p06get.IsSealed); 13253Assert.False(p06get.IsExtern); 13254Assert.False(p06get.IsAsync); 13255Assert.False(p06get.IsOverride); 13261Assert.False(p07.IsAbstract); 13263Assert.False(p07.IsSealed); 13264Assert.False(p07.IsStatic); 13265Assert.False(p07.IsExtern); 13266Assert.False(p07.IsOverride); 13269Assert.False(p07set.IsAbstract); 13272Assert.False(p07set.IsSealed); 13273Assert.False(p07set.IsStatic); 13274Assert.False(p07set.IsExtern); 13275Assert.False(p07set.IsAsync); 13276Assert.False(p07set.IsOverride); 13282Assert.False(p08.IsAbstract); 13283Assert.False(p08.IsVirtual); 13284Assert.False(p08.IsSealed); 13285Assert.False(p08.IsStatic); 13286Assert.False(p08.IsExtern); 13287Assert.False(p08.IsOverride); 13290Assert.False(p08get.IsAbstract); 13291Assert.False(p08get.IsVirtual); 13292Assert.False(p08get.IsMetadataVirtual()); 13293Assert.False(p08get.IsSealed); 13294Assert.False(p08get.IsStatic); 13295Assert.False(p08get.IsExtern); 13296Assert.False(p08get.IsAsync); 13297Assert.False(p08get.IsOverride); 13304Assert.False(p09.IsVirtual); 13305Assert.False(p09.IsSealed); 13306Assert.False(p09.IsStatic); 13307Assert.False(p09.IsExtern); 13308Assert.False(p09.IsOverride); 13312Assert.False(p09set.IsVirtual); 13314Assert.False(p09set.IsSealed); 13315Assert.False(p09set.IsStatic); 13316Assert.False(p09set.IsExtern); 13317Assert.False(p09set.IsAsync); 13318Assert.False(p09set.IsOverride); 13325Assert.False(p10.IsVirtual); 13326Assert.False(p10.IsSealed); 13327Assert.False(p10.IsStatic); 13328Assert.False(p10.IsExtern); 13329Assert.False(p10.IsOverride); 13333Assert.False(p10get.IsVirtual); 13335Assert.False(p10get.IsSealed); 13336Assert.False(p10get.IsStatic); 13337Assert.False(p10get.IsExtern); 13338Assert.False(p10get.IsAsync); 13339Assert.False(p10get.IsOverride); 13344Assert.False(p11.IsAbstract); 13346Assert.False(p11.IsSealed); 13347Assert.False(p11.IsStatic); 13349Assert.False(p11.IsOverride); 13356Assert.False(accessor.IsAbstract); 13359Assert.False(accessor.IsSealed); 13360Assert.False(accessor.IsStatic); 13362Assert.False(accessor.IsAsync); 13363Assert.False(accessor.IsOverride); 13370Assert.False(p12.IsVirtual); 13371Assert.False(p12.IsSealed); 13372Assert.False(p12.IsStatic); 13373Assert.False(p12.IsExtern); 13374Assert.False(p12.IsOverride); 13382Assert.False(accessor.IsVirtual); 13384Assert.False(accessor.IsSealed); 13385Assert.False(accessor.IsStatic); 13386Assert.False(accessor.IsExtern); 13387Assert.False(accessor.IsAsync); 13388Assert.False(accessor.IsOverride); 13395Assert.False(p13.IsVirtual); 13396Assert.False(p13.IsSealed); 13397Assert.False(p13.IsStatic); 13398Assert.False(p13.IsExtern); 13399Assert.False(p13.IsOverride); 13407Assert.False(accessor.IsVirtual); 13409Assert.False(accessor.IsSealed); 13410Assert.False(accessor.IsStatic); 13411Assert.False(accessor.IsExtern); 13412Assert.False(accessor.IsAsync); 13413Assert.False(accessor.IsOverride); 13420Assert.False(p14.IsVirtual); 13421Assert.False(p14.IsSealed); 13422Assert.False(p14.IsStatic); 13423Assert.False(p14.IsExtern); 13424Assert.False(p14.IsOverride); 13432Assert.False(accessor.IsVirtual); 13434Assert.False(accessor.IsSealed); 13435Assert.False(accessor.IsStatic); 13436Assert.False(accessor.IsExtern); 13437Assert.False(accessor.IsAsync); 13438Assert.False(accessor.IsOverride); 13445Assert.False(p15.IsVirtual); 13446Assert.False(p15.IsSealed); 13447Assert.False(p15.IsStatic); 13448Assert.False(p15.IsExtern); 13449Assert.False(p15.IsOverride); 13457Assert.False(accessor.IsVirtual); 13459Assert.False(accessor.IsSealed); 13460Assert.False(accessor.IsStatic); 13461Assert.False(accessor.IsExtern); 13462Assert.False(accessor.IsAsync); 13463Assert.False(accessor.IsOverride); 13470Assert.False(p16.IsVirtual); 13471Assert.False(p16.IsSealed); 13472Assert.False(p16.IsStatic); 13473Assert.False(p16.IsExtern); 13474Assert.False(p16.IsOverride); 13482Assert.False(accessor.IsVirtual); 13484Assert.False(accessor.IsSealed); 13485Assert.False(accessor.IsStatic); 13486Assert.False(accessor.IsExtern); 13487Assert.False(accessor.IsAsync); 13488Assert.False(accessor.IsOverride); 13496Assert.False(p17.IsVirtual); 13497Assert.False(p17.IsSealed); 13498Assert.False(p17.IsStatic); 13499Assert.False(p17.IsExtern); 13500Assert.False(p17.IsOverride); 13504Assert.False(p17get.IsVirtual); 13506Assert.False(p17get.IsSealed); 13507Assert.False(p17get.IsStatic); 13508Assert.False(p17get.IsExtern); 13509Assert.False(p17get.IsAsync); 13510Assert.False(p17get.IsOverride); 13517Assert.False(p18.IsVirtual); 13518Assert.False(p18.IsSealed); 13519Assert.False(p18.IsStatic); 13520Assert.False(p18.IsExtern); 13521Assert.False(p18.IsOverride); 13525Assert.False(p18get.IsVirtual); 13527Assert.False(p18get.IsSealed); 13528Assert.False(p18get.IsStatic); 13529Assert.False(p18get.IsExtern); 13530Assert.False(p18get.IsAsync); 13531Assert.False(p18get.IsOverride); 13537Assert.False(p19.IsVirtual); 13538Assert.False(p19.IsSealed); 13539Assert.False(p19.IsStatic); 13540Assert.False(p19.IsExtern); 13541Assert.False(p19.IsOverride); 13672Assert.False(compilation2.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 13930Assert.False(p1.IsAbstract); 13932Assert.False(p1.IsSealed); 13933Assert.False(p1.IsStatic); 13934Assert.False(p1.IsExtern); 13935Assert.False(p1.IsOverride); 13938Assert.False(p1get.IsAbstract); 13941Assert.False(p1get.IsSealed); 13942Assert.False(p1get.IsStatic); 13943Assert.False(p1get.IsExtern); 13944Assert.False(p1get.IsAsync); 13945Assert.False(p1get.IsOverride); 14023Assert.False(p1.IsVirtual); 14024Assert.False(p1.IsSealed); 14025Assert.False(p1.IsStatic); 14026Assert.False(p1.IsExtern); 14027Assert.False(p1.IsOverride); 14037Assert.False(accessor.IsVirtual); 14039Assert.False(accessor.IsSealed); 14040Assert.False(accessor.IsStatic); 14041Assert.False(accessor.IsExtern); 14042Assert.False(accessor.IsAsync); 14043Assert.False(accessor.IsOverride); 14097Assert.False(p1.IsVirtual); 14098Assert.False(p1.IsSealed); 14099Assert.False(p1.IsStatic); 14100Assert.False(p1.IsExtern); 14101Assert.False(p1.IsOverride); 14110Assert.False(accessor.IsVirtual); 14112Assert.False(accessor.IsSealed); 14113Assert.False(accessor.IsStatic); 14114Assert.False(accessor.IsExtern); 14115Assert.False(accessor.IsAsync); 14116Assert.False(accessor.IsOverride); 14298Assert.False(p1.IsAbstract); 14299Assert.False(p1.IsVirtual); 14300Assert.False(p1.IsSealed); 14302Assert.False(p1.IsExtern); 14303Assert.False(p1.IsOverride); 14328Assert.False(accessor.IsAbstract); 14329Assert.False(accessor.IsVirtual); 14330Assert.False(accessor.IsMetadataVirtual()); 14331Assert.False(accessor.IsSealed); 14333Assert.False(accessor.IsExtern); 14334Assert.False(accessor.IsAsync); 14335Assert.False(accessor.IsOverride); 14410Assert.False(p1.IsVirtual); 14411Assert.False(p1.IsSealed); 14413Assert.False(p1.IsExtern); 14414Assert.False(p1.IsOverride); 14419Assert.False(p1get.IsVirtual); 14421Assert.False(p1get.IsSealed); 14423Assert.False(p1get.IsExtern); 14424Assert.False(p1get.IsAsync); 14425Assert.False(p1get.IsOverride); 14432Assert.False(p2.IsAbstract); 14434Assert.False(p2.IsSealed); 14436Assert.False(p2.IsExtern); 14437Assert.False(p2.IsOverride); 14441Assert.False(p2set.IsAbstract); 14444Assert.False(p2set.IsSealed); 14446Assert.False(p2set.IsExtern); 14447Assert.False(p2set.IsAsync); 14448Assert.False(p2set.IsOverride); 14455Assert.False(p3.IsAbstract); 14456Assert.False(p3.IsVirtual); 14457Assert.False(p3.IsSealed); 14459Assert.False(p3.IsExtern); 14460Assert.False(p3.IsOverride); 14464Assert.False(p3get.IsAbstract); 14465Assert.False(p3get.IsVirtual); 14466Assert.False(p3get.IsMetadataVirtual()); 14467Assert.False(p3get.IsSealed); 14469Assert.False(p3get.IsExtern); 14470Assert.False(p3get.IsAsync); 14471Assert.False(p3get.IsOverride); 14647Assert.False(p1.IsAbstract); 14648Assert.False(p1.IsVirtual); 14649Assert.False(p1.IsSealed); 14650Assert.False(p1.IsStatic); 14651Assert.False(p1.IsExtern); 14652Assert.False(p1.IsOverride); 14677Assert.False(accessor.IsAbstract); 14678Assert.False(accessor.IsVirtual); 14679Assert.False(accessor.IsMetadataVirtual()); 14680Assert.False(accessor.IsSealed); 14681Assert.False(accessor.IsStatic); 14682Assert.False(accessor.IsExtern); 14683Assert.False(accessor.IsAsync); 14684Assert.False(accessor.IsOverride); 14752Assert.False(p1.IsVirtual); 14753Assert.False(p1.IsSealed); 14754Assert.False(p1.IsStatic); 14755Assert.False(p1.IsExtern); 14756Assert.False(p1.IsOverride); 14761Assert.False(p1get.IsVirtual); 14763Assert.False(p1get.IsSealed); 14764Assert.False(p1get.IsStatic); 14765Assert.False(p1get.IsExtern); 14766Assert.False(p1get.IsAsync); 14767Assert.False(p1get.IsOverride); 14774Assert.False(p2.IsAbstract); 14776Assert.False(p2.IsSealed); 14777Assert.False(p2.IsStatic); 14778Assert.False(p2.IsExtern); 14779Assert.False(p2.IsOverride); 14783Assert.False(p2get.IsAbstract); 14786Assert.False(p2get.IsSealed); 14787Assert.False(p2get.IsStatic); 14788Assert.False(p2get.IsExtern); 14789Assert.False(p2get.IsAsync); 14790Assert.False(p2get.IsOverride); 14796Assert.False(p3.IsAbstract); 14797Assert.False(p3.IsVirtual); 14799Assert.False(p3.IsStatic); 14800Assert.False(p3.IsExtern); 14801Assert.False(p3.IsOverride); 14809Assert.False(accessor.IsAbstract); 14810Assert.False(accessor.IsVirtual); 14811Assert.False(accessor.IsMetadataVirtual()); 14813Assert.False(accessor.IsStatic); 14814Assert.False(accessor.IsExtern); 14815Assert.False(accessor.IsAsync); 14816Assert.False(accessor.IsOverride); 14824Assert.False(p4.IsAbstract); 14825Assert.False(p4.IsVirtual); 14826Assert.False(p4.IsSealed); 14827Assert.False(p4.IsStatic); 14828Assert.False(p4.IsExtern); 14829Assert.False(p4.IsOverride); 14833Assert.False(p4get.IsAbstract); 14834Assert.False(p4get.IsVirtual); 14835Assert.False(p4get.IsMetadataVirtual()); 14836Assert.False(p4get.IsSealed); 14837Assert.False(p4get.IsStatic); 14838Assert.False(p4get.IsExtern); 14839Assert.False(p4get.IsAsync); 14840Assert.False(p4get.IsOverride); 15026Assert.False(p1.IsVirtual); 15027Assert.False(p1.IsSealed); 15028Assert.False(p1.IsStatic); 15029Assert.False(p1.IsExtern); 15030Assert.False(p1.IsOverride); 15037Assert.False(m1.IsVirtual); 15039Assert.False(m1.IsSealed); 15040Assert.False(m1.IsStatic); 15041Assert.False(m1.IsExtern); 15042Assert.False(m1.IsAsync); 15043Assert.False(m1.IsOverride); 16199Assert.False(p1.IsAbstract); 16200Assert.False(p1.IsVirtual); 16201Assert.False(p1.IsSealed); 16202Assert.False(p1.IsStatic); 16203Assert.False(p1.IsExtern); 16204Assert.False(p1.IsOverride); 16229Assert.False(accessor.IsAbstract); 16230Assert.False(accessor.IsVirtual); 16231Assert.False(accessor.IsMetadataVirtual()); 16232Assert.False(accessor.IsSealed); 16233Assert.False(accessor.IsStatic); 16234Assert.False(accessor.IsExtern); 16235Assert.False(accessor.IsAsync); 16236Assert.False(accessor.IsOverride); 16329Assert.False(p1.IsAbstract); 16330Assert.False(p1.IsVirtual); 16331Assert.False(p1.IsSealed); 16332Assert.False(p1.IsStatic); 16333Assert.False(p1.IsExtern); 16334Assert.False(p1.IsOverride); 16339Assert.False(p1get.IsAbstract); 16340Assert.False(p1get.IsVirtual); 16341Assert.False(p1get.IsMetadataVirtual()); 16342Assert.False(p1get.IsSealed); 16343Assert.False(p1get.IsStatic); 16344Assert.False(p1get.IsExtern); 16345Assert.False(p1get.IsAsync); 16346Assert.False(p1get.IsOverride); 16356Assert.False(p2.IsVirtual); 16358Assert.False(p2.IsStatic); 16359Assert.False(p2.IsExtern); 16360Assert.False(p2.IsOverride); 16366Assert.False(p2get.IsVirtual); 16369Assert.False(p2get.IsStatic); 16370Assert.False(p2get.IsExtern); 16371Assert.False(p2get.IsAsync); 16372Assert.False(p2get.IsOverride); 16381Assert.False(p3.IsAbstract); 16384Assert.False(p3.IsStatic); 16385Assert.False(p3.IsExtern); 16386Assert.False(p3.IsOverride); 16391Assert.False(p3set.IsAbstract); 16395Assert.False(p3set.IsStatic); 16396Assert.False(p3set.IsExtern); 16397Assert.False(p3set.IsAsync); 16398Assert.False(p3set.IsOverride); 16607Assert.False(p2.IsSealed); 16608Assert.False(p2.IsStatic); 16609Assert.False(p2.IsExtern); 16610Assert.False(p2.IsOverride); 16640Assert.False(accessor.IsSealed); 16641Assert.False(accessor.IsStatic); 16642Assert.False(accessor.IsExtern); 16643Assert.False(accessor.IsAsync); 16644Assert.False(accessor.IsOverride); 16795Assert.False(p1.IsAbstract); 16797Assert.False(p1.IsSealed); 16798Assert.False(p1.IsStatic); 16800Assert.False(p1.IsOverride); 16805Assert.False(p1get.IsAbstract); 16808Assert.False(p1get.IsSealed); 16809Assert.False(p1get.IsStatic); 16811Assert.False(p1get.IsAsync); 16812Assert.False(p1get.IsOverride); 16821Assert.False(p2.IsAbstract); 16823Assert.False(p2.IsSealed); 16824Assert.False(p2.IsStatic); 16826Assert.False(p2.IsOverride); 16831Assert.False(p2set.IsAbstract); 16834Assert.False(p2set.IsSealed); 16835Assert.False(p2set.IsStatic); 16837Assert.False(p2set.IsAsync); 16838Assert.False(p2set.IsOverride); 16849Assert.False(p3.IsAbstract); 16850Assert.False(p3.IsVirtual); 16851Assert.False(p3.IsSealed); 16854Assert.False(p3.IsOverride); 16863Assert.False(accessor.IsAbstract); 16864Assert.False(accessor.IsVirtual); 16865Assert.False(accessor.IsMetadataVirtual()); 16866Assert.False(accessor.IsSealed); 16869Assert.False(accessor.IsAsync); 16870Assert.False(accessor.IsOverride); 16880Assert.False(p4.IsAbstract); 16881Assert.False(p4.IsVirtual); 16882Assert.False(p4.IsSealed); 16883Assert.False(p4.IsStatic); 16885Assert.False(p4.IsOverride); 16890Assert.False(p4get.IsAbstract); 16891Assert.False(p4get.IsVirtual); 16892Assert.False(p4get.IsMetadataVirtual()); 16893Assert.False(p4get.IsSealed); 16894Assert.False(p4get.IsStatic); 16896Assert.False(p4get.IsAsync); 16897Assert.False(p4get.IsOverride); 16905Assert.False(p5.IsAbstract); 16906Assert.False(p5.IsVirtual); 16907Assert.False(p5.IsSealed); 16908Assert.False(p5.IsStatic); 16910Assert.False(p5.IsOverride); 16915Assert.False(p5set.IsAbstract); 16916Assert.False(p5set.IsVirtual); 16917Assert.False(p5set.IsMetadataVirtual()); 16918Assert.False(p5set.IsSealed); 16919Assert.False(p5set.IsStatic); 16921Assert.False(p5set.IsAsync); 16922Assert.False(p5set.IsOverride); 16938Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 17039Assert.False(p1.IsVirtual); 17040Assert.False(p1.IsSealed); 17041Assert.False(p1.IsStatic); 17043Assert.False(p1.IsOverride); 17049Assert.False(p1get.IsVirtual); 17051Assert.False(p1get.IsSealed); 17052Assert.False(p1get.IsStatic); 17054Assert.False(p1get.IsAsync); 17055Assert.False(p1get.IsOverride); 17064Assert.False(p2.IsAbstract); 17066Assert.False(p2.IsSealed); 17067Assert.False(p2.IsStatic); 17069Assert.False(p2.IsOverride); 17074Assert.False(p2get.IsAbstract); 17077Assert.False(p2get.IsSealed); 17078Assert.False(p2get.IsStatic); 17080Assert.False(p2get.IsAsync); 17081Assert.False(p2get.IsOverride); 17089Assert.False(p3.IsAbstract); 17091Assert.False(p3.IsSealed); 17094Assert.False(p3.IsOverride); 17103Assert.False(accessor.IsAbstract); 17106Assert.False(accessor.IsSealed); 17109Assert.False(accessor.IsAsync); 17110Assert.False(accessor.IsOverride); 17118Assert.False(p4.IsAbstract); 17119Assert.False(p4.IsVirtual); 17120Assert.False(p4.IsSealed); 17121Assert.False(p4.IsStatic); 17123Assert.False(p4.IsOverride); 17132Assert.False(accessor.IsAbstract); 17133Assert.False(accessor.IsVirtual); 17134Assert.False(accessor.IsMetadataVirtual()); 17135Assert.False(accessor.IsSealed); 17136Assert.False(accessor.IsStatic); 17138Assert.False(accessor.IsAsync); 17139Assert.False(accessor.IsOverride); 17148Assert.False(p5.IsAbstract); 17149Assert.False(p5.IsVirtual); 17150Assert.False(p5.IsSealed); 17151Assert.False(p5.IsStatic); 17153Assert.False(p5.IsOverride); 17158Assert.False(p5get.IsAbstract); 17159Assert.False(p5get.IsVirtual); 17160Assert.False(p5get.IsMetadataVirtual()); 17161Assert.False(p5get.IsSealed); 17162Assert.False(p5get.IsStatic); 17164Assert.False(p5get.IsAsync); 17165Assert.False(p5get.IsOverride); 17288Assert.False(p1.IsVirtual); 17289Assert.False(p1.IsSealed); 17290Assert.False(p1.IsStatic); 17291Assert.False(p1.IsExtern); 17292Assert.False(p1.IsOverride); 17302Assert.False(accessor.IsVirtual); 17304Assert.False(accessor.IsSealed); 17305Assert.False(accessor.IsStatic); 17306Assert.False(accessor.IsExtern); 17307Assert.False(accessor.IsAsync); 17308Assert.False(accessor.IsOverride); 17319Assert.False(p2.IsVirtual); 17320Assert.False(p2.IsSealed); 17321Assert.False(p2.IsStatic); 17322Assert.False(p2.IsExtern); 17323Assert.False(p2.IsOverride); 17329Assert.False(p2get.IsVirtual); 17331Assert.False(p2get.IsSealed); 17332Assert.False(p2get.IsStatic); 17333Assert.False(p2get.IsExtern); 17334Assert.False(p2get.IsAsync); 17335Assert.False(p2get.IsOverride); 17343Assert.False(p3.IsAbstract); 17345Assert.False(p3.IsSealed); 17348Assert.False(p3.IsOverride); 17357Assert.False(accessor.IsAbstract); 17360Assert.False(accessor.IsSealed); 17363Assert.False(accessor.IsAsync); 17364Assert.False(accessor.IsOverride); 17374Assert.False(p4.IsVirtual); 17375Assert.False(p4.IsSealed); 17377Assert.False(p4.IsExtern); 17378Assert.False(p4.IsOverride); 17388Assert.False(accessor.IsVirtual); 17390Assert.False(accessor.IsSealed); 17392Assert.False(accessor.IsExtern); 17393Assert.False(accessor.IsAsync); 17394Assert.False(accessor.IsOverride); 17403Assert.False(p5.IsAbstract); 17404Assert.False(p5.IsVirtual); 17405Assert.False(p5.IsSealed); 17406Assert.False(p5.IsStatic); 17407Assert.False(p5.IsExtern); 17408Assert.False(p5.IsOverride); 17413Assert.False(p5get.IsAbstract); 17414Assert.False(p5get.IsVirtual); 17415Assert.False(p5get.IsMetadataVirtual()); 17416Assert.False(p5get.IsSealed); 17417Assert.False(p5get.IsStatic); 17418Assert.False(p5get.IsExtern); 17419Assert.False(p5get.IsAsync); 17420Assert.False(p5get.IsOverride); 17499Assert.False(p1.IsAbstract); 17501Assert.False(p1.IsSealed); 17502Assert.False(p1.IsStatic); 17503Assert.False(p1.IsExtern); 17504Assert.False(p1.IsOverride); 17510Assert.False(m1.IsAbstract); 17513Assert.False(m1.IsSealed); 17514Assert.False(m1.IsStatic); 17515Assert.False(m1.IsExtern); 17516Assert.False(m1.IsAsync); 17517Assert.False(m1.IsOverride); 17766Assert.False(p1.IsAbstract); 17768Assert.False(p1.IsSealed); 17769Assert.False(p1.IsStatic); 17770Assert.False(p1.IsExtern); 17771Assert.False(p1.IsOverride); 17788Assert.False(true); 17794Assert.False(accessor.IsAbstract); 17797Assert.False(accessor.IsSealed); 17798Assert.False(accessor.IsStatic); 17799Assert.False(accessor.IsExtern); 17800Assert.False(accessor.IsAsync); 17801Assert.False(accessor.IsOverride); 18356Assert.False(p1.IsSealed); 18357Assert.False(p1.IsStatic); 18358Assert.False(p1.IsExtern); 18359Assert.False(p1.IsOverride); 18394Assert.False(m1.IsSealed); 18395Assert.False(m1.IsStatic); 18396Assert.False(m1.IsExtern); 18397Assert.False(m1.IsAsync); 18398Assert.False(m1.IsOverride); 19880Assert.False(p1.IsAbstract); 19882Assert.False(p1.IsSealed); 19883Assert.False(p1.IsStatic); 19884Assert.False(p1.IsExtern); 19885Assert.False(p1.IsOverride); 19891Assert.False(m1.IsAbstract); 19894Assert.False(m1.IsSealed); 19895Assert.False(m1.IsStatic); 19896Assert.False(m1.IsExtern); 19897Assert.False(m1.IsAsync); 19898Assert.False(m1.IsOverride); 20534Assert.False(p1.IsAbstract); 20535Assert.False(p1.IsVirtual); 20536Assert.False(p1.IsSealed); 20538Assert.False(p1.IsExtern); 20539Assert.False(p1.IsOverride); 20549Assert.False(accessor.IsAbstract); 20550Assert.False(accessor.IsVirtual); 20551Assert.False(accessor.IsMetadataVirtual()); 20552Assert.False(accessor.IsSealed); 20554Assert.False(accessor.IsExtern); 20555Assert.False(accessor.IsAsync); 20556Assert.False(accessor.IsOverride); 21608Assert.False(p01.IsVirtual); 21609Assert.False(p01.IsSealed); 21610Assert.False(p01.IsStatic); 21611Assert.False(p01.IsExtern); 21612Assert.False(p01.IsOverride); 21620Assert.False(accessor.IsVirtual); 21622Assert.False(accessor.IsSealed); 21623Assert.False(accessor.IsStatic); 21624Assert.False(accessor.IsExtern); 21625Assert.False(accessor.IsAsync); 21626Assert.False(accessor.IsOverride); 21634Assert.False(p02.IsVirtual); 21635Assert.False(p02.IsSealed); 21636Assert.False(p02.IsStatic); 21637Assert.False(p02.IsExtern); 21638Assert.False(p02.IsOverride); 21642Assert.False(p02get.IsVirtual); 21644Assert.False(p02get.IsSealed); 21645Assert.False(p02get.IsStatic); 21646Assert.False(p02get.IsExtern); 21647Assert.False(p02get.IsAsync); 21648Assert.False(p02get.IsOverride); 21655Assert.False(p03.IsVirtual); 21656Assert.False(p03.IsSealed); 21657Assert.False(p03.IsStatic); 21658Assert.False(p03.IsExtern); 21659Assert.False(p03.IsOverride); 21663Assert.False(p03set.IsVirtual); 21665Assert.False(p03set.IsSealed); 21666Assert.False(p03set.IsStatic); 21667Assert.False(p03set.IsExtern); 21668Assert.False(p03set.IsAsync); 21669Assert.False(p03set.IsOverride); 21676Assert.False(p04.IsVirtual); 21677Assert.False(p04.IsSealed); 21678Assert.False(p04.IsStatic); 21679Assert.False(p04.IsExtern); 21680Assert.False(p04.IsOverride); 21684Assert.False(p04get.IsVirtual); 21686Assert.False(p04get.IsSealed); 21687Assert.False(p04get.IsStatic); 21688Assert.False(p04get.IsExtern); 21689Assert.False(p04get.IsAsync); 21690Assert.False(p04get.IsOverride); 21696Assert.False(p05.IsAbstract); 21697Assert.False(p05.IsVirtual); 21698Assert.False(p05.IsSealed); 21699Assert.False(p05.IsStatic); 21700Assert.False(p05.IsExtern); 21701Assert.False(p05.IsOverride); 21704Assert.False(p05set.IsAbstract); 21705Assert.False(p05set.IsVirtual); 21706Assert.False(p05set.IsMetadataVirtual()); 21707Assert.False(p05set.IsSealed); 21708Assert.False(p05set.IsStatic); 21709Assert.False(p05set.IsExtern); 21710Assert.False(p05set.IsAsync); 21711Assert.False(p05set.IsOverride); 21718Assert.False(p06.IsVirtual); 21719Assert.False(p06.IsSealed); 21720Assert.False(p06.IsStatic); 21721Assert.False(p06.IsExtern); 21722Assert.False(p06.IsOverride); 21726Assert.False(p06get.IsVirtual); 21728Assert.False(p06get.IsSealed); 21729Assert.False(p06get.IsStatic); 21730Assert.False(p06get.IsExtern); 21731Assert.False(p06get.IsAsync); 21732Assert.False(p06get.IsOverride); 21738Assert.False(p07.IsAbstract); 21740Assert.False(p07.IsSealed); 21741Assert.False(p07.IsStatic); 21742Assert.False(p07.IsExtern); 21743Assert.False(p07.IsOverride); 21746Assert.False(p07set.IsAbstract); 21749Assert.False(p07set.IsSealed); 21750Assert.False(p07set.IsStatic); 21751Assert.False(p07set.IsExtern); 21752Assert.False(p07set.IsAsync); 21753Assert.False(p07set.IsOverride); 21759Assert.False(p08.IsAbstract); 21760Assert.False(p08.IsVirtual); 21761Assert.False(p08.IsSealed); 21762Assert.False(p08.IsStatic); 21763Assert.False(p08.IsExtern); 21764Assert.False(p08.IsOverride); 21767Assert.False(p08get.IsAbstract); 21768Assert.False(p08get.IsVirtual); 21769Assert.False(p08get.IsMetadataVirtual()); 21770Assert.False(p08get.IsSealed); 21771Assert.False(p08get.IsStatic); 21772Assert.False(p08get.IsExtern); 21773Assert.False(p08get.IsAsync); 21774Assert.False(p08get.IsOverride); 21781Assert.False(p09.IsVirtual); 21782Assert.False(p09.IsSealed); 21783Assert.False(p09.IsStatic); 21784Assert.False(p09.IsExtern); 21785Assert.False(p09.IsOverride); 21789Assert.False(p09set.IsVirtual); 21791Assert.False(p09set.IsSealed); 21792Assert.False(p09set.IsStatic); 21793Assert.False(p09set.IsExtern); 21794Assert.False(p09set.IsAsync); 21795Assert.False(p09set.IsOverride); 21802Assert.False(p10.IsVirtual); 21803Assert.False(p10.IsSealed); 21804Assert.False(p10.IsStatic); 21805Assert.False(p10.IsExtern); 21806Assert.False(p10.IsOverride); 21810Assert.False(p10get.IsVirtual); 21812Assert.False(p10get.IsSealed); 21813Assert.False(p10get.IsStatic); 21814Assert.False(p10get.IsExtern); 21815Assert.False(p10get.IsAsync); 21816Assert.False(p10get.IsOverride); 21821Assert.False(p11.IsAbstract); 21823Assert.False(p11.IsSealed); 21824Assert.False(p11.IsStatic); 21826Assert.False(p11.IsOverride); 21833Assert.False(accessor.IsAbstract); 21836Assert.False(accessor.IsSealed); 21837Assert.False(accessor.IsStatic); 21839Assert.False(accessor.IsAsync); 21840Assert.False(accessor.IsOverride); 21847Assert.False(p12.IsVirtual); 21848Assert.False(p12.IsSealed); 21849Assert.False(p12.IsStatic); 21850Assert.False(p12.IsExtern); 21851Assert.False(p12.IsOverride); 21859Assert.False(accessor.IsVirtual); 21861Assert.False(accessor.IsSealed); 21862Assert.False(accessor.IsStatic); 21863Assert.False(accessor.IsExtern); 21864Assert.False(accessor.IsAsync); 21865Assert.False(accessor.IsOverride); 21872Assert.False(p13.IsVirtual); 21873Assert.False(p13.IsSealed); 21874Assert.False(p13.IsStatic); 21875Assert.False(p13.IsExtern); 21876Assert.False(p13.IsOverride); 21884Assert.False(accessor.IsVirtual); 21886Assert.False(accessor.IsSealed); 21887Assert.False(accessor.IsStatic); 21888Assert.False(accessor.IsExtern); 21889Assert.False(accessor.IsAsync); 21890Assert.False(accessor.IsOverride); 21897Assert.False(p14.IsVirtual); 21898Assert.False(p14.IsSealed); 21899Assert.False(p14.IsStatic); 21900Assert.False(p14.IsExtern); 21901Assert.False(p14.IsOverride); 21909Assert.False(accessor.IsVirtual); 21911Assert.False(accessor.IsSealed); 21912Assert.False(accessor.IsStatic); 21913Assert.False(accessor.IsExtern); 21914Assert.False(accessor.IsAsync); 21915Assert.False(accessor.IsOverride); 21922Assert.False(p15.IsVirtual); 21923Assert.False(p15.IsSealed); 21924Assert.False(p15.IsStatic); 21925Assert.False(p15.IsExtern); 21926Assert.False(p15.IsOverride); 21934Assert.False(accessor.IsVirtual); 21936Assert.False(accessor.IsSealed); 21937Assert.False(accessor.IsStatic); 21938Assert.False(accessor.IsExtern); 21939Assert.False(accessor.IsAsync); 21940Assert.False(accessor.IsOverride); 21947Assert.False(p16.IsVirtual); 21948Assert.False(p16.IsSealed); 21949Assert.False(p16.IsStatic); 21950Assert.False(p16.IsExtern); 21951Assert.False(p16.IsOverride); 21959Assert.False(accessor.IsVirtual); 21961Assert.False(accessor.IsSealed); 21962Assert.False(accessor.IsStatic); 21963Assert.False(accessor.IsExtern); 21964Assert.False(accessor.IsAsync); 21965Assert.False(accessor.IsOverride); 21973Assert.False(p17.IsVirtual); 21974Assert.False(p17.IsSealed); 21975Assert.False(p17.IsStatic); 21976Assert.False(p17.IsExtern); 21977Assert.False(p17.IsOverride); 21981Assert.False(p17get.IsVirtual); 21983Assert.False(p17get.IsSealed); 21984Assert.False(p17get.IsStatic); 21985Assert.False(p17get.IsExtern); 21986Assert.False(p17get.IsAsync); 21987Assert.False(p17get.IsOverride); 21994Assert.False(p18.IsVirtual); 21995Assert.False(p18.IsSealed); 21996Assert.False(p18.IsStatic); 21997Assert.False(p18.IsExtern); 21998Assert.False(p18.IsOverride); 22002Assert.False(p18get.IsVirtual); 22004Assert.False(p18get.IsSealed); 22005Assert.False(p18get.IsStatic); 22006Assert.False(p18get.IsExtern); 22007Assert.False(p18get.IsAsync); 22008Assert.False(p18get.IsOverride); 22014Assert.False(p19.IsVirtual); 22015Assert.False(p19.IsSealed); 22016Assert.False(p19.IsStatic); 22017Assert.False(p19.IsExtern); 22018Assert.False(p19.IsOverride); 22145Assert.False(compilation2.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 26853Assert.False(p01.IsVirtual); 26854Assert.False(p01.IsSealed); 26855Assert.False(p01.IsStatic); 26856Assert.False(p01.IsExtern); 26857Assert.False(p01.IsOverride); 26865Assert.False(accessor.IsVirtual); 26867Assert.False(accessor.IsSealed); 26868Assert.False(accessor.IsStatic); 26869Assert.False(accessor.IsExtern); 26870Assert.False(accessor.IsAsync); 26871Assert.False(accessor.IsOverride); 26878Assert.False(p02.IsAbstract); 26880Assert.False(p02.IsSealed); 26881Assert.False(p02.IsStatic); 26882Assert.False(p02.IsExtern); 26883Assert.False(p02.IsOverride); 26886Assert.False(p02get.IsAbstract); 26889Assert.False(p02get.IsSealed); 26890Assert.False(p02get.IsStatic); 26891Assert.False(p02get.IsExtern); 26892Assert.False(p02get.IsAsync); 26893Assert.False(p02get.IsOverride); 26899Assert.False(p03.IsAbstract); 26901Assert.False(p03.IsSealed); 26902Assert.False(p03.IsStatic); 26903Assert.False(p03.IsExtern); 26904Assert.False(p03.IsOverride); 26907Assert.False(p03set.IsAbstract); 26910Assert.False(p03set.IsSealed); 26911Assert.False(p03set.IsStatic); 26912Assert.False(p03set.IsExtern); 26913Assert.False(p03set.IsAsync); 26914Assert.False(p03set.IsOverride); 26920Assert.False(p04.IsAbstract); 26922Assert.False(p04.IsSealed); 26923Assert.False(p04.IsStatic); 26924Assert.False(p04.IsExtern); 26925Assert.False(p04.IsOverride); 26928Assert.False(p04get.IsAbstract); 26931Assert.False(p04get.IsSealed); 26932Assert.False(p04get.IsStatic); 26933Assert.False(p04get.IsExtern); 26934Assert.False(p04get.IsAsync); 26935Assert.False(p04get.IsOverride); 26941Assert.False(p05.IsAbstract); 26942Assert.False(p05.IsVirtual); 26943Assert.False(p05.IsSealed); 26944Assert.False(p05.IsStatic); 26945Assert.False(p05.IsExtern); 26946Assert.False(p05.IsOverride); 26949Assert.False(p05set.IsAbstract); 26950Assert.False(p05set.IsVirtual); 26951Assert.False(p05set.IsMetadataVirtual()); 26952Assert.False(p05set.IsSealed); 26953Assert.False(p05set.IsStatic); 26954Assert.False(p05set.IsExtern); 26955Assert.False(p05set.IsAsync); 26956Assert.False(p05set.IsOverride); 26962Assert.False(p06.IsAbstract); 26963Assert.False(p06.IsVirtual); 26964Assert.False(p06.IsSealed); 26966Assert.False(p06.IsExtern); 26967Assert.False(p06.IsOverride); 26970Assert.False(p06get.IsAbstract); 26971Assert.False(p06get.IsVirtual); 26972Assert.False(p06get.IsMetadataVirtual()); 26973Assert.False(p06get.IsSealed); 26975Assert.False(p06get.IsExtern); 26976Assert.False(p06get.IsAsync); 26977Assert.False(p06get.IsOverride); 26983Assert.False(p07.IsAbstract); 26985Assert.False(p07.IsSealed); 26986Assert.False(p07.IsStatic); 26987Assert.False(p07.IsExtern); 26988Assert.False(p07.IsOverride); 26991Assert.False(p07set.IsAbstract); 26994Assert.False(p07set.IsSealed); 26995Assert.False(p07set.IsStatic); 26996Assert.False(p07set.IsExtern); 26997Assert.False(p07set.IsAsync); 26998Assert.False(p07set.IsOverride); 27004Assert.False(p08.IsAbstract); 27005Assert.False(p08.IsVirtual); 27006Assert.False(p08.IsSealed); 27007Assert.False(p08.IsStatic); 27008Assert.False(p08.IsExtern); 27009Assert.False(p08.IsOverride); 27012Assert.False(p08get.IsAbstract); 27013Assert.False(p08get.IsVirtual); 27014Assert.False(p08get.IsMetadataVirtual()); 27015Assert.False(p08get.IsSealed); 27016Assert.False(p08get.IsStatic); 27017Assert.False(p08get.IsExtern); 27018Assert.False(p08get.IsAsync); 27019Assert.False(p08get.IsOverride); 27025Assert.False(p09.IsAbstract); 27027Assert.False(p09.IsSealed); 27028Assert.False(p09.IsStatic); 27029Assert.False(p09.IsExtern); 27030Assert.False(p09.IsOverride); 27033Assert.False(p09set.IsAbstract); 27036Assert.False(p09set.IsSealed); 27037Assert.False(p09set.IsStatic); 27038Assert.False(p09set.IsExtern); 27039Assert.False(p09set.IsAsync); 27040Assert.False(p09set.IsOverride); 27047Assert.False(p10.IsVirtual); 27048Assert.False(p10.IsSealed); 27049Assert.False(p10.IsStatic); 27050Assert.False(p10.IsExtern); 27051Assert.False(p10.IsOverride); 27055Assert.False(p10get.IsVirtual); 27057Assert.False(p10get.IsSealed); 27058Assert.False(p10get.IsStatic); 27059Assert.False(p10get.IsExtern); 27060Assert.False(p10get.IsAsync); 27061Assert.False(p10get.IsOverride); 27068Assert.False(p11.IsAbstract); 27070Assert.False(p11.IsSealed); 27071Assert.False(p11.IsStatic); 27073Assert.False(p11.IsOverride); 27080Assert.False(accessor.IsAbstract); 27083Assert.False(accessor.IsSealed); 27084Assert.False(accessor.IsStatic); 27086Assert.False(accessor.IsAsync); 27087Assert.False(accessor.IsOverride); 27095Assert.False(p14.IsVirtual); 27096Assert.False(p14.IsSealed); 27097Assert.False(p14.IsStatic); 27098Assert.False(p14.IsExtern); 27099Assert.False(p14.IsOverride); 27107Assert.False(accessor.IsVirtual); 27109Assert.False(accessor.IsSealed); 27110Assert.False(accessor.IsStatic); 27111Assert.False(accessor.IsExtern); 27112Assert.False(accessor.IsAsync); 27113Assert.False(accessor.IsOverride); 27237Assert.False(compilation2.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 27651Assert.False(p1.IsVirtual); 27652Assert.False(p1.IsSealed); 27653Assert.False(p1.IsStatic); 27654Assert.False(p1.IsExtern); 27655Assert.False(p1.IsOverride); 27665Assert.False(accessor.IsVirtual); 27667Assert.False(accessor.IsSealed); 27668Assert.False(accessor.IsStatic); 27669Assert.False(accessor.IsExtern); 27670Assert.False(accessor.IsAsync); 27671Assert.False(accessor.IsOverride); 27725Assert.False(p1.IsVirtual); 27726Assert.False(p1.IsSealed); 27727Assert.False(p1.IsStatic); 27728Assert.False(p1.IsExtern); 27729Assert.False(p1.IsOverride); 27738Assert.False(accessor.IsVirtual); 27740Assert.False(accessor.IsSealed); 27741Assert.False(accessor.IsStatic); 27742Assert.False(accessor.IsExtern); 27743Assert.False(accessor.IsAsync); 27744Assert.False(accessor.IsOverride); 27824Assert.False(p1.IsAbstract); 27825Assert.False(p1.IsVirtual); 27826Assert.False(p1.IsSealed); 27828Assert.False(p1.IsExtern); 27829Assert.False(p1.IsOverride); 27838Assert.False(accessor.IsAbstract); 27839Assert.False(accessor.IsVirtual); 27840Assert.False(accessor.IsMetadataVirtual()); 27841Assert.False(accessor.IsSealed); 27843Assert.False(accessor.IsExtern); 27844Assert.False(accessor.IsAsync); 27845Assert.False(accessor.IsOverride); 27993Assert.False(p1.IsVirtual); 27994Assert.False(p1.IsSealed); 27996Assert.False(p1.IsExtern); 27997Assert.False(p1.IsOverride); 28006Assert.False(accessor.IsVirtual); 28008Assert.False(accessor.IsSealed); 28010Assert.False(accessor.IsExtern); 28011Assert.False(accessor.IsAsync); 28012Assert.False(accessor.IsOverride); 28019Assert.False(p2.IsAbstract); 28021Assert.False(p2.IsSealed); 28023Assert.False(p2.IsExtern); 28024Assert.False(p2.IsOverride); 28032Assert.False(accessor.IsAbstract); 28035Assert.False(accessor.IsSealed); 28037Assert.False(accessor.IsExtern); 28038Assert.False(accessor.IsAsync); 28039Assert.False(accessor.IsOverride); 28046Assert.False(p3.IsAbstract); 28047Assert.False(p3.IsVirtual); 28048Assert.False(p3.IsSealed); 28050Assert.False(p3.IsExtern); 28051Assert.False(p3.IsOverride); 28059Assert.False(accessor.IsAbstract); 28060Assert.False(accessor.IsVirtual); 28061Assert.False(accessor.IsMetadataVirtual()); 28062Assert.False(accessor.IsSealed); 28064Assert.False(accessor.IsExtern); 28065Assert.False(accessor.IsAsync); 28066Assert.False(accessor.IsOverride); 28153Assert.False(p1.IsAbstract); 28154Assert.False(p1.IsVirtual); 28155Assert.False(p1.IsSealed); 28156Assert.False(p1.IsStatic); 28157Assert.False(p1.IsExtern); 28158Assert.False(p1.IsOverride); 28167Assert.False(accessor.IsAbstract); 28168Assert.False(accessor.IsVirtual); 28169Assert.False(accessor.IsMetadataVirtual()); 28170Assert.False(accessor.IsSealed); 28171Assert.False(accessor.IsStatic); 28172Assert.False(accessor.IsExtern); 28173Assert.False(accessor.IsAsync); 28174Assert.False(accessor.IsOverride); 28250Assert.False(p1.IsVirtual); 28251Assert.False(p1.IsSealed); 28252Assert.False(p1.IsStatic); 28253Assert.False(p1.IsExtern); 28254Assert.False(p1.IsOverride); 28263Assert.False(accessor.IsVirtual); 28265Assert.False(accessor.IsSealed); 28266Assert.False(accessor.IsStatic); 28267Assert.False(accessor.IsExtern); 28268Assert.False(accessor.IsAsync); 28269Assert.False(accessor.IsOverride); 28276Assert.False(p2.IsAbstract); 28278Assert.False(p2.IsSealed); 28279Assert.False(p2.IsStatic); 28280Assert.False(p2.IsExtern); 28281Assert.False(p2.IsOverride); 28289Assert.False(accessor.IsAbstract); 28292Assert.False(accessor.IsSealed); 28293Assert.False(accessor.IsStatic); 28294Assert.False(accessor.IsExtern); 28295Assert.False(accessor.IsAsync); 28296Assert.False(accessor.IsOverride); 28303Assert.False(p3.IsAbstract); 28304Assert.False(p3.IsVirtual); 28306Assert.False(p3.IsStatic); 28307Assert.False(p3.IsExtern); 28308Assert.False(p3.IsOverride); 28316Assert.False(accessor.IsAbstract); 28317Assert.False(accessor.IsVirtual); 28318Assert.False(accessor.IsMetadataVirtual()); 28320Assert.False(accessor.IsStatic); 28321Assert.False(accessor.IsExtern); 28322Assert.False(accessor.IsAsync); 28323Assert.False(accessor.IsOverride); 28330Assert.False(p4.IsAbstract); 28331Assert.False(p4.IsVirtual); 28332Assert.False(p4.IsSealed); 28333Assert.False(p4.IsStatic); 28334Assert.False(p4.IsExtern); 28335Assert.False(p4.IsOverride); 28343Assert.False(accessor.IsAbstract); 28344Assert.False(accessor.IsVirtual); 28345Assert.False(accessor.IsMetadataVirtual()); 28346Assert.False(accessor.IsSealed); 28347Assert.False(accessor.IsStatic); 28348Assert.False(accessor.IsExtern); 28349Assert.False(accessor.IsAsync); 28350Assert.False(accessor.IsOverride); 28468Assert.False(p1.IsVirtual); 28469Assert.False(p1.IsSealed); 28470Assert.False(p1.IsStatic); 28471Assert.False(p1.IsExtern); 28472Assert.False(p1.IsOverride); 28479Assert.False(m1.IsVirtual); 28481Assert.False(m1.IsSealed); 28482Assert.False(m1.IsStatic); 28483Assert.False(m1.IsExtern); 28484Assert.False(m1.IsAsync); 28485Assert.False(m1.IsOverride); 29602Assert.False(p1.IsAbstract); 29603Assert.False(p1.IsVirtual); 29604Assert.False(p1.IsSealed); 29605Assert.False(p1.IsStatic); 29606Assert.False(p1.IsExtern); 29607Assert.False(p1.IsOverride); 29616Assert.False(accessor.IsAbstract); 29617Assert.False(accessor.IsVirtual); 29618Assert.False(accessor.IsMetadataVirtual()); 29619Assert.False(accessor.IsSealed); 29620Assert.False(accessor.IsStatic); 29621Assert.False(accessor.IsExtern); 29622Assert.False(accessor.IsAsync); 29623Assert.False(accessor.IsOverride); 29717Assert.False(p1.IsAbstract); 29718Assert.False(p1.IsVirtual); 29719Assert.False(p1.IsSealed); 29720Assert.False(p1.IsStatic); 29721Assert.False(p1.IsExtern); 29722Assert.False(p1.IsOverride); 29731Assert.False(accessor.IsAbstract); 29732Assert.False(accessor.IsVirtual); 29733Assert.False(accessor.IsMetadataVirtual()); 29734Assert.False(accessor.IsSealed); 29735Assert.False(accessor.IsStatic); 29736Assert.False(accessor.IsExtern); 29737Assert.False(accessor.IsAsync); 29738Assert.False(accessor.IsOverride); 29748Assert.False(p2.IsVirtual); 29750Assert.False(p2.IsStatic); 29751Assert.False(p2.IsExtern); 29752Assert.False(p2.IsOverride); 29762Assert.False(accessor.IsVirtual); 29765Assert.False(accessor.IsStatic); 29766Assert.False(accessor.IsExtern); 29767Assert.False(accessor.IsAsync); 29768Assert.False(accessor.IsOverride); 29777Assert.False(p3.IsAbstract); 29780Assert.False(p3.IsStatic); 29781Assert.False(p3.IsExtern); 29782Assert.False(p3.IsOverride); 29791Assert.False(accessor.IsAbstract); 29795Assert.False(accessor.IsStatic); 29796Assert.False(accessor.IsExtern); 29797Assert.False(accessor.IsAsync); 29798Assert.False(accessor.IsOverride); 30020Assert.False(p2.IsSealed); 30021Assert.False(p2.IsStatic); 30022Assert.False(p2.IsExtern); 30023Assert.False(p2.IsOverride); 30053Assert.False(accessor.IsSealed); 30054Assert.False(accessor.IsStatic); 30055Assert.False(accessor.IsExtern); 30056Assert.False(accessor.IsAsync); 30057Assert.False(accessor.IsOverride); 30130Assert.False(p1.IsAbstract); 30132Assert.False(p1.IsSealed); 30133Assert.False(p1.IsStatic); 30135Assert.False(p1.IsOverride); 30144Assert.False(accessor.IsAbstract); 30147Assert.False(accessor.IsSealed); 30148Assert.False(accessor.IsStatic); 30150Assert.False(accessor.IsAsync); 30151Assert.False(accessor.IsOverride); 30160Assert.False(p2.IsAbstract); 30162Assert.False(p2.IsSealed); 30163Assert.False(p2.IsStatic); 30165Assert.False(p2.IsOverride); 30174Assert.False(accessor.IsAbstract); 30177Assert.False(accessor.IsSealed); 30178Assert.False(accessor.IsStatic); 30180Assert.False(accessor.IsAsync); 30181Assert.False(accessor.IsOverride); 30190Assert.False(p3.IsAbstract); 30191Assert.False(p3.IsVirtual); 30192Assert.False(p3.IsSealed); 30195Assert.False(p3.IsOverride); 30204Assert.False(accessor.IsAbstract); 30205Assert.False(accessor.IsVirtual); 30206Assert.False(accessor.IsMetadataVirtual()); 30207Assert.False(accessor.IsSealed); 30210Assert.False(accessor.IsAsync); 30211Assert.False(accessor.IsOverride); 30219Assert.False(p4.IsAbstract); 30220Assert.False(p4.IsVirtual); 30221Assert.False(p4.IsSealed); 30222Assert.False(p4.IsStatic); 30224Assert.False(p4.IsOverride); 30233Assert.False(accessor.IsAbstract); 30234Assert.False(accessor.IsVirtual); 30235Assert.False(accessor.IsMetadataVirtual()); 30236Assert.False(accessor.IsSealed); 30237Assert.False(accessor.IsStatic); 30239Assert.False(accessor.IsAsync); 30240Assert.False(accessor.IsOverride); 30248Assert.False(p5.IsAbstract); 30249Assert.False(p5.IsVirtual); 30250Assert.False(p5.IsSealed); 30251Assert.False(p5.IsStatic); 30253Assert.False(p5.IsOverride); 30262Assert.False(accessor.IsAbstract); 30263Assert.False(accessor.IsVirtual); 30264Assert.False(accessor.IsMetadataVirtual()); 30265Assert.False(accessor.IsSealed); 30266Assert.False(accessor.IsStatic); 30268Assert.False(accessor.IsAsync); 30269Assert.False(accessor.IsOverride); 30332Assert.False(compilation3.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 30461Assert.False(p1.IsVirtual); 30462Assert.False(p1.IsSealed); 30463Assert.False(p1.IsStatic); 30465Assert.False(p1.IsOverride); 30475Assert.False(accessor.IsVirtual); 30477Assert.False(accessor.IsSealed); 30478Assert.False(accessor.IsStatic); 30480Assert.False(accessor.IsAsync); 30481Assert.False(accessor.IsOverride); 30490Assert.False(p2.IsAbstract); 30492Assert.False(p2.IsSealed); 30493Assert.False(p2.IsStatic); 30495Assert.False(p2.IsOverride); 30504Assert.False(accessor.IsAbstract); 30507Assert.False(accessor.IsSealed); 30508Assert.False(accessor.IsStatic); 30510Assert.False(accessor.IsAsync); 30511Assert.False(accessor.IsOverride); 30520Assert.False(p3.IsAbstract); 30521Assert.False(p3.IsVirtual); 30522Assert.False(p3.IsSealed); 30525Assert.False(p3.IsOverride); 30534Assert.False(accessor.IsAbstract); 30535Assert.False(accessor.IsVirtual); 30536Assert.False(accessor.IsMetadataVirtual()); 30537Assert.False(accessor.IsSealed); 30540Assert.False(accessor.IsAsync); 30541Assert.False(accessor.IsOverride); 30549Assert.False(p4.IsAbstract); 30550Assert.False(p4.IsVirtual); 30551Assert.False(p4.IsSealed); 30552Assert.False(p4.IsStatic); 30554Assert.False(p4.IsOverride); 30563Assert.False(accessor.IsAbstract); 30564Assert.False(accessor.IsVirtual); 30565Assert.False(accessor.IsMetadataVirtual()); 30566Assert.False(accessor.IsSealed); 30567Assert.False(accessor.IsStatic); 30569Assert.False(accessor.IsAsync); 30570Assert.False(accessor.IsOverride); 30682Assert.False(p1.IsVirtual); 30683Assert.False(p1.IsSealed); 30684Assert.False(p1.IsStatic); 30685Assert.False(p1.IsExtern); 30686Assert.False(p1.IsOverride); 30696Assert.False(accessor.IsVirtual); 30698Assert.False(accessor.IsSealed); 30699Assert.False(accessor.IsStatic); 30700Assert.False(accessor.IsExtern); 30701Assert.False(accessor.IsAsync); 30702Assert.False(accessor.IsOverride); 30712Assert.False(p2.IsVirtual); 30713Assert.False(p2.IsSealed); 30714Assert.False(p2.IsStatic); 30715Assert.False(p2.IsExtern); 30716Assert.False(p2.IsOverride); 30726Assert.False(accessor.IsVirtual); 30728Assert.False(accessor.IsSealed); 30729Assert.False(accessor.IsStatic); 30730Assert.False(accessor.IsExtern); 30731Assert.False(accessor.IsAsync); 30732Assert.False(accessor.IsOverride); 30741Assert.False(p3.IsAbstract); 30742Assert.False(p3.IsVirtual); 30743Assert.False(p3.IsSealed); 30746Assert.False(p3.IsOverride); 30755Assert.False(accessor.IsAbstract); 30756Assert.False(accessor.IsVirtual); 30757Assert.False(accessor.IsMetadataVirtual()); 30758Assert.False(accessor.IsSealed); 30761Assert.False(accessor.IsAsync); 30762Assert.False(accessor.IsOverride); 30772Assert.False(p4.IsVirtual); 30773Assert.False(p4.IsSealed); 30775Assert.False(p4.IsExtern); 30776Assert.False(p4.IsOverride); 30786Assert.False(accessor.IsVirtual); 30788Assert.False(accessor.IsSealed); 30790Assert.False(accessor.IsExtern); 30791Assert.False(accessor.IsAsync); 30792Assert.False(accessor.IsOverride); 30800Assert.False(p5.IsAbstract); 30801Assert.False(p5.IsVirtual); 30802Assert.False(p5.IsSealed); 30803Assert.False(p5.IsStatic); 30804Assert.False(p5.IsExtern); 30805Assert.False(p5.IsOverride); 30814Assert.False(accessor.IsAbstract); 30815Assert.False(accessor.IsVirtual); 30816Assert.False(accessor.IsMetadataVirtual()); 30817Assert.False(accessor.IsSealed); 30818Assert.False(accessor.IsStatic); 30819Assert.False(accessor.IsExtern); 30820Assert.False(accessor.IsAsync); 30821Assert.False(accessor.IsOverride); 30904Assert.False(p1.IsAbstract); 30906Assert.False(p1.IsSealed); 30907Assert.False(p1.IsStatic); 30908Assert.False(p1.IsExtern); 30909Assert.False(p1.IsOverride); 30915Assert.False(m1.IsAbstract); 30918Assert.False(m1.IsSealed); 30919Assert.False(m1.IsStatic); 30920Assert.False(m1.IsExtern); 30921Assert.False(m1.IsAsync); 30922Assert.False(m1.IsOverride); 31243Assert.False(p1.IsAbstract); 31244Assert.False(p1.IsVirtual); 31245Assert.False(p1.IsSealed); 31247Assert.False(p1.IsExtern); 31248Assert.False(p1.IsOverride); 31257Assert.False(accessor.IsAbstract); 31258Assert.False(accessor.IsVirtual); 31259Assert.False(accessor.IsMetadataVirtual()); 31260Assert.False(accessor.IsSealed); 31262Assert.False(accessor.IsExtern); 31263Assert.False(accessor.IsAsync); 31264Assert.False(accessor.IsOverride); 33075Assert.False(m1.IsMetadataNewSlot()); 33077Assert.False(m1.IsVirtual); 33080Assert.False(m1.IsExtern); 33081Assert.False(m1.IsAsync); 33082Assert.False(m1.IsOverride); 33296Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 33321Assert.False(compilation2.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 33912Assert.False(m1.IsMetadataNewSlot()); 33913Assert.False(m1.IsAbstract); 33914Assert.False(m1.IsVirtual); 33915Assert.False(m1.IsSealed); 33918Assert.False(m1.IsAsync); 33919Assert.False(m1.IsOverride); 34028Assert.False(m1.IsMetadataNewSlot()); 34029Assert.False(m1.IsAbstract); 34030Assert.False(m1.IsVirtual); 34031Assert.False(m1.IsSealed); 34033Assert.False(m1.IsExtern); 34035Assert.False(m1.IsOverride); 37133Assert.False(m1.IsVirtual); 37136Assert.False(m1.IsExtern); 37137Assert.False(m1.IsOverride); 38024Assert.False(m1.IsAbstract); 38025Assert.False(m1.IsVirtual); 38026Assert.False(m1.IsSealed); 38029Assert.False(m1.IsOverride); 40166Assert.False(m1.IsVirtual); 40169Assert.False(m1.IsExtern); 40170Assert.False(m1.IsOverride); 40406Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 40437Assert.False(compilation2.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 43754Assert.False(f1.IsStatic); 43953Assert.False(f1.IsConst); 43954Assert.False(f2.IsConst); 43955Assert.False(f3.IsConst); 43956Assert.False(f4.IsConst); 44663Assert.False(cctor.IsAbstract); 44664Assert.False(cctor.IsVirtual); 44665Assert.False(cctor.IsMetadataVirtual()); 44666Assert.False(cctor.IsSealed); 44668Assert.False(cctor.IsExtern); 44669Assert.False(cctor.IsAsync); 44670Assert.False(cctor.IsOverride); 44761Assert.False(cctor.IsAbstract); 44762Assert.False(cctor.IsVirtual); 44763Assert.False(cctor.IsMetadataVirtual()); 44764Assert.False(cctor.IsSealed); 44767Assert.False(cctor.IsAsync); 44768Assert.False(cctor.IsOverride); 45941Assert.False(compilation4.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 46205Assert.False(compilation4.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 49612Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 49613Assert.False(compilation1.Assembly.CorLibrary.RuntimeSupportsDefaultInterfaceImplementation); 49773Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 49782Assert.False(compilation2.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 49783Assert.False(compilation2.Assembly.CorLibrary.RuntimeSupportsDefaultInterfaceImplementation); 49923Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 49924Assert.False(compilation1.Assembly.CorLibrary.RuntimeSupportsDefaultInterfaceImplementation); 51116Assert.False(m.IsMetadataNewSlot()); 51118Assert.False(m.IsVirtual); 51121Assert.False(m.IsExtern); 51122Assert.False(m.IsAsync); 51123Assert.False(m.IsOverride); 52039Assert.False(i2m1.IsMetadataNewSlot()); 52041Assert.False(i2m1.IsVirtual); 52045Assert.False(i2m1.IsAsync); 52046Assert.False(i2m1.IsOverride); 52162Assert.False(i2m1.IsMetadataNewSlot()); 52164Assert.False(i2m1.IsVirtual); 52167Assert.False(i2m1.IsExtern); 52169Assert.False(i2m1.IsOverride); 52278Assert.False(c2m1.IsAbstract); 52279Assert.False(c2m1.IsSealed); 52560Assert.False(reabstracting.IsVirtual); 52563Assert.False(reabstracting.IsExtern); 52564Assert.False(reabstracting.IsOverride); 53742Assert.False(i2p1.IsVirtual); 53746Assert.False(i2p1.IsOverride); 53755Assert.False(i2p1Get.IsMetadataNewSlot()); 53757Assert.False(i2p1Get.IsVirtual); 53761Assert.False(i2p1Get.IsAsync); 53762Assert.False(i2p1Get.IsOverride); 53772Assert.False(i2p1Set.IsMetadataNewSlot()); 53774Assert.False(i2p1Set.IsVirtual); 53778Assert.False(i2p1Set.IsAsync); 53779Assert.False(i2p1Set.IsOverride); 53885Assert.False(c2p1.IsAbstract); 53886Assert.False(c2p1.IsSealed); 53892Assert.False(c2p1Get.IsAbstract); 53893Assert.False(c2p1Get.IsSealed); 53900Assert.False(c2p1Set.IsAbstract); 53901Assert.False(c2p1Set.IsSealed); 57524Assert.False(reabstracting.IsVirtual); 57527Assert.False(reabstracting.IsExtern); 57528Assert.False(reabstracting.IsOverride); 58687Assert.False(c2p1.IsAbstract); 58688Assert.False(c2p1.IsSealed); 58698Assert.False(c2p1Add.IsAbstract); 58699Assert.False(c2p1Add.IsSealed); 58713Assert.False(c2p1Remove.IsAbstract); 58714Assert.False(c2p1Remove.IsSealed); 62726Assert.False(baseInterfaceNormal.IsWindowsRuntimeEvent); 62727Assert.False(i1Normal.IsWindowsRuntimeEvent); 67880Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 67908Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 69402Assert.False(hasBeforeFieldInitFlag(module, "I4")); 69403Assert.False(hasBeforeFieldInitFlag(module, "I5")); 69404Assert.False(hasBeforeFieldInitFlag(module, "I6"));
Symbols\EnumTests.cs (1)
355Assert.False(value.HasValue);
Symbols\ErrorTypeSymbolTests.cs (2)
92Assert.False(type.IsErrorType()); 93Assert.False(constructedFrom.IsErrorType());
Symbols\ExtendedPartialMethodsTests.cs (15)
1171Assert.False(importData.SetLastError); 1172Assert.False(importData.ExactSpelling); 1266Assert.False(method.IsAsync); 1290Assert.False(method.IsAsync); 1322Assert.False(method.IsAsync); 2113Assert.False(m.IsAbstract); 2118Assert.False(m.IsStatic); 2119Assert.False(m.IsExtern); 2120Assert.False(m.IsOverride); 2256Assert.False(m.IsAbstract); 2259Assert.False(m.IsMetadataNewSlot()); 2260Assert.False(m.IsSealed); 2262Assert.False(m.IsExtern); 2263Assert.False(m.IsOverride); 3048Assert.False(array.IsSZArray);
Symbols\ExtensionMethodTests.cs (10)
41Assert.False(method.IsExtensionMethod); 124Assert.False(method.IsExtensionMethod); 129Assert.False(method.IsStatic); 130Assert.False(method.IsExtensionMethod); 138Assert.False(method.IsExtensionMethod); 144Assert.False(method.IsExtensionMethod); 150Assert.False(method.IsExtensionMethod); 2508Assert.False(sourceAssembly.MightContainExtensionMethods); 2730Assert.False(methodSymbol.IsFromCompilation(compilation)); 2740Assert.False(methodSymbol.IsFromCompilation(compilation));
Symbols\FunctionPointerTypeSymbolTests.cs (19)
915Assert.False(ret1.Equals(ret2, TypeCompareKind.ConsiderEverything)); 916Assert.False(ret1.Equals(ret2, TypeCompareKind.AllNullableIgnoreOptions)); 952Assert.False(s1.Equals(s2, TypeCompareKind.ConsiderEverything)); 953Assert.False(s1.Equals(s2, TypeCompareKind.AllNullableIgnoreOptions)); 1063Assert.False(param1.Type.Equals(param2.Type, TypeCompareKind.ConsiderEverything)); 1273Assert.False(nestedTypeInfo.Type!.IsErrorType()); 2028Assert.False(ptr1.NoRef.Equals(ptr2.ByRef, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2029Assert.False(ptr1.NoRef.Equals(ptr2.ByRef, TypeCompareKind.ConsiderEverything)); 2030Assert.False(ptr1.ByRef.Equals(ptr2.NoRef, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2031Assert.False(ptr1.ByRef.Equals(ptr2.NoRef, TypeCompareKind.ConsiderEverything)); 2098Assert.False(ptr1.NoRef.Equals(ptr2.ByRef, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2099Assert.False(ptr1.NoRef.Equals(ptr2.ByRef, TypeCompareKind.ConsiderEverything)); 2100Assert.False(ptr1.ByRef.Equals(ptr2.NoRef, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2101Assert.False(ptr1.ByRef.Equals(ptr2.NoRef, TypeCompareKind.ConsiderEverything)); 2154Assert.False(ptr1.NoRef.Equals(ptr2.ByRef, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2155Assert.False(ptr1.NoRef.Equals(ptr2.ByRef, TypeCompareKind.ConsiderEverything)); 2156Assert.False(ptr1.ByRef.Equals(ptr2.NoRef, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2157Assert.False(ptr1.ByRef.Equals(ptr2.NoRef, TypeCompareKind.ConsiderEverything)); 2167Assert.False(ptr1.ByRef.Equals(ptr2.ByRef, TypeCompareKind.ConsiderEverything));
Symbols\GenericConstraintTests.cs (56)
3418Assert.False(((NamedTypeSymbol)constraintType).IsSerializable); 3752Assert.False(i2.IsErrorType()); 3755Assert.False(i2.MangleName); 3786Assert.False(i2.IsErrorType()); 3789Assert.False(i2.MangleName); 3820Assert.False(i2.IsErrorType()); 3854Assert.False(i2.IsErrorType()); 3857Assert.False(i2.MangleName); 3903Assert.False(i2.IsErrorType()); 3906Assert.False(i2.MangleName); 3911Assert.False(iEquatable.IsErrorType()); 3929Assert.False(t.IsErrorType()); 3938Assert.False(t.MangleName); 3943Assert.False(t.IsErrorType()); 3952Assert.False(t.MangleName); 3957Assert.False(t.IsErrorType()); 3971Assert.False(t.IsErrorType()); 3985Assert.False(t.IsErrorType()); 3987Assert.False(t.MangleName); 3992Assert.False(t.IsErrorType()); 3994Assert.False(t.MangleName); 4001Assert.False(t.MangleName); 4006Assert.False(t.IsErrorType()); 4008Assert.False(t.MangleName); 4013Assert.False(t.IsErrorType()); 4015Assert.False(t.MangleName); 4027Assert.False(t.IsErrorType()); 4029Assert.False(t.MangleName); 4034Assert.False(t.IsErrorType()); 4036Assert.False(t.MangleName); 4050Assert.False(t.MangleName); 4083Assert.False(t.IsErrorType()); 4085Assert.False(t.MangleName); 4092Assert.False(t.MangleName); 4097Assert.False(t.IsErrorType()); 4099Assert.False(t.MangleName); 4141Assert.False(t.IsErrorType()); 4152Assert.False(t.IsErrorType()); 4163Assert.False(t.IsErrorType()); 4177Assert.False(t.IsErrorType()); 4191Assert.False(t.IsErrorType()); 4193Assert.False(t.MangleName); 4198Assert.False(t.IsErrorType()); 4200Assert.False(t.MangleName); 4209Assert.False(t.IsErrorType()); 4211Assert.False(t.MangleName); 4216Assert.False(t.IsErrorType()); 4218Assert.False(t.MangleName); 4230Assert.False(t.IsErrorType()); 4232Assert.False(t.MangleName); 4237Assert.False(t.IsErrorType()); 4239Assert.False(t.MangleName); 4274Assert.False(t.IsErrorType()); 4276Assert.False(t.MangleName); 4285Assert.False(t.IsErrorType()); 4287Assert.False(t.MangleName);
Symbols\ImplicitClassTests.cs (4)
38Assert.False(implicitClass.IsSubmissionClass); 39Assert.False(implicitClass.IsScriptClass); 67Assert.False(scriptClass.IsSubmissionClass); 89Assert.False(@event.TypeWithAnnotations.IsDefault);
Symbols\IndexedPropertyTests.cs (10)
989Assert.False(property.MustCallMethodsDirectly); 1005Assert.False(property.MustCallMethodsDirectly); 1006Assert.False(property.CanCallMethodsDirectly()); 1007Assert.False(property.GetMethod.CanBeReferencedByName); 1008Assert.False(property.GetMethod.CanBeReferencedByNameIgnoringIllegalCharacters); 1009Assert.False(property.SetMethod.CanBeReferencedByName); 1010Assert.False(property.SetMethod.CanBeReferencedByNameIgnoringIllegalCharacters); 1091Assert.False(property.MustCallMethodsDirectly); 1097Assert.False(property.MustCallMethodsDirectly); 1099Assert.False(property.GetMethod.CanBeReferencedByName);
Symbols\IndexerTests.cs (7)
1161Assert.False(interfaceIndexer.CanBeReferencedByName); 1175Assert.False(classEventImpl.CanBeReferencedByName); 1176Assert.False(classPropertyImpl.CanBeReferencedByName); 1177Assert.False(classIndexerImpl.CanBeReferencedByName); 1185Assert.False(classIndexer.CanBeReferencedByName); 1247Assert.False(classCIndexer.IsIndexer()); //not the default member of C 2407Assert.False(indexer.GetMethod.Parameters.IsEmpty);
Symbols\InterfaceImplementationTests.cs (26)
579Assert.False(baseClass.AllInterfaces().Contains(@interface)); 590Assert.False(class2.AllInterfaces().Contains(@interface)); 629Assert.False(baseClass.AllInterfaces().Contains(@interface)); 639Assert.False(class2.AllInterfaces().Contains(@interface)); 749Assert.False(baseClassMethodNonVirtual.IsVirtual); 765Assert.False(class1MethodNonVirtual.IsOverride); 783Assert.False(class2MethodNonVirtual.IsOverride); 831Assert.False(nonDeclaring1.InterfacesAndTheirBaseInterfacesNoUseSiteDiagnostics.ContainsKey(@interface)); 840Assert.False(nonDeclaring2.InterfacesAndTheirBaseInterfacesNoUseSiteDiagnostics.ContainsKey(@interface)); 879Assert.False(derivedClass.InterfacesAndTheirBaseInterfacesNoUseSiteDiagnostics.ContainsKey(@interface)); 918Assert.False(baseClass.AllInterfaces().Contains(@interface)); 925Assert.False(baseClassMethod.IsVirtual); 926Assert.False(baseClassProperty.IsVirtual); 927Assert.False(baseClassPropertyGetter.IsVirtual); 928Assert.False(baseClassPropertySetter.IsVirtual); 942Assert.False(derivedClass.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Any()); 987Assert.False(baseClass.AllInterfaces().Contains(@interface)); 994Assert.False(baseClassMethod.IsVirtual); 995Assert.False(baseClassProperty.IsVirtual); 996Assert.False(baseClassPropertyGetter.IsVirtual); 997Assert.False(baseClassPropertySetter.IsVirtual); 1007Assert.False(((Cci.IMethodDefinition)baseClassMethod.GetCciAdapter()).IsVirtual); 1008Assert.False(((Cci.IMethodDefinition)baseClassPropertyGetter.GetCciAdapter()).IsVirtual); 1009Assert.False(((Cci.IMethodDefinition)baseClassPropertySetter.GetCciAdapter()).IsVirtual); 1057Assert.False(comp.GetDiagnostics().Any()); 1768Assert.False(interfaceProperty.IsIndexer);
Symbols\LocalFunctionTests.cs (4)
37Assert.False(local.IsStatic); 79Assert.False(local.IsStatic); 102Assert.False(local.RequiresInstanceReceiver); 104Assert.False(staticLocal.RequiresInstanceReceiver);
Symbols\Metadata\MetadataMemberTests.cs (42)
167Assert.False(ctor.IsStatic); 168Assert.False(ctor.IsSealed); 169Assert.False(ctor.IsOverride); 170Assert.False(ctor.IsExtensionMethod); 172Assert.False(ctor.IsVararg); 210Assert.False(member1.IsAbstract); 211Assert.False(member1.IsSealed); 212Assert.False(member1.IsVirtual); 213Assert.False(member1.IsOverride); 216Assert.False(member1.IsGenericMethod); 219Assert.False(member1.ReturnsVoid); 220Assert.False(member1.IsVararg); 271Assert.False(p1.IsStatic); 272Assert.False(p1.IsAbstract); 273Assert.False(p2.IsSealed); 274Assert.False(p2.IsVirtual); 275Assert.False(p3.IsOverride); 276Assert.False(p3.IsParams); 277Assert.False(p3.IsParamsArray); 278Assert.False(p3.IsParamsCollection); 279Assert.False(p4.IsOptional); 280Assert.False(p4.HasExplicitDefaultValue); 317Assert.False(member1.IsStatic); 319Assert.False(member2.IsSealed); 320Assert.False(member2.IsVirtual); 321Assert.False(member2.IsOverride); 324Assert.False(member1.IsGenericMethod); 328Assert.False(member2.IsVararg); 367Assert.False(p1.IsStatic); 368Assert.False(p1.IsAbstract); 369Assert.False(p2.IsSealed); 370Assert.False(p2.IsVirtual); 371Assert.False(p1.IsOverride); 372Assert.False(p1.IsExtern); 373Assert.False(p1.IsParams); 374Assert.False(p1.IsParamsArray); 375Assert.False(p1.IsParamsCollection); 376Assert.False(p2.IsOptional); 377Assert.False(p2.HasExplicitDefaultValue); 395Assert.False(compilation.GetDiagnostics().Any()); 498Assert.False(propWithoutGetter.MustCallMethodsDirectly); 504Assert.False(propWithoutSetter.MustCallMethodsDirectly);
Symbols\Metadata\MetadataTypeTests.cs (40)
42Assert.False(ns.IsType); 48Assert.False(ns.IsAbstract); 49Assert.False(ns.IsSealed); 50Assert.False(ns.IsVirtual); 51Assert.False(ns.IsOverride); 83Assert.False(class1.IsNamespace); 86Assert.False(class1.IsValueType); 92Assert.False(class1.IsAbstract); 93Assert.False(class1.IsAbstract); 94Assert.False(class1.IsExtern); 95Assert.False(class1.IsSealed); 96Assert.False(class1.IsVirtual); 97Assert.False(class1.IsOverride); 133Assert.False(type1.IsNamespace); 136Assert.False(type1.IsValueType); 141Assert.False(type1.IsStatic); 142Assert.False(type1.IsAbstract); 143Assert.False(type1.IsSealed); 144Assert.False(type1.IsVirtual); 145Assert.False(type1.IsOverride); 181Assert.False(type1.IsNamespace); 184Assert.False(type1.IsValueType); 189Assert.False(type1.IsStatic); 191Assert.False(type1.IsSealed); 192Assert.False(type1.IsVirtual); 193Assert.False(type1.IsOverride); 194Assert.False(type1.IsExtern); 231Assert.False(type1.IsNamespace); 233Assert.False(type1.IsReferenceType); 239Assert.False(type1.IsStatic); 240Assert.False(type1.IsAbstract); 242Assert.False(type1.IsVirtual); 243Assert.False(type1.IsOverride); 320Assert.False(type2.IsNamespace); 326Assert.False(type3.IsValueType); 328Assert.False(type2.IsStatic); 329Assert.False(type2.IsAbstract); 330Assert.False(type2.IsSealed); 331Assert.False(type3.IsVirtual); 332Assert.False(type3.IsOverride);
Symbols\Metadata\PE\BaseTypeResolution.cs (10)
344Assert.False(test1.BaseType().IsErrorType()); 345Assert.False(test1.BaseType().BaseType().IsErrorType()); 346Assert.False(test2.BaseType().IsErrorType()); 347Assert.False(test2.BaseType().BaseType().IsErrorType()); 348Assert.False(test2.BaseType().BaseType().BaseType().IsErrorType()); 364Assert.False(m3.BaseType().IsErrorType()); 365Assert.False(m3.BaseType().BaseType().IsErrorType()); 366Assert.False(m4.BaseType().IsErrorType()); 367Assert.False(m4.BaseType().BaseType().IsErrorType()); 375Assert.False(m4.BaseType().IsErrorType());
Symbols\Metadata\PE\DynamicTransformsTests.cs (18)
58Assert.False(_base0Class.ContainsDynamic()); 62Assert.False(_base1Class.ContainsDynamic()); 66Assert.False(_base2Class.ContainsDynamic()); 69Assert.False(_derivedClass.ContainsDynamic()); 89Assert.False(_outerClass.ContainsDynamic()); 95Assert.False(_innerClass.ContainsDynamic()); 101Assert.False(_innerInnerClass.ContainsDynamic()); 106Assert.False(_outer2Class.ContainsDynamic()); 111Assert.False(_inner2Class.ContainsDynamic()); 112Assert.False(_inner2Class.BaseType().ContainsDynamic()); 116Assert.False(_innerInner2Class.ContainsDynamic()); 117Assert.False(_innerInner2Class.BaseType().ContainsDynamic()); 121Assert.False(_inner3Class.ContainsDynamic()); 329Assert.False(unsafeClass.ContainsDynamic()); 367Assert.False(structType.ContainsDynamic()); 559Assert.False(field1.Type.ContainsDynamic()); 563Assert.False(field1.Type.ContainsDynamic()); 568Assert.False(field1.Type.ContainsDynamic());
Symbols\Metadata\PE\HasUnsupportedMetadata.cs (11)
163Assert.False(c3.HasUnsupportedMetadata); 164Assert.False(c3.ContainingSymbol.HasUnsupportedMetadata); 168Assert.False(f1.HasUnsupportedMetadata); 172Assert.False(m1.HasUnsupportedMetadata); 176Assert.False(x.HasUnsupportedMetadata); 180Assert.False(e1.HasUnsupportedMetadata); 184Assert.False(p1.HasUnsupportedMetadata); 367Assert.False(c3.HasUnsupportedMetadata); 368Assert.False(c3.ContainingSymbol.HasUnsupportedMetadata); 394Assert.False(vector.HasUnsupportedMetadata); 404Assert.False(typeX.HasUnsupportedMetadata);
Symbols\Metadata\PE\LoadCustomModifiers.cs (2)
110Assert.False(m7.ReturnsVoid); 142Assert.False(MemberSignatureComparer.RuntimeImplicitImplementationComparer.Equals(method1, method2));
Symbols\Metadata\PE\LoadingEvents.cs (1)
76Assert.False(instanceEvent.IsStatic);
Symbols\Metadata\PE\LoadingFields.cs (26)
47Assert.False(f1.IsAbstract); 48Assert.False(f1.IsConst); 50Assert.False(f1.IsExtern); 51Assert.False(f1.IsOverride); 52Assert.False(f1.IsReadOnly); 53Assert.False(f1.IsSealed); 55Assert.False(f1.IsVirtual); 56Assert.False(f1.IsVolatile); 66Assert.False(f2.IsConst); 68Assert.False(f2.IsStatic); 69Assert.False(f2.IsVolatile); 74Assert.False(f3.IsConst); 75Assert.False(f3.IsReadOnly); 76Assert.False(f3.IsStatic); 77Assert.False(f3.IsVolatile); 82Assert.False(f4.IsConst); 83Assert.False(f4.IsReadOnly); 84Assert.False(f4.IsStatic); 85Assert.False(f4.IsVolatile); 91Assert.False(f5.IsReadOnly); 93Assert.False(f5.IsVolatile); 98Assert.False(f6.IsConst); 99Assert.False(f6.IsReadOnly); 100Assert.False(f6.IsStatic); 106Assert.False(mod.IsOptional); 151Assert.False(readOnlySpanType.IsErrorType());
Symbols\Metadata\PE\LoadingGenericTypeParameters.cs (23)
60Assert.False(varC1_T.HasConstructorConstraint); 61Assert.False(varC1_T.HasReferenceTypeConstraint); 62Assert.False(varC1_T.HasValueTypeConstraint); 65Assert.False(varC1_T.IsAbstract); 66Assert.False(varC1_T.IsNamespace); 67Assert.False(varC1_T.IsSealed); 68Assert.False(varC1_T.IsVirtual); 69Assert.False(varC1_T.IsOverride); 70Assert.False(varC1_T.IsStatic); 127Assert.False(varT.HasConstructorConstraint); 128Assert.False(varT.HasReferenceTypeConstraint); 129Assert.False(varT.HasValueTypeConstraint); 134Assert.False(varT.HasConstructorConstraint); 135Assert.False(varT.HasReferenceTypeConstraint); 136Assert.False(varT.HasValueTypeConstraint); 142Assert.False(varT.HasReferenceTypeConstraint); 143Assert.False(varT.HasValueTypeConstraint); 149Assert.False(varT.HasConstructorConstraint); 151Assert.False(varT.HasValueTypeConstraint); 157Assert.False(varT.HasConstructorConstraint); 158Assert.False(varT.HasReferenceTypeConstraint); 167Assert.False(varT.HasValueTypeConstraint); 174Assert.False(varT.HasValueTypeConstraint);
Symbols\Metadata\PE\LoadingIndexers.cs (14)
614Assert.False(instanceIndexer.IsStatic); 726Assert.False(parameterModoptIndexer.MustCallMethodsDirectly); //NB: we allow this amount of variation (modopt is on, rather than in parameter type) 731Assert.False(returnTypeModoptIndexer.MustCallMethodsDirectly); //NB: we allow this amount of variation (modopt is on, rather than in return type) 919Assert.False(readWrite.MustCallMethodsDirectly); 922Assert.False(readWrite.Parameters.Last().IsParamsCollection); 926Assert.False(readOnly.MustCallMethodsDirectly); 929Assert.False(readOnly.Parameters.Last().IsParamsCollection); 933Assert.False(writeOnly.MustCallMethodsDirectly); 936Assert.False(writeOnly.Parameters.Last().IsParamsCollection); 1010Assert.False(readWrite.Parameters.Last().IsParams); //favour setter 1011Assert.False(readWrite.Parameters.Last().IsParamsArray); //favour setter 1012Assert.False(readWrite.Parameters.Last().IsParamsCollection); //favour setter 1019Assert.False(readOnly.Parameters.Last().IsParamsCollection); //favour setter 1177Assert.False(classIndexer.IsIndexer);
Symbols\Metadata\PE\LoadingMethods.cs (128)
70Assert.False(localM1_1.IsAbstract); 71Assert.False(localM1_1.IsSealed); 72Assert.False(localM1_1.IsVirtual); 73Assert.False(localM1_1.IsOverride); 74Assert.False(localM1_1.IsStatic); 75Assert.False(localM1_1.IsExtern); 79Assert.False(localM3.ReturnsVoid); 83Assert.False(localM4.ReturnsVoid); 117Assert.False(basicC1_M1.Parameters[0].IsOptional); 118Assert.False(basicC1_M1.Parameters[0].HasExplicitDefaultValue); 122Assert.False(basicC1_M2.Parameters[0].HasExplicitDefaultValue); 128Assert.False(basicC1_M4.Parameters[0].HasExplicitDefaultValue); 140Assert.False(basicC1_M5.IsGenericMethod); // Check genericity before cracking signature 142Assert.False(basicC1_M6.IsGenericMethod); // Check genericity after cracking signature 164Assert.False(basicC1_M12.IsVararg); 165Assert.False(basicC1_M12.IsExtern); 166Assert.False(basicC1_M12.IsStatic); 195Assert.False(basicModifiers1_M1.IsVirtual); 196Assert.False(basicModifiers1_M1.IsSealed); 198Assert.False(basicModifiers1_M1.IsOverride); 200Assert.False(basicModifiers1_M2.IsAbstract); 202Assert.False(basicModifiers1_M2.IsSealed); 204Assert.False(basicModifiers1_M2.IsOverride); 206Assert.False(basicModifiers1_M3.IsAbstract); 207Assert.False(basicModifiers1_M3.IsVirtual); 208Assert.False(basicModifiers1_M3.IsSealed); 209Assert.False(basicModifiers1_M3.HidesBaseMethodsByName); 210Assert.False(basicModifiers1_M3.IsOverride); 212Assert.False(basicModifiers1_M4.IsAbstract); 213Assert.False(basicModifiers1_M4.IsVirtual); 214Assert.False(basicModifiers1_M4.IsSealed); 216Assert.False(basicModifiers1_M4.IsOverride); 218Assert.False(basicModifiers1_M5.IsAbstract); 219Assert.False(basicModifiers1_M5.IsVirtual); 220Assert.False(basicModifiers1_M5.IsSealed); 222Assert.False(basicModifiers1_M5.IsOverride); 225Assert.False(basicModifiers1_M6.IsVirtual); 226Assert.False(basicModifiers1_M6.IsSealed); 227Assert.False(basicModifiers1_M6.HidesBaseMethodsByName); 228Assert.False(basicModifiers1_M6.IsOverride); 230Assert.False(basicModifiers1_M7.IsAbstract); 232Assert.False(basicModifiers1_M7.IsSealed); 233Assert.False(basicModifiers1_M7.HidesBaseMethodsByName); 234Assert.False(basicModifiers1_M7.IsOverride); 237Assert.False(basicModifiers1_M8.IsVirtual); 238Assert.False(basicModifiers1_M8.IsSealed); 240Assert.False(basicModifiers1_M8.IsOverride); 242Assert.False(basicModifiers1_M9.IsAbstract); 244Assert.False(basicModifiers1_M9.IsSealed); 246Assert.False(basicModifiers1_M9.IsOverride); 256Assert.False(basicModifiers2_M1.IsVirtual); 257Assert.False(basicModifiers2_M1.IsSealed); 261Assert.False(basicModifiers2_M2.IsAbstract); 262Assert.False(basicModifiers2_M2.IsVirtual); 268Assert.False(basicModifiers2_M6.IsVirtual); 269Assert.False(basicModifiers2_M6.IsSealed); 270Assert.False(basicModifiers2_M6.HidesBaseMethodsByName); 273Assert.False(basicModifiers2_M7.IsAbstract); 274Assert.False(basicModifiers2_M7.IsVirtual); 276Assert.False(basicModifiers2_M7.HidesBaseMethodsByName); 284Assert.False(basicModifiers3_M1.IsAbstract); 285Assert.False(basicModifiers3_M1.IsVirtual); 286Assert.False(basicModifiers3_M1.IsSealed); 290Assert.False(basicModifiers3_M6.IsAbstract); 291Assert.False(basicModifiers3_M6.IsVirtual); 292Assert.False(basicModifiers3_M6.IsSealed); 293Assert.False(basicModifiers3_M6.HidesBaseMethodsByName); 304Assert.False(csharpModifiers1_M1.IsVirtual); 305Assert.False(csharpModifiers1_M1.IsSealed); 306Assert.False(csharpModifiers1_M1.HidesBaseMethodsByName); 307Assert.False(csharpModifiers1_M1.IsOverride); 309Assert.False(csharpModifiers1_M2.IsAbstract); 311Assert.False(csharpModifiers1_M2.IsSealed); 312Assert.False(csharpModifiers1_M2.HidesBaseMethodsByName); 313Assert.False(csharpModifiers1_M2.IsOverride); 315Assert.False(csharpModifiers1_M3.IsAbstract); 316Assert.False(csharpModifiers1_M3.IsVirtual); 317Assert.False(csharpModifiers1_M3.IsSealed); 318Assert.False(csharpModifiers1_M3.HidesBaseMethodsByName); 319Assert.False(csharpModifiers1_M3.IsOverride); 321Assert.False(csharpModifiers1_M4.IsAbstract); 323Assert.False(csharpModifiers1_M4.IsSealed); 324Assert.False(csharpModifiers1_M4.HidesBaseMethodsByName); 325Assert.False(csharpModifiers1_M4.IsOverride); 333Assert.False(csharpModifiers2_M1.IsAbstract); 334Assert.False(csharpModifiers2_M1.IsVirtual); 336Assert.False(csharpModifiers2_M1.HidesBaseMethodsByName); 340Assert.False(csharpModifiers2_M2.IsVirtual); 341Assert.False(csharpModifiers2_M2.IsSealed); 342Assert.False(csharpModifiers2_M2.HidesBaseMethodsByName); 345Assert.False(csharpModifiers2_M3.IsAbstract); 347Assert.False(csharpModifiers2_M3.IsSealed); 348Assert.False(csharpModifiers2_M3.HidesBaseMethodsByName); 349Assert.False(csharpModifiers2_M3.IsOverride); 357Assert.False(csharpModifiers3_M1.IsAbstract); 358Assert.False(csharpModifiers3_M1.IsVirtual); 359Assert.False(csharpModifiers3_M1.IsSealed); 360Assert.False(csharpModifiers3_M1.HidesBaseMethodsByName); 363Assert.False(csharpModifiers3_M3.IsAbstract); 364Assert.False(csharpModifiers3_M3.IsVirtual); 365Assert.False(csharpModifiers3_M3.IsSealed); 366Assert.False(csharpModifiers3_M3.HidesBaseMethodsByName); 367Assert.False(csharpModifiers3_M3.IsOverride); 370Assert.False(csharpModifiers3_M4.IsVirtual); 371Assert.False(csharpModifiers3_M4.IsSealed); 372Assert.False(csharpModifiers3_M4.HidesBaseMethodsByName); 373Assert.False(csharpModifiers3_M4.IsOverride); 556Assert.False(explicitImpls.Any()); 966Assert.False(method.IsVirtual); 967Assert.False(method.IsOverride); 968Assert.False(method.IsAbstract); 969Assert.False(method.IsSealed); 973Assert.False(method.IsOverride); 974Assert.False(method.IsAbstract); 975Assert.False(method.IsSealed); 978Assert.False(method.IsVirtual); 980Assert.False(method.IsAbstract); 981Assert.False(method.IsSealed); 984Assert.False(method.IsVirtual); 986Assert.False(method.IsAbstract); 990Assert.False(method.IsVirtual); 991Assert.False(method.IsOverride); 993Assert.False(method.IsSealed); 996Assert.False(method.IsVirtual); 999Assert.False(method.IsSealed); 1244Assert.False(((MethodSymbol)m).IsVirtual); 1246Assert.False(((MethodSymbol)m).IsOverride); 1352Assert.False(method.ReturnTypeWithAnnotations.IsDefault);
Symbols\Metadata\PE\LoadingNamespacesAndTypes.cs (4)
144Assert.False(systemNS.IsGlobalNamespace); 157Assert.False(collectionsNS.IsGlobalNamespace); 314Assert.False(constructor.IsImplicitlyDeclared); 364Assert.False(constructors[withParameterIndex].IsImplicitlyDeclared);
Symbols\Metadata\PE\MissingTypeReferences.cs (12)
47Assert.False(@base.IsNamespace); 65Assert.False(@base.IsNamespace); 102Assert.False(@base.IsNamespace); 131Assert.False(@base.IsNamespace); 146Assert.False(@base.IsNamespace); 161Assert.False(@base.IsNamespace); 178Assert.False(@base.IsNamespace); 195Assert.False(@base.IsNamespace); 214Assert.False(@base.IsNamespace); 232Assert.False(@base.IsNamespace); 254Assert.False(@base.IsNamespace); 379Assert.False(missingAssembly.Equals(null));
Symbols\Metadata\PE\NoPia.cs (22)
309Assert.False(ambiguous.IsSerializable); 535Assert.False(missing.IsSerializable); 756Assert.False(pia1Ref.Properties.EmbedInteropTypes); 758Assert.False(pia5Ref.Properties.EmbedInteropTypes); 760Assert.False(library2Ref.Properties.EmbedInteropTypes); 776Assert.False(pia5Asm2.IsLinked); 788Assert.False(library2Asm3.IsLinked); 801Assert.False(pia5Asm4.IsLinked); 802Assert.False(library2Asm4.IsLinked); 820Assert.False(library2Asm5.IsLinked); 836Assert.False(pia1Asm6.IsLinked); 838Assert.False(library2Asm6.IsLinked); 1111Assert.False(pia5Ref.Properties.EmbedInteropTypes); 1119Assert.False(pia1Ref.Properties.EmbedInteropTypes); 1127Assert.False(library2Ref.Properties.EmbedInteropTypes); 1143Assert.False(pia5Asm2.IsLinked); 1155Assert.False(library2Asm3.IsLinked); 1168Assert.False(pia5Asm4.IsLinked); 1169Assert.False(library2Asm4.IsLinked); 1187Assert.False(library2Asm5.IsLinked); 1203Assert.False(pia1Asm6.IsLinked); 1205Assert.False(library2Asm6.IsLinked);
Symbols\Metadata\PE\TypeForwarders.cs (4)
186Assert.False(baseType.IsErrorType()); 426Assert.False(baseType.IsErrorType()); 1716Assert.False(token.IsNil); //could the type ref be located? If not then the attribute's not there. 1920Assert.False(resolved.IsErrorType());
Symbols\Metadata\PE\TypeKindTests.cs (9)
77Assert.False(obj.IsAbstract); 78Assert.False(obj.IsSealed); 79Assert.False(obj.IsStatic); 82Assert.False(@enum.IsSealed); 83Assert.False(@enum.IsStatic); 85Assert.False(func.IsAbstract); 87Assert.False(func.IsStatic); 91Assert.False(console.IsAbstract); 92Assert.False(console.IsSealed);
Symbols\MissingSpecialMember.cs (1)
685Assert.False(wkt.IsValueTupleType());
Symbols\MockSymbolTests.cs (3)
34Assert.False(ats1.IsValueType); 42Assert.False(ats2.IsValueType); 58Assert.False(pts1.IsReferenceType);
Symbols\OverriddenOrHiddenMembersTests.cs (36)
275Assert.False(derivedInterface1MethodOverriddenOrHidden.OverriddenMembers.Any()); 279Assert.False(derivedInterface1PropertyOverriddenOrHidden.OverriddenMembers.Any()); 283Assert.False(derivedInterface2MethodOverriddenOrHidden.OverriddenMembers.Any()); 287Assert.False(derivedInterface2PropertyOverriddenOrHidden.OverriddenMembers.Any()); 370Assert.False(derivedInterface1MethodIntOverriddenOrHidden.OverriddenMembers.Any()); 374Assert.False(derivedInterface1PropertyOverriddenOrHidden.OverriddenMembers.Any()); 378Assert.False(derivedInterface2MethodIntOverriddenOrHidden.OverriddenMembers.Any()); 382Assert.False(derivedInterface2PropertyOverriddenOrHidden.OverriddenMembers.Any()); 433Assert.False(derivedClassMethodOverriddenOrHidden.OverriddenMembers.Any()); 437Assert.False(derivedClassPropertyOverriddenOrHidden.OverriddenMembers.Any()); 486Assert.False(derivedClassMethodIntOverriddenOrHidden.OverriddenMembers.Any()); 490Assert.False(derivedClassPropertyOverriddenOrHidden.OverriddenMembers.Any()); 550Assert.False(derivedClassMethodOverriddenOrHidden.HiddenMembers.Any()); 554Assert.False(derivedClassPropertyOverriddenOrHidden.HiddenMembers.Any()); 558Assert.False(derivedClassRefMethodOverriddenOrHidden.HiddenMembers.Any()); 562Assert.False(derivedClassRefPropertyOverriddenOrHidden.HiddenMembers.Any()); 566Assert.False(derivedClassRefIndexerOverriddenOrHidden.HiddenMembers.Any()); 622Assert.False(baseClassToStringOverriddenOrHidden.HiddenMembers.Any()); 626Assert.False(baseClassGetHashCodeOverriddenOrHidden.HiddenMembers.Any()); 630Assert.False(derivedClassEqualsOverriddenOrHidden.HiddenMembers.Any()); 634Assert.False(derivedClassGetHashCodeOverriddenOrHidden.HiddenMembers.Any()); 686Assert.False(derivedClassMethodIntOverriddenOrHidden.HiddenMembers.Any()); 690Assert.False(derivedClassPropertyOverriddenOrHidden.HiddenMembers.Any()); 766Assert.False(overridingClassMethod1OverriddenOrHidden.OverriddenMembers.Any()); 772Assert.False(overridingClassMethod2OverriddenOrHidden.HiddenMembers.Any()); 777Assert.False(overridingClassProperty1OverriddenOrHidden.OverriddenMembers.Any()); 782Assert.False(overridingClassProperty2OverriddenOrHidden.HiddenMembers.Any()); 900Assert.False(comp.GetDiagnostics().Any()); 946Assert.False(classEMethod1OverriddenOrHiddenMembers.HiddenMembers.Any()); 954Assert.False(classEMethod2OverriddenOrHiddenMembers.HiddenMembers.Any()); 2870Assert.False(finalize.IsVirtual); 2871Assert.False(finalize.IsOverride); 3688Assert.False(validatorBaseT.AbstractMembers.Any()); 3695Assert.False(validatorBaseObject.AbstractMembers.Any()); 3944Assert.False(validatorBaseT.AbstractMembers.Any()); 3951Assert.False(validatorBaseObject.AbstractMembers.Any());
Symbols\PartialPropertiesTests.cs (26)
711Assert.False(prop.GetPublicSymbol().IsExtern); 712Assert.False(prop.GetMethod!.GetPublicSymbol().IsExtern); 713Assert.False(prop.SetMethod!.GetPublicSymbol().IsExtern); 799Assert.False(importData.SetLastError); 800Assert.False(importData.ExactSpelling); 2672Assert.False(p.IsAbstract); 2675Assert.False(p.IsStatic); 2676Assert.False(p.IsExtern); 2677Assert.False(p.IsOverride); 2686Assert.False(m.IsAbstract); 2691Assert.False(m.IsStatic); 2692Assert.False(m.IsExtern); 2693Assert.False(m.IsOverride); 2812Assert.False(p.IsAbstract); 2814Assert.False(p.IsSealed); 2816Assert.False(p.IsExtern); 2817Assert.False(p.IsOverride); 2826Assert.False(m.IsAbstract); 2829Assert.False(m.IsMetadataNewSlot()); 2830Assert.False(m.IsSealed); 2832Assert.False(m.IsExtern); 2833Assert.False(m.IsOverride); 5240Assert.False(implSymbol.IsPartialDefinition); 5277Assert.False(implSymbol.IsPartialDefinition); 5291Assert.False(defOfIntSymbol.IsPartialDefinition); 5324Assert.False(implSymbol.IsPartialDefinition);
Symbols\PEParameterSymbolTests.cs (3)
110Assert.False(x.IsOptional); 114Assert.False(y.IsOptional); 125Assert.False(x1.IsOptional);
Symbols\RequiredMembersTests.cs (5)
1280Assert.False(prop.IsRequired); 7179Assert.False(d.HasDeclaredRequiredMembers); 7180Assert.False(field2.IsRequired); 7181Assert.False(property2.IsRequired); 7265Assert.False(u_c.HasDeclaredRequiredMembers);
Symbols\Retargeting\RetargetCustomAttributes.cs (1)
394Assert.False(a.AttributeClass.IsErrorType());
Symbols\Retargeting\RetargetCustomModifiers.cs (7)
121Assert.False(m7.ReturnsVoid); 171Assert.False(volatileFldMod.IsOptional); 186Assert.False(volatileFld.IsConst); 187Assert.False(volatileFld.IsReadOnly); 188Assert.False(volatileFld.IsStatic); 197Assert.False(m1.HidesBaseMethodsByName); 198Assert.False(m1.IsExtensionMethod);
Symbols\Retargeting\RetargetExplicitInterfaceImplementation.cs (11)
120Assert.False(comp2.GetDiagnostics().Any()); 171Assert.False(retargetedClassCMethod2.ExplicitInterfaceImplementations.Any()); 180Assert.False(retargetedClassCMethod3.ExplicitInterfaceImplementations.Any()); 210Assert.False(retargetedClassCProperty2.ExplicitInterfaceImplementations.Any()); 218Assert.False(retargetedClassCProperty3.ExplicitInterfaceImplementations.Any()); 248Assert.False(retargetedClassCIndexer2.ExplicitInterfaceImplementations.Any()); 256Assert.False(retargetedClassCIndexer3.ExplicitInterfaceImplementations.Any()); 286Assert.False(retargetedClassCEvent2.ExplicitInterfaceImplementations.Any()); 294Assert.False(retargetedClassCEvent3.ExplicitInterfaceImplementations.Any()); 350Assert.False(comp1.GetDiagnostics().Any()); 384Assert.False(comp2.GetDiagnostics().Any());
Symbols\Retargeting\RetargetingTests.cs (3)
468Assert.False(retargetingType.IsSerializable); 915Assert.False(originalType.IsErrorType()); 916Assert.False(retargetedType.IsErrorType());
Symbols\Source\AccessTests.cs (1)
124Assert.False(comp.GetDeclarationDiagnostics().Any());
Symbols\Source\BaseClassTests.cs (12)
278Assert.False(((ITypeSymbol)members[0]).IsErrorType()); 466Assert.False(cBase.IsErrorType()); 550Assert.False(o.BaseType().IsErrorType()); 568Assert.False(p.BaseType().IsErrorType()); 589Assert.False(rBase.IsErrorType()); 609Assert.False(ifaces[0].IsErrorType()); 629Assert.False(ifaces[0].IsErrorType()); 634Assert.False(ixFaces[0].IsErrorType()); 654Assert.False(ifaces[0].IsErrorType()); 1041Assert.False(B2.IsSerializable); 1529Assert.False(baseB.IsErrorType()); 1549Assert.False(baseB.IsErrorType());
Symbols\Source\CompletionTests.cs (17)
36Assert.False(a.HasComplete(CompletionPart.StartBaseType)); 37Assert.False(a.HasComplete(CompletionPart.Members)); 41Assert.False(a.HasComplete(CompletionPart.StartBaseType)); 42Assert.False(x.HasComplete(CompletionPart.Type)); 46Assert.False(a.HasComplete(CompletionPart.StartBaseType)); 49Assert.False(a.HasComplete(CompletionPart.StartBaseType)); 50Assert.False(y.HasComplete(CompletionPart.Type)); 54Assert.False(a.HasComplete(CompletionPart.StartBaseType)); // needed to look in A's base for y's type 57Assert.False(f.HasComplete(CompletionPart.StartMethodChecks)); 58Assert.False(f.ReturnsVoid); 76Assert.False(a.HasComplete(CompletionPart.StartBaseType)); 77Assert.False(a.HasComplete(CompletionPart.Members)); 81Assert.False(a.HasComplete(CompletionPart.StartBaseType)); 85Assert.False(p.HasComplete(CompletionPart.Type)); 86Assert.False(p.HasComplete(CompletionPart.Parameters)); 91Assert.False(p.HasComplete(CompletionPart.Type)); 92Assert.False(p.HasComplete(CompletionPart.Parameters));
Symbols\Source\CustomModifierCopyTests.cs (15)
484Assert.False(customModifiers.Any()); 552Assert.False(class3Method1.Parameters.Single().TypeWithAnnotations.CustomModifiers.Any()); 604Assert.False(@class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Any()); 653Assert.False(baseM.Parameters.Single().IsParamsCollection); 656Assert.False(baseN.Parameters.Single().IsParamsCollection); 659Assert.False(derivedM.Parameters.Single().IsParamsCollection); 662Assert.False(derivedN.Parameters.Single().IsParamsCollection); 665Assert.False(derived2M.Parameters.Single().IsParamsCollection); 668Assert.False(derived2N.Parameters.Single().IsParamsCollection); 824Assert.False(baseIndexer1.Parameters.Single().IsParamsCollection); 827Assert.False(baseIndexer2.Parameters.Single().IsParamsCollection); 830Assert.False(derivedIndexer1.Parameters.Single().IsParamsCollection); 833Assert.False(derivedIndexer2.Parameters.Single().IsParamsCollection); 836Assert.False(derived2Indexer1.Parameters.Single().IsParamsCollection); 839Assert.False(derived2Indexer2.Parameters.Single().IsParamsCollection);
Symbols\Source\DeclaringSyntaxNodeTests.cs (6)
37Assert.False(symbol.IsImplicitlyDeclared); 99Assert.False(symbol.IsImplicitlyDeclared); 125Assert.False(symbol.IsImplicitlyDeclared); 192Assert.False(n1.IsImplicitlyDeclared); 334Assert.False(localType.IsImplicitlyDeclared); 366Assert.False(member.IsImplicitlyDeclared);
Symbols\Source\DelegateTests.cs (6)
132Assert.False(v.IsValueType); 134Assert.False(v.IsAbstract); 782Assert.False(d.DelegateInvokeMethod.ReturnsByRefReadonly); 798Assert.False(d.DelegateInvokeMethod.ReturnsByRef); 830Assert.False(lambda.ReturnsByRef); 837Assert.False(lambda.ReturnsByRef);
Symbols\Source\EventTests.cs (8)
86Assert.False(@event.IsStatic); 103Assert.False(associatedField.IsStatic); 162Assert.False(@event.IsVirtual); 163Assert.False(@event.IsStatic); 175Assert.False(@event.HasAssociatedField); 197Assert.False(@event.IsVirtual); 210Assert.False(@event.HasAssociatedField); 832Assert.False(eventSymbol.RequiresInstanceReceiver);
Symbols\Source\ExpressionBodiedMethodTests.cs (6)
41Assert.False(gooDef.IsPartialImplementation); 49Assert.False(gooImpl.IsPartialDefinition); 205Assert.False(m.IsImplicitlyDeclared); 209Assert.False(pp.IsImplicitlyDeclared); 213Assert.False(conv.IsImplicitlyDeclared); 304Assert.False(method.IsExplicitInterfaceImplementation);
Symbols\Source\ExpressionBodiedPropertyTests.cs (12)
262Assert.False(p.GetMethod.IsImplicitlyDeclared); 268Assert.False(indexer.GetMethod.IsImplicitlyDeclared); 509Assert.False(p.GetMethod.IsImplicitlyDeclared); 532Assert.False(p.GetMethod.IsImplicitlyDeclared); 535Assert.False(p.ReturnsByRef); 536Assert.False(p.GetMethod.ReturnsByRef); 559Assert.False(p.GetMethod.IsImplicitlyDeclared); 563Assert.False(p.ReturnsByRef); 564Assert.False(p.GetMethod.ReturnsByRef); 587Assert.False(p.GetMethod.IsImplicitlyDeclared); 591Assert.False(p.ReturnsByRef); 592Assert.False(p.GetMethod.ReturnsByRef);
Symbols\Source\FieldTests.cs (14)
69Assert.False(sym.IsStatic); 70Assert.False(sym.IsAbstract); 71Assert.False(sym.IsSealed); 72Assert.False(sym.IsVirtual); 73Assert.False(sym.IsOverride); 146Assert.False(n1.IsVolatile); 151Assert.False(n2.IsConst); 153Assert.False(n2.IsStatic); 156Assert.False(mod.IsOptional); 160Assert.False(n3.IsConst); 161Assert.False(n3.IsVolatile); 259Assert.False(mem.HasConstantValue); 520Assert.False(goo.IsFixedSizeBuffer); 534Assert.False(field.RequiresInstanceReceiver);
Symbols\Source\FileModifierTests.cs (10)
100Assert.False(((SourceMemberContainerTypeSymbol)classC).IsFileLocal); 847Assert.False(outer1.FilePathChecksumOpt.IsDefaultOrEmpty); 848Assert.False(outer2.FilePathChecksumOpt.IsDefaultOrEmpty); 849Assert.False(outer3.FilePathChecksumOpt.IsDefaultOrEmpty); 850Assert.False(outer1.FilePathChecksumOpt.SequenceEqual(outer2.FilePathChecksumOpt)); 857Assert.False(bytes1.SequenceEqual(bytes2)); 4246Assert.False(sourceTypeCByMetadataName is SourceMemberContainerTypeSymbol { IsFileLocal: true }); 4435Assert.False(type.IsFileLocal); 4458Assert.False(type.IsFileLocal); 4572Assert.False(retargeted.GetPublicSymbol().IsFileLocal);
Symbols\Source\LocalTests.cs (7)
36Assert.False(symbol.IsUsing); 38Assert.False(symbol.IsForEach()); // VB extension method works only for VB locals 64Assert.False(local.IsUsing); 90Assert.False(symbol.IsUsing); 115Assert.False(symbol.IsForEach); 140Assert.False(symbol.IsForEach); 163Assert.False(symbol.IsForEach);
Symbols\Source\MethodTests.cs (119)
370Assert.False(refP.IsValueType); 377Assert.False(outP.IsReferenceType); 379Assert.False(outP.IsStatic); 380Assert.False(outP.IsAbstract); 408Assert.False(m.ReturnType.IsReferenceType); 601Assert.False(m0.IsAbstract); 602Assert.False(m0.IsOverride); 603Assert.False(m0.IsSealed); 604Assert.False(m0.IsVirtual); 608Assert.False(m1.IsAbstract); 610Assert.False(m1.IsSealed); 611Assert.False(m1.IsVirtual); 615Assert.False(m2.IsAbstract); 617Assert.False(m2.IsSealed); 618Assert.False(m2.IsVirtual); 622Assert.False(m3.IsAbstract); 625Assert.False(m3.IsVirtual); 629Assert.False(m4.IsAbstract); 631Assert.False(m4.IsSealed); 632Assert.False(m4.IsVirtual); 636Assert.False(m5.IsAbstract); 637Assert.False(m5.IsOverride); 638Assert.False(m5.IsSealed); 639Assert.False(m5.IsVirtual); 644Assert.False(m6.IsAbstract); 646Assert.False(m6.IsSealed); 647Assert.False(m6.IsVirtual); 662Assert.False(mm.IsAbstract); 663Assert.False(mm.IsOverride); 664Assert.False(mm.IsSealed); 665Assert.False(mm.IsVirtual); 674Assert.False(m1.IsOverride); 675Assert.False(m1.IsSealed); 676Assert.False(m1.IsVirtual); 681Assert.False(m2.IsOverride); 682Assert.False(m2.IsSealed); 683Assert.False(m2.IsVirtual); 687Assert.False(m3.IsAbstract); 688Assert.False(m3.IsOverride); 689Assert.False(m3.IsSealed); 694Assert.False(m4.IsAbstract); 695Assert.False(m4.IsOverride); 696Assert.False(m4.IsSealed); 701Assert.False(m5.IsAbstract); 702Assert.False(m5.IsOverride); 703Assert.False(m5.IsSealed); 704Assert.False(m5.IsVirtual); 710Assert.False(m6.IsOverride); 711Assert.False(m6.IsSealed); 712Assert.False(m6.IsVirtual); 794Assert.False(m0.IsAbstract); 795Assert.False(m0.IsOverride); 796Assert.False(m0.IsSealed); 797Assert.False(m0.IsVirtual); 801Assert.False(m1.IsAbstract); 803Assert.False(m1.IsSealed); 804Assert.False(m1.IsVirtual); 808Assert.False(m2.IsAbstract); 810Assert.False(m2.IsSealed); 811Assert.False(m2.IsVirtual); 815Assert.False(m3.IsAbstract); 818Assert.False(m3.IsVirtual); 822Assert.False(m4.IsAbstract); 824Assert.False(m4.IsSealed); 825Assert.False(m4.IsVirtual); 829Assert.False(m5.IsAbstract); 830Assert.False(m5.IsOverride); 831Assert.False(m5.IsSealed); 832Assert.False(m5.IsVirtual); 837Assert.False(m6.IsAbstract); 839Assert.False(m6.IsSealed); 840Assert.False(m6.IsVirtual); 854Assert.False(mm.IsAbstract); 855Assert.False(mm.IsOverride); 856Assert.False(mm.IsSealed); 857Assert.False(mm.IsVirtual); 861Assert.False(m0.IsAbstract); 862Assert.False(m0.IsOverride); 863Assert.False(m0.IsSealed); 864Assert.False(m0.IsVirtual); 869Assert.False(m1.IsOverride); 870Assert.False(m1.IsSealed); 871Assert.False(m1.IsVirtual); 876Assert.False(m2.IsOverride); 877Assert.False(m2.IsSealed); 878Assert.False(m2.IsVirtual); 882Assert.False(m3.IsAbstract); 883Assert.False(m3.IsOverride); 884Assert.False(m3.IsSealed); 889Assert.False(m4.IsAbstract); 890Assert.False(m4.IsOverride); 891Assert.False(m4.IsSealed); 896Assert.False(m5.IsAbstract); 897Assert.False(m5.IsOverride); 898Assert.False(m5.IsSealed); 899Assert.False(m5.IsVirtual); 905Assert.False(m6.IsOverride); 906Assert.False(m6.IsSealed); 907Assert.False(m6.IsVirtual); 1172Assert.False(type1.IsReferenceType); 1209Assert.False(type2.IsValueType); 1266Assert.False(type1.IsValueType); 1866Assert.False(method3.IsVirtual); 1867Assert.False(method4.IsVirtual); 1871Assert.False(((Cci.IMethodDefinition)method3.GetCciAdapter()).IsVirtual); 1887Assert.False(method3.IsVirtual); 1888Assert.False(method4.IsVirtual); 2313Assert.False(method.RequiresInstanceReceiver); 2339Assert.False(method.IsConditional); 2409Assert.False(m.IsPartialDefinition); 2446Assert.False(m.PartialImplementationPart.IsPartialDefinition); 2472Assert.False(m.PartialImplementationPart.IsPartialDefinition); 2492Assert.False(m.IsPartialDefinition); 2514Assert.False(m.PartialImplementationPart.IsPartialDefinition); 2519Assert.False(m.IsPartialDefinition); 2547Assert.False(partialImpl.IsPartialDefinition); 2580Assert.False(partialDefConstructed.IsPartialDefinition); 2585Assert.False(partialImpl.IsPartialDefinition); 2586Assert.False(partialImplConstructed.IsPartialDefinition);
Symbols\Source\NamedTypeTests.cs (1)
28Assert.False(namedType.IsExplicitDefinitionOfNoPiaLocalType);
Symbols\Source\NullablePublicAPITests.cs (2)
1748Assert.False(isNullableAnalysisEnabled(comp)); 2844Assert.False(event1.Equals(event2, SymbolEqualityComparer.IncludeNullability));
Symbols\Source\PropertyTests.cs (18)
364Assert.False(p.GetMethod.IsImplicitlyDeclared); 365Assert.False(p.SetMethod.IsImplicitlyDeclared); 368Assert.False(p.GetMethod.IsImplicitlyDeclared); 369Assert.False(p.SetMethod.IsImplicitlyDeclared); 372Assert.False(q.GetMethod.IsImplicitlyDeclared); 373Assert.False(q.SetMethod.IsImplicitlyDeclared); 410Assert.False(backField.Locations.IsEmpty); 429Assert.False(backField.Locations.IsEmpty); 721Assert.False(goodStatic.MustCallMethodsDirectly); 738Assert.False(goodInstance.MustCallMethodsDirectly); 2562Assert.False(property.MustCallMethodsDirectly); 2615Assert.False(comp.ExternalReferences[1].Properties.EmbedInteropTypes); 2620Assert.False(iap.Type.IsDynamic()); 2622Assert.False(iam.ReturnType.IsDynamic()); 2633Assert.False(comp.ExternalReferences[1].Properties.EmbedInteropTypes); 2638Assert.False(iap.Type.IsDynamic()); 2640Assert.False(iam.ReturnType.IsDynamic()); 3015Assert.False(property.RequiresInstanceReceiver);
Symbols\Source\RecordTests.cs (22)
155Assert.False(x.IsReadOnly); 156Assert.False(x.IsWriteOnly); 157Assert.False(x.IsImplicitlyDeclared); 159Assert.False(x.IsVirtual); 160Assert.False(x.IsStatic); 189Assert.False(y.IsReadOnly); 190Assert.False(y.IsWriteOnly); 191Assert.False(y.IsImplicitlyDeclared); 193Assert.False(x.IsVirtual); 194Assert.False(x.IsStatic); 1431Assert.False(clone.IsOverride); 1433Assert.False(clone.IsAbstract); 1440Assert.False(clone2.IsVirtual); 1441Assert.False(clone2.IsAbstract); 1474Assert.False(clone.IsOverride); 1475Assert.False(clone.IsVirtual); 1485Assert.False(clone2.IsVirtual); 1496Assert.False(clone3.IsVirtual); 1497Assert.False(clone3.IsAbstract); 1507Assert.False(clone4.IsVirtual); 1518Assert.False(clone5.IsVirtual); 1519Assert.False(clone5.IsAbstract);
Symbols\StaticAbstractMembersInInterfacesTests.cs (1157)
153Assert.False(m01.IsVirtual); 155Assert.False(m01.IsSealed); 157Assert.False(m01.IsExtern); 158Assert.False(m01.IsAsync); 159Assert.False(m01.IsOverride); 164Assert.False(m02.IsAbstract); 167Assert.False(m02.IsSealed); 169Assert.False(m02.IsExtern); 170Assert.False(m02.IsAsync); 171Assert.False(m02.IsOverride); 176Assert.False(m03.IsAbstract); 177Assert.False(m03.IsVirtual); 178Assert.False(m03.IsMetadataVirtual()); 179Assert.False(m03.IsSealed); 181Assert.False(m03.IsExtern); 182Assert.False(m03.IsAsync); 183Assert.False(m03.IsOverride); 188Assert.False(m04.IsAbstract); 189Assert.False(m04.IsVirtual); 190Assert.False(m04.IsMetadataVirtual()); 191Assert.False(m04.IsSealed); 193Assert.False(m04.IsExtern); 194Assert.False(m04.IsAsync); 195Assert.False(m04.IsOverride); 203Assert.False(m05.IsSealed); 205Assert.False(m05.IsExtern); 206Assert.False(m05.IsAsync); 207Assert.False(m05.IsOverride); 213Assert.False(m06.IsVirtual); 215Assert.False(m06.IsSealed); 217Assert.False(m06.IsExtern); 218Assert.False(m06.IsAsync); 219Assert.False(m06.IsOverride); 225Assert.False(m07.IsVirtual); 227Assert.False(m07.IsSealed); 229Assert.False(m07.IsExtern); 230Assert.False(m07.IsAsync); 231Assert.False(m07.IsOverride); 236Assert.False(m08.IsAbstract); 239Assert.False(m08.IsSealed); 241Assert.False(m08.IsExtern); 242Assert.False(m08.IsAsync); 243Assert.False(m08.IsOverride); 248Assert.False(m09.IsAbstract); 251Assert.False(m09.IsSealed); 253Assert.False(m09.IsExtern); 254Assert.False(m09.IsAsync); 255Assert.False(m09.IsOverride); 260Assert.False(m10.IsAbstract); 261Assert.False(m10.IsVirtual); 262Assert.False(m10.IsMetadataVirtual()); 263Assert.False(m10.IsSealed); 265Assert.False(m10.IsExtern); 266Assert.False(m10.IsAsync); 267Assert.False(m10.IsOverride); 863Assert.False(m01.IsAbstract); 864Assert.False(m01.IsVirtual); 865Assert.False(m01.IsMetadataVirtual()); 866Assert.False(m01.IsSealed); 868Assert.False(m01.IsExtern); 869Assert.False(m01.IsAsync); 870Assert.False(m01.IsOverride); 973Assert.False(m01.IsAbstract); 974Assert.False(m01.IsVirtual); 975Assert.False(m01.IsMetadataVirtual()); 976Assert.False(m01.IsSealed); 978Assert.False(m01.IsExtern); 979Assert.False(m01.IsAsync); 980Assert.False(m01.IsOverride); 1003Assert.False(m01.IsAbstract); 1004Assert.False(m01.IsVirtual); 1005Assert.False(m01.IsMetadataVirtual()); 1006Assert.False(m01.IsSealed); 1008Assert.False(m01.IsExtern); 1009Assert.False(m01.IsAsync); 1010Assert.False(m01.IsOverride); 1045Assert.False(m01.IsAbstract); 1046Assert.False(m01.IsVirtual); 1047Assert.False(m01.IsMetadataVirtual()); 1048Assert.False(m01.IsSealed); 1050Assert.False(m01.IsExtern); 1051Assert.False(m01.IsAsync); 1052Assert.False(m01.IsOverride); 1060Assert.False(m01.IsAbstract); 1061Assert.False(m01.IsVirtual); 1062Assert.False(m01.IsMetadataVirtual()); 1063Assert.False(m01.IsSealed); 1065Assert.False(m01.IsExtern); 1066Assert.False(m01.IsAsync); 1067Assert.False(m01.IsOverride); 1139Assert.False(m01.IsVirtual); 1141Assert.False(m01.IsSealed); 1143Assert.False(m01.IsExtern); 1144Assert.False(m01.IsAsync); 1145Assert.False(m01.IsOverride); 1175Assert.False(m01.IsAbstract); 1178Assert.False(m01.IsSealed); 1180Assert.False(m01.IsExtern); 1181Assert.False(m01.IsAsync); 1182Assert.False(m01.IsOverride); 1212Assert.False(m01.IsAbstract); 1215Assert.False(m01.IsSealed); 1217Assert.False(m01.IsExtern); 1218Assert.False(m01.IsAsync); 1219Assert.False(m01.IsOverride); 1260Assert.False(m01.IsVirtual); 1262Assert.False(m01.IsSealed); 1264Assert.False(m01.IsExtern); 1265Assert.False(m01.IsAsync); 1266Assert.False(m01.IsOverride); 1275Assert.False(m01.IsVirtual); 1277Assert.False(m01.IsSealed); 1279Assert.False(m01.IsExtern); 1280Assert.False(m01.IsAsync); 1281Assert.False(m01.IsOverride); 1310Assert.False(m01.IsAbstract); 1313Assert.False(m01.IsSealed); 1315Assert.False(m01.IsExtern); 1316Assert.False(m01.IsAsync); 1317Assert.False(m01.IsOverride); 1325Assert.False(m01.IsAbstract); 1328Assert.False(m01.IsSealed); 1330Assert.False(m01.IsExtern); 1331Assert.False(m01.IsAsync); 1332Assert.False(m01.IsOverride); 1366Assert.False(m01.IsVirtual); 1368Assert.False(m01.IsSealed); 1370Assert.False(m01.IsExtern); 1371Assert.False(m01.IsAsync); 1372Assert.False(m01.IsOverride); 1380Assert.False(m01.IsAbstract); 1381Assert.False(m01.IsVirtual); 1382Assert.False(m01.IsMetadataVirtual()); 1383Assert.False(m01.IsSealed); 1385Assert.False(m01.IsExtern); 1386Assert.False(m01.IsAsync); 1387Assert.False(m01.IsOverride); 1423Assert.False(m01.IsAbstract); 1426Assert.False(m01.IsSealed); 1428Assert.False(m01.IsExtern); 1429Assert.False(m01.IsAsync); 1430Assert.False(m01.IsOverride); 1438Assert.False(m01.IsAbstract); 1439Assert.False(m01.IsVirtual); 1440Assert.False(m01.IsMetadataVirtual()); 1441Assert.False(m01.IsSealed); 1443Assert.False(m01.IsExtern); 1444Assert.False(m01.IsAsync); 1445Assert.False(m01.IsOverride); 1478Assert.False(m01.IsAbstract); 1481Assert.False(m01.IsSealed); 1483Assert.False(m01.IsExtern); 1484Assert.False(m01.IsAsync); 1485Assert.False(m01.IsOverride); 1493Assert.False(m01.IsAbstract); 1494Assert.False(m01.IsVirtual); 1495Assert.False(m01.IsMetadataVirtual()); 1496Assert.False(m01.IsSealed); 1498Assert.False(m01.IsExtern); 1499Assert.False(m01.IsAsync); 1500Assert.False(m01.IsOverride); 1536Assert.False(m01.IsAbstract); 1537Assert.False(m01.IsVirtual); 1538Assert.False(m01.IsMetadataVirtual()); 1539Assert.False(m01.IsSealed); 1541Assert.False(m01.IsExtern); 1542Assert.False(m01.IsAsync); 1543Assert.False(m01.IsOverride); 1552Assert.False(m01.IsVirtual); 1554Assert.False(m01.IsSealed); 1556Assert.False(m01.IsExtern); 1557Assert.False(m01.IsAsync); 1558Assert.False(m01.IsOverride); 1719Assert.False(m01.IsVirtual); 1720Assert.False(m01.IsSealed); 1722Assert.False(m01.IsExtern); 1723Assert.False(m01.IsOverride); 1728Assert.False(m02.IsAbstract); 1730Assert.False(m02.IsSealed); 1732Assert.False(m02.IsExtern); 1733Assert.False(m02.IsOverride); 1738Assert.False(m03.IsAbstract); 1739Assert.False(m03.IsVirtual); 1740Assert.False(m03.IsSealed); 1742Assert.False(m03.IsExtern); 1743Assert.False(m03.IsOverride); 1748Assert.False(m04.IsAbstract); 1749Assert.False(m04.IsVirtual); 1750Assert.False(m04.IsSealed); 1752Assert.False(m04.IsExtern); 1753Assert.False(m04.IsOverride); 1760Assert.False(m05.IsSealed); 1762Assert.False(m05.IsExtern); 1763Assert.False(m05.IsOverride); 1769Assert.False(m06.IsVirtual); 1770Assert.False(m06.IsSealed); 1772Assert.False(m06.IsExtern); 1773Assert.False(m06.IsOverride); 1779Assert.False(m07.IsVirtual); 1780Assert.False(m07.IsSealed); 1782Assert.False(m07.IsExtern); 1783Assert.False(m07.IsOverride); 1788Assert.False(m08.IsAbstract); 1790Assert.False(m08.IsSealed); 1792Assert.False(m08.IsExtern); 1793Assert.False(m08.IsOverride); 1798Assert.False(m09.IsAbstract); 1800Assert.False(m09.IsSealed); 1802Assert.False(m09.IsExtern); 1803Assert.False(m09.IsOverride); 1808Assert.False(m10.IsAbstract); 1809Assert.False(m10.IsVirtual); 1810Assert.False(m10.IsSealed); 1812Assert.False(m10.IsExtern); 1813Assert.False(m10.IsOverride); 1820Assert.False(m01.IsVirtual); 1822Assert.False(m01.IsSealed); 1824Assert.False(m01.IsExtern); 1825Assert.False(m01.IsAsync); 1826Assert.False(m01.IsOverride); 1831Assert.False(m02.IsAbstract); 1834Assert.False(m02.IsSealed); 1836Assert.False(m02.IsExtern); 1837Assert.False(m02.IsAsync); 1838Assert.False(m02.IsOverride); 1843Assert.False(m03.IsAbstract); 1844Assert.False(m03.IsVirtual); 1845Assert.False(m03.IsMetadataVirtual()); 1846Assert.False(m03.IsSealed); 1848Assert.False(m03.IsExtern); 1849Assert.False(m03.IsAsync); 1850Assert.False(m03.IsOverride); 1855Assert.False(m04.IsAbstract); 1856Assert.False(m04.IsVirtual); 1857Assert.False(m04.IsMetadataVirtual()); 1858Assert.False(m04.IsSealed); 1860Assert.False(m04.IsExtern); 1861Assert.False(m04.IsAsync); 1862Assert.False(m04.IsOverride); 1870Assert.False(m05.IsSealed); 1872Assert.False(m05.IsExtern); 1873Assert.False(m05.IsAsync); 1874Assert.False(m05.IsOverride); 1880Assert.False(m06.IsVirtual); 1882Assert.False(m06.IsSealed); 1884Assert.False(m06.IsExtern); 1885Assert.False(m06.IsAsync); 1886Assert.False(m06.IsOverride); 1892Assert.False(m07.IsVirtual); 1894Assert.False(m07.IsSealed); 1896Assert.False(m07.IsExtern); 1897Assert.False(m07.IsAsync); 1898Assert.False(m07.IsOverride); 1903Assert.False(m08.IsAbstract); 1906Assert.False(m08.IsSealed); 1908Assert.False(m08.IsExtern); 1909Assert.False(m08.IsAsync); 1910Assert.False(m08.IsOverride); 1915Assert.False(m09.IsAbstract); 1918Assert.False(m09.IsSealed); 1920Assert.False(m09.IsExtern); 1921Assert.False(m09.IsAsync); 1922Assert.False(m09.IsOverride); 1927Assert.False(m10.IsAbstract); 1928Assert.False(m10.IsVirtual); 1929Assert.False(m10.IsMetadataVirtual()); 1930Assert.False(m10.IsSealed); 1932Assert.False(m10.IsExtern); 1933Assert.False(m10.IsAsync); 1934Assert.False(m10.IsOverride); 2525Assert.False(m01.IsVirtual); 2526Assert.False(m01.IsSealed); 2528Assert.False(m01.IsExtern); 2529Assert.False(m01.IsOverride); 2534Assert.False(m02.IsAbstract); 2536Assert.False(m02.IsSealed); 2538Assert.False(m02.IsExtern); 2539Assert.False(m02.IsOverride); 2544Assert.False(m03.IsAbstract); 2545Assert.False(m03.IsVirtual); 2546Assert.False(m03.IsSealed); 2548Assert.False(m03.IsExtern); 2549Assert.False(m03.IsOverride); 2554Assert.False(m04.IsAbstract); 2555Assert.False(m04.IsVirtual); 2556Assert.False(m04.IsSealed); 2558Assert.False(m04.IsExtern); 2559Assert.False(m04.IsOverride); 2566Assert.False(m05.IsSealed); 2568Assert.False(m05.IsExtern); 2569Assert.False(m05.IsOverride); 2575Assert.False(m06.IsVirtual); 2576Assert.False(m06.IsSealed); 2578Assert.False(m06.IsExtern); 2579Assert.False(m06.IsOverride); 2585Assert.False(m07.IsVirtual); 2586Assert.False(m07.IsSealed); 2588Assert.False(m07.IsExtern); 2589Assert.False(m07.IsOverride); 2594Assert.False(m08.IsAbstract); 2596Assert.False(m08.IsSealed); 2598Assert.False(m08.IsExtern); 2599Assert.False(m08.IsOverride); 2604Assert.False(m09.IsAbstract); 2606Assert.False(m09.IsSealed); 2608Assert.False(m09.IsExtern); 2609Assert.False(m09.IsOverride); 2614Assert.False(m10.IsAbstract); 2615Assert.False(m10.IsVirtual); 2616Assert.False(m10.IsSealed); 2618Assert.False(m10.IsExtern); 2619Assert.False(m10.IsOverride); 2628Assert.False(m01.IsVirtual); 2630Assert.False(m01.IsSealed); 2632Assert.False(m01.IsExtern); 2633Assert.False(m01.IsAsync); 2634Assert.False(m01.IsOverride); 2639Assert.False(m02.IsAbstract); 2642Assert.False(m02.IsSealed); 2644Assert.False(m02.IsExtern); 2645Assert.False(m02.IsAsync); 2646Assert.False(m02.IsOverride); 2651Assert.False(m03.IsAbstract); 2652Assert.False(m03.IsVirtual); 2653Assert.False(m03.IsMetadataVirtual()); 2654Assert.False(m03.IsSealed); 2656Assert.False(m03.IsExtern); 2657Assert.False(m03.IsAsync); 2658Assert.False(m03.IsOverride); 2663Assert.False(m04.IsAbstract); 2664Assert.False(m04.IsVirtual); 2665Assert.False(m04.IsMetadataVirtual()); 2666Assert.False(m04.IsSealed); 2668Assert.False(m04.IsExtern); 2669Assert.False(m04.IsAsync); 2670Assert.False(m04.IsOverride); 2678Assert.False(m05.IsSealed); 2680Assert.False(m05.IsExtern); 2681Assert.False(m05.IsAsync); 2682Assert.False(m05.IsOverride); 2688Assert.False(m06.IsVirtual); 2690Assert.False(m06.IsSealed); 2692Assert.False(m06.IsExtern); 2693Assert.False(m06.IsAsync); 2694Assert.False(m06.IsOverride); 2700Assert.False(m07.IsVirtual); 2702Assert.False(m07.IsSealed); 2704Assert.False(m07.IsExtern); 2705Assert.False(m07.IsAsync); 2706Assert.False(m07.IsOverride); 2711Assert.False(m08.IsAbstract); 2714Assert.False(m08.IsSealed); 2716Assert.False(m08.IsExtern); 2717Assert.False(m08.IsAsync); 2718Assert.False(m08.IsOverride); 2723Assert.False(m09.IsAbstract); 2726Assert.False(m09.IsSealed); 2728Assert.False(m09.IsExtern); 2729Assert.False(m09.IsAsync); 2730Assert.False(m09.IsOverride); 2735Assert.False(m10.IsAbstract); 2736Assert.False(m10.IsVirtual); 2737Assert.False(m10.IsMetadataVirtual()); 2738Assert.False(m10.IsSealed); 2740Assert.False(m10.IsExtern); 2741Assert.False(m10.IsAsync); 2742Assert.False(m10.IsOverride); 3356Assert.False(m01.IsVirtual); 3358Assert.False(m01.IsSealed); 3360Assert.False(m01.IsExtern); 3361Assert.False(m01.IsAsync); 3362Assert.False(m01.IsOverride); 3367Assert.False(m02.IsAbstract); 3370Assert.False(m02.IsSealed); 3372Assert.False(m02.IsExtern); 3373Assert.False(m02.IsAsync); 3374Assert.False(m02.IsOverride); 3379Assert.False(m03.IsAbstract); 3380Assert.False(m03.IsVirtual); 3381Assert.False(m03.IsMetadataVirtual()); 3382Assert.False(m03.IsSealed); 3384Assert.False(m03.IsExtern); 3385Assert.False(m03.IsAsync); 3386Assert.False(m03.IsOverride); 3391Assert.False(m04.IsAbstract); 3392Assert.False(m04.IsVirtual); 3393Assert.False(m04.IsMetadataVirtual()); 3394Assert.False(m04.IsSealed); 3396Assert.False(m04.IsExtern); 3397Assert.False(m04.IsAsync); 3398Assert.False(m04.IsOverride); 3406Assert.False(m05.IsSealed); 3408Assert.False(m05.IsExtern); 3409Assert.False(m05.IsAsync); 3410Assert.False(m05.IsOverride); 3416Assert.False(m06.IsVirtual); 3418Assert.False(m06.IsSealed); 3420Assert.False(m06.IsExtern); 3421Assert.False(m06.IsAsync); 3422Assert.False(m06.IsOverride); 3428Assert.False(m07.IsVirtual); 3430Assert.False(m07.IsSealed); 3432Assert.False(m07.IsExtern); 3433Assert.False(m07.IsAsync); 3434Assert.False(m07.IsOverride); 3439Assert.False(m08.IsAbstract); 3442Assert.False(m08.IsSealed); 3444Assert.False(m08.IsExtern); 3445Assert.False(m08.IsAsync); 3446Assert.False(m08.IsOverride); 3451Assert.False(m09.IsAbstract); 3454Assert.False(m09.IsSealed); 3456Assert.False(m09.IsExtern); 3457Assert.False(m09.IsAsync); 3458Assert.False(m09.IsOverride); 3463Assert.False(m10.IsAbstract); 3464Assert.False(m10.IsVirtual); 3465Assert.False(m10.IsMetadataVirtual()); 3466Assert.False(m10.IsSealed); 3468Assert.False(m10.IsExtern); 3469Assert.False(m10.IsAsync); 3470Assert.False(m10.IsOverride); 4123Assert.False(m01.IsVirtual); 4125Assert.False(m01.IsSealed); 4127Assert.False(m01.IsExtern); 4128Assert.False(m01.IsAsync); 4129Assert.False(m01.IsOverride); 4135Assert.False(m01.IsAbstract); 4136Assert.False(m01.IsVirtual); 4137Assert.False(m01.IsMetadataVirtual()); 4138Assert.False(m01.IsSealed); 4140Assert.False(m01.IsExtern); 4141Assert.False(m01.IsAsync); 4142Assert.False(m01.IsOverride); 4149Assert.False(m01.IsVirtual); 4151Assert.False(m01.IsSealed); 4153Assert.False(m01.IsExtern); 4154Assert.False(m01.IsAsync); 4155Assert.False(m01.IsOverride); 4369Assert.False(m01.IsVirtual); 4371Assert.False(m01.IsSealed); 4373Assert.False(m01.IsExtern); 4374Assert.False(m01.IsAsync); 4375Assert.False(m01.IsOverride); 4381Assert.False(m01.IsAbstract); 4382Assert.False(m01.IsVirtual); 4383Assert.False(m01.IsMetadataVirtual()); 4384Assert.False(m01.IsSealed); 4386Assert.False(m01.IsExtern); 4387Assert.False(m01.IsAsync); 4388Assert.False(m01.IsOverride); 4395Assert.False(m01.IsVirtual); 4397Assert.False(m01.IsSealed); 4399Assert.False(m01.IsExtern); 4400Assert.False(m01.IsAsync); 4401Assert.False(m01.IsOverride); 4554Assert.False(m01.IsAbstract); 4557Assert.False(m01.IsSealed); 4559Assert.False(m01.IsExtern); 4560Assert.False(m01.IsAsync); 4561Assert.False(m01.IsOverride); 4567Assert.False(m01.IsAbstract); 4570Assert.False(m01.IsSealed); 4572Assert.False(m01.IsExtern); 4573Assert.False(m01.IsAsync); 4574Assert.False(m01.IsOverride); 4583Assert.False(m01.IsSealed); 4585Assert.False(m01.IsExtern); 4586Assert.False(m01.IsAsync); 4587Assert.False(m01.IsOverride); 4794Assert.False(m01.IsAbstract); 4797Assert.False(m01.IsSealed); 4799Assert.False(m01.IsExtern); 4800Assert.False(m01.IsAsync); 4801Assert.False(m01.IsOverride); 4807Assert.False(m01.IsAbstract); 4810Assert.False(m01.IsSealed); 4812Assert.False(m01.IsExtern); 4813Assert.False(m01.IsAsync); 4814Assert.False(m01.IsOverride); 4823Assert.False(m01.IsSealed); 4825Assert.False(m01.IsExtern); 4826Assert.False(m01.IsAsync); 4827Assert.False(m01.IsOverride); 5295Assert.False(m01.IsMetadataNewSlot()); 5298Assert.False(m01.IsMetadataFinal); 5299Assert.False(m01.IsVirtual); 5300Assert.False(m01.IsSealed); 5302Assert.False(m01.IsOverride); 5331Assert.False(m01.IsMetadataNewSlot()); 5332Assert.False(m01.IsAbstract); 5334Assert.False(m01.IsMetadataFinal); 5336Assert.False(m01.IsSealed); 5338Assert.False(m01.IsOverride); 5362Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 5363Assert.False(compilation1.Assembly.RuntimeSupportsStaticAbstractMembersInInterfaces); 5364Assert.False(compilation1.SupportsRuntimeCapability(RuntimeCapability.DefaultImplementationsOfInterfaces)); 5365Assert.False(compilation1.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 5378Assert.False(compilation2.Assembly.RuntimeSupportsStaticAbstractMembersInInterfaces); 5380Assert.False(compilation2.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 5403Assert.False(compilation1.Assembly.RuntimeSupportsDefaultInterfaceImplementation); 5404Assert.False(compilation1.Assembly.RuntimeSupportsStaticAbstractMembersInInterfaces); 5405Assert.False(compilation1.SupportsRuntimeCapability(RuntimeCapability.DefaultImplementationsOfInterfaces)); 5406Assert.False(compilation1.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 5419Assert.False(compilation2.Assembly.RuntimeSupportsStaticAbstractMembersInInterfaces); 5421Assert.False(compilation2.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 5480Assert.False(m01.IsMetadataNewSlot()); 5483Assert.False(m01.IsMetadataFinal); 5484Assert.False(m01.IsVirtual); 5485Assert.False(m01.IsSealed); 5487Assert.False(m01.IsOverride); 5548Assert.False(m01.IsMetadataNewSlot()); 5549Assert.False(m01.IsAbstract); 5551Assert.False(m01.IsMetadataFinal); 5553Assert.False(m01.IsSealed); 5555Assert.False(m01.IsOverride); 5588Assert.False(m01.IsMetadataNewSlot()); 5591Assert.False(m01.IsMetadataFinal); 5592Assert.False(m01.IsVirtual); 5593Assert.False(m01.IsSealed); 5595Assert.False(m01.IsOverride); 5632Assert.False(m01.IsMetadataNewSlot()); 5633Assert.False(m01.IsAbstract); 5635Assert.False(m01.IsMetadataFinal); 5637Assert.False(m01.IsSealed); 5639Assert.False(m01.IsOverride); 5863Assert.False(m01.IsMetadataNewSlot()); 5866Assert.False(m01.IsMetadataFinal); 5867Assert.False(m01.IsVirtual); 5868Assert.False(m01.IsSealed); 5870Assert.False(m01.IsOverride); 5902Assert.False(m01.IsMetadataNewSlot()); 5903Assert.False(m01.IsAbstract); 5905Assert.False(m01.IsMetadataFinal); 5907Assert.False(m01.IsSealed); 5909Assert.False(m01.IsOverride); 5971Assert.False(p01.IsVirtual); 5972Assert.False(p01.IsSealed); 5974Assert.False(p01.IsOverride); 5979Assert.False(m01.IsMetadataNewSlot()); 5982Assert.False(m01.IsMetadataFinal); 5983Assert.False(m01.IsVirtual); 5984Assert.False(m01.IsSealed); 5986Assert.False(m01.IsOverride); 6015Assert.False(p01.IsAbstract); 6017Assert.False(p01.IsSealed); 6019Assert.False(p01.IsOverride); 6024Assert.False(m01.IsMetadataNewSlot()); 6025Assert.False(m01.IsAbstract); 6027Assert.False(m01.IsMetadataFinal); 6029Assert.False(m01.IsSealed); 6031Assert.False(m01.IsOverride); 6109Assert.False(e01.IsVirtual); 6110Assert.False(e01.IsSealed); 6112Assert.False(e01.IsOverride); 6117Assert.False(m01.IsMetadataNewSlot()); 6120Assert.False(m01.IsMetadataFinal); 6121Assert.False(m01.IsVirtual); 6122Assert.False(m01.IsSealed); 6124Assert.False(m01.IsOverride); 6154Assert.False(e01.IsAbstract); 6156Assert.False(e01.IsSealed); 6158Assert.False(e01.IsOverride); 6163Assert.False(m01.IsMetadataNewSlot()); 6164Assert.False(m01.IsAbstract); 6166Assert.False(m01.IsMetadataFinal); 6168Assert.False(m01.IsSealed); 6170Assert.False(m01.IsOverride); 10065Assert.False(binaryIsAbstract); 10066Assert.False(op == "&" ? falseIsAbstract : trueIsAbstract); 16060Assert.False(cM01.IsAbstract); 16061Assert.False(cM01.IsVirtual); 16062Assert.False(cM01.IsMetadataVirtual()); 16063Assert.False(cM01.IsMetadataFinal); 16064Assert.False(cM01.IsMetadataNewSlot()); 16122Assert.False(cM01.IsAbstract); 16123Assert.False(cM01.IsVirtual); 16124Assert.False(cM01.IsMetadataVirtual()); 16125Assert.False(cM01.IsMetadataFinal); 16126Assert.False(cM01.IsMetadataNewSlot()); 16468Assert.False(c2M01.IsAbstract); 16469Assert.False(c2M01.IsVirtual); 16470Assert.False(c2M01.IsMetadataVirtual()); 16471Assert.False(c2M01.IsMetadataFinal); 16472Assert.False(c2M01.IsMetadataNewSlot()); 16483Assert.False(c1M01.IsAbstract); 16484Assert.False(c1M01.IsVirtual); 16485Assert.False(c1M01.IsMetadataVirtual()); 16486Assert.False(c1M01.IsMetadataFinal); 16487Assert.False(c1M01.IsMetadataNewSlot()); 16553Assert.False(c1M01.IsAbstract); 16554Assert.False(c1M01.IsVirtual); 16555Assert.False(c1M01.IsMetadataVirtual()); 16556Assert.False(c1M01.IsMetadataFinal); 16557Assert.False(c1M01.IsMetadataNewSlot()); 16569Assert.False(c1M01.IsAbstract); 16570Assert.False(c1M01.IsVirtual); 16571Assert.False(c1M01.IsMetadataVirtual()); 16572Assert.False(c1M01.IsMetadataFinal); 16573Assert.False(c1M01.IsMetadataNewSlot()); 16590Assert.False(c2M01.IsAbstract); 16591Assert.False(c2M01.IsVirtual); 16592Assert.False(c2M01.IsMetadataVirtual()); 16593Assert.False(c2M01.IsMetadataFinal); 16594Assert.False(c2M01.IsMetadataNewSlot()); 16676Assert.False(c1M01.IsAbstract); 16677Assert.False(c1M01.IsVirtual); 16678Assert.False(c1M01.IsMetadataVirtual()); 16679Assert.False(c1M01.IsMetadataFinal); 16680Assert.False(c1M01.IsMetadataNewSlot()); 16769Assert.False(c2M01.IsAbstract); 16770Assert.False(c2M01.IsVirtual); 16771Assert.False(c2M01.IsMetadataVirtual()); 16772Assert.False(c2M01.IsMetadataFinal); 16773Assert.False(c2M01.IsMetadataNewSlot()); 19851Assert.False(cM01.IsAbstract); 19852Assert.False(cM01.IsVirtual); 19853Assert.False(cM01.IsMetadataVirtual()); 19854Assert.False(cM01.IsMetadataFinal); 19855Assert.False(cM01.IsMetadataNewSlot()); 19857Assert.False(cM01.HasRuntimeSpecialName); 19932Assert.False(cM01.IsAbstract); 19933Assert.False(cM01.IsVirtual); 19934Assert.False(cM01.IsMetadataVirtual()); 19935Assert.False(cM01.IsMetadataFinal); 19936Assert.False(cM01.IsMetadataNewSlot()); 19938Assert.False(cM01.HasRuntimeSpecialName); 20024Assert.False(cM01.IsAbstract); 20025Assert.False(cM01.IsVirtual); 20026Assert.False(cM01.IsMetadataVirtual()); 20027Assert.False(cM01.IsMetadataFinal); 20028Assert.False(cM01.IsMetadataNewSlot()); 20030Assert.False(cM01.HasRuntimeSpecialName); 20122Assert.False(cM01.IsAbstract); 20123Assert.False(cM01.IsVirtual); 20124Assert.False(cM01.IsMetadataVirtual()); 20125Assert.False(cM01.IsMetadataFinal); 20126Assert.False(cM01.IsMetadataNewSlot()); 20128Assert.False(cM01.HasRuntimeSpecialName); 20129Assert.False(cM01.HasSpecialName); 20205Assert.False(cM01.IsAbstract); 20206Assert.False(cM01.IsVirtual); 20207Assert.False(cM01.IsMetadataVirtual()); 20208Assert.False(cM01.IsMetadataFinal); 20209Assert.False(cM01.IsMetadataNewSlot()); 20211Assert.False(cM01.HasRuntimeSpecialName); 20212Assert.False(cM01.HasSpecialName); 20297Assert.False(cM01.IsAbstract); 20298Assert.False(cM01.IsVirtual); 20299Assert.False(cM01.IsMetadataVirtual()); 20300Assert.False(cM01.IsMetadataFinal); 20301Assert.False(cM01.IsMetadataNewSlot()); 20303Assert.False(cM01.HasRuntimeSpecialName); 20304Assert.False(cM01.HasSpecialName); 20386Assert.False(cM01.IsAbstract); 20387Assert.False(cM01.IsVirtual); 20388Assert.False(cM01.IsMetadataVirtual()); 20389Assert.False(cM01.IsMetadataFinal); 20390Assert.False(cM01.IsMetadataNewSlot()); 20392Assert.False(cM01.HasRuntimeSpecialName); 20393Assert.False(cM01.HasSpecialName); 21341Assert.False(c2M01.IsAbstract); 21342Assert.False(c2M01.IsVirtual); 21343Assert.False(c2M01.IsMetadataVirtual()); 21344Assert.False(c2M01.IsMetadataFinal); 21345Assert.False(c2M01.IsMetadataNewSlot()); 21350Assert.False(c2M01.HasRuntimeSpecialName); 21351Assert.False(c2M01.HasSpecialName); 21359Assert.False(c1M01.IsAbstract); 21360Assert.False(c1M01.IsVirtual); 21361Assert.False(c1M01.IsMetadataVirtual()); 21362Assert.False(c1M01.IsMetadataFinal); 21363Assert.False(c1M01.IsMetadataNewSlot()); 21365Assert.False(c1M01.HasRuntimeSpecialName); 21372Assert.False(c2M01.HasRuntimeSpecialName); 21457Assert.False(c1M01.IsAbstract); 21458Assert.False(c1M01.IsVirtual); 21459Assert.False(c1M01.IsMetadataVirtual()); 21460Assert.False(c1M01.IsMetadataFinal); 21461Assert.False(c1M01.IsMetadataNewSlot()); 21473Assert.False(c1M01.IsAbstract); 21474Assert.False(c1M01.IsVirtual); 21475Assert.False(c1M01.IsMetadataVirtual()); 21476Assert.False(c1M01.IsMetadataFinal); 21477Assert.False(c1M01.IsMetadataNewSlot()); 21494Assert.False(c2M01.IsAbstract); 21495Assert.False(c2M01.IsVirtual); 21496Assert.False(c2M01.IsMetadataVirtual()); 21497Assert.False(c2M01.IsMetadataFinal); 21498Assert.False(c2M01.IsMetadataNewSlot()); 21568Assert.False(c1M01.IsAbstract); 21569Assert.False(c1M01.IsVirtual); 21570Assert.False(c1M01.IsMetadataVirtual()); 21571Assert.False(c1M01.IsMetadataFinal); 21572Assert.False(c1M01.IsMetadataNewSlot()); 21584Assert.False(c1M01.IsAbstract); 21585Assert.False(c1M01.IsVirtual); 21586Assert.False(c1M01.IsMetadataVirtual()); 21587Assert.False(c1M01.IsMetadataFinal); 21588Assert.False(c1M01.IsMetadataNewSlot()); 21605Assert.False(c2M01.IsAbstract); 21606Assert.False(c2M01.IsVirtual); 21607Assert.False(c2M01.IsMetadataVirtual()); 21608Assert.False(c2M01.IsMetadataFinal); 21609Assert.False(c2M01.IsMetadataNewSlot()); 21703Assert.False(c1M01.IsAbstract); 21704Assert.False(c1M01.IsVirtual); 21705Assert.False(c1M01.IsMetadataVirtual()); 21706Assert.False(c1M01.IsMetadataFinal); 21707Assert.False(c1M01.IsMetadataNewSlot()); 21719Assert.False(c1M01.IsAbstract); 21720Assert.False(c1M01.IsVirtual); 21721Assert.False(c1M01.IsMetadataVirtual()); 21722Assert.False(c1M01.IsMetadataFinal); 21723Assert.False(c1M01.IsMetadataNewSlot()); 21739Assert.False(c2M01.IsAbstract); 21740Assert.False(c2M01.IsVirtual); 21741Assert.False(c2M01.IsMetadataVirtual()); 21742Assert.False(c2M01.IsMetadataFinal); 21743Assert.False(c2M01.IsMetadataNewSlot()); 22007Assert.False(c1M01.IsAbstract); 22008Assert.False(c1M01.IsVirtual); 22009Assert.False(c1M01.IsMetadataVirtual()); 22010Assert.False(c1M01.IsMetadataFinal); 22011Assert.False(c1M01.IsMetadataNewSlot()); 22134Assert.False(c2M01.IsAbstract); 22135Assert.False(c2M01.IsVirtual); 22136Assert.False(c2M01.IsMetadataVirtual()); 22137Assert.False(c2M01.IsMetadataFinal); 22138Assert.False(c2M01.IsMetadataNewSlot()); 23481Assert.False(cM01.IsAbstract); 23482Assert.False(cM01.IsVirtual); 23490Assert.False(cM01Get.IsAbstract); 23491Assert.False(cM01Get.IsVirtual); 23492Assert.False(cM01Get.IsMetadataVirtual()); 23493Assert.False(cM01Get.IsMetadataFinal); 23494Assert.False(cM01Get.IsMetadataNewSlot()); 23496Assert.False(cM01Get.HasRuntimeSpecialName); 23505Assert.False(cM01Set.IsAbstract); 23506Assert.False(cM01Set.IsVirtual); 23507Assert.False(cM01Set.IsMetadataVirtual()); 23508Assert.False(cM01Set.IsMetadataFinal); 23509Assert.False(cM01Set.IsMetadataNewSlot()); 23511Assert.False(cM01Set.HasRuntimeSpecialName); 23577Assert.False(cM01.IsAbstract); 23578Assert.False(cM01.IsVirtual); 23586Assert.False(cM01Get.IsAbstract); 23587Assert.False(cM01Get.IsVirtual); 23588Assert.False(cM01Get.IsMetadataVirtual()); 23589Assert.False(cM01Get.IsMetadataFinal); 23590Assert.False(cM01Get.IsMetadataNewSlot()); 23598Assert.False(cM01Set.IsAbstract); 23599Assert.False(cM01Set.IsVirtual); 23600Assert.False(cM01Set.IsMetadataVirtual()); 23601Assert.False(cM01Set.IsMetadataFinal); 23602Assert.False(cM01Set.IsMetadataNewSlot()); 23667Assert.False(cM01.IsAbstract); 23668Assert.False(cM01.IsVirtual); 23676Assert.False(cM01Get.IsAbstract); 23677Assert.False(cM01Get.IsVirtual); 23678Assert.False(cM01Get.IsMetadataVirtual()); 23679Assert.False(cM01Get.IsMetadataFinal); 23680Assert.False(cM01Get.IsMetadataNewSlot()); 23682Assert.False(cM01Get.HasRuntimeSpecialName); 23691Assert.False(cM01Set.IsAbstract); 23692Assert.False(cM01Set.IsVirtual); 23693Assert.False(cM01Set.IsMetadataVirtual()); 23694Assert.False(cM01Set.IsMetadataFinal); 23695Assert.False(cM01Set.IsMetadataNewSlot()); 23697Assert.False(cM01Set.HasRuntimeSpecialName); 24200Assert.False(cM01.IsAbstract); 24201Assert.False(cM01.IsVirtual); 24209Assert.False(cM01Get.IsAbstract); 24210Assert.False(cM01Get.IsVirtual); 24211Assert.False(cM01Get.IsMetadataVirtual()); 24212Assert.False(cM01Get.IsMetadataFinal); 24213Assert.False(cM01Get.IsMetadataNewSlot()); 24258Assert.False(cM01.IsAbstract); 24259Assert.False(cM01.IsVirtual); 24267Assert.False(cM01Get.IsAbstract); 24268Assert.False(cM01Get.IsVirtual); 24269Assert.False(cM01Get.IsMetadataVirtual()); 24270Assert.False(cM01Get.IsMetadataFinal); 24271Assert.False(cM01Get.IsMetadataNewSlot()); 24279Assert.False(cM01Set.IsAbstract); 24280Assert.False(cM01Set.IsVirtual); 24281Assert.False(cM01Set.IsMetadataVirtual()); 24282Assert.False(cM01Set.IsMetadataFinal); 24283Assert.False(cM01Set.IsMetadataNewSlot()); 24362Assert.False(cM01.IsAbstract); 24363Assert.False(cM01.IsVirtual); 24371Assert.False(cM01Get.IsAbstract); 24372Assert.False(cM01Get.IsVirtual); 24373Assert.False(cM01Get.IsMetadataVirtual()); 24374Assert.False(cM01Get.IsMetadataFinal); 24375Assert.False(cM01Get.IsMetadataNewSlot()); 24552Assert.False(cM01.IsAbstract); 24553Assert.False(cM01.IsVirtual); 24561Assert.False(cM01Set.IsAbstract); 24562Assert.False(cM01Set.IsVirtual); 24563Assert.False(cM01Set.IsMetadataVirtual()); 24564Assert.False(cM01Set.IsMetadataFinal); 24565Assert.False(cM01Set.IsMetadataNewSlot()); 24610Assert.False(cM01.IsAbstract); 24611Assert.False(cM01.IsVirtual); 24619Assert.False(cM01Set.IsAbstract); 24620Assert.False(cM01Set.IsVirtual); 24621Assert.False(cM01Set.IsMetadataVirtual()); 24622Assert.False(cM01Set.IsMetadataFinal); 24623Assert.False(cM01Set.IsMetadataNewSlot()); 24631Assert.False(cM01Get.IsAbstract); 24632Assert.False(cM01Get.IsVirtual); 24633Assert.False(cM01Get.IsMetadataVirtual()); 24634Assert.False(cM01Get.IsMetadataFinal); 24635Assert.False(cM01Get.IsMetadataNewSlot()); 24714Assert.False(cM01.IsAbstract); 24715Assert.False(cM01.IsVirtual); 24723Assert.False(cM01Set.IsAbstract); 24724Assert.False(cM01Set.IsVirtual); 24725Assert.False(cM01Set.IsMetadataVirtual()); 24726Assert.False(cM01Set.IsMetadataFinal); 24727Assert.False(cM01Set.IsMetadataNewSlot()); 24940Assert.False(c2M01Get.IsAbstract); 24941Assert.False(c2M01Get.IsVirtual); 24942Assert.False(c2M01Get.IsMetadataVirtual()); 24943Assert.False(c2M01Get.IsMetadataFinal); 24944Assert.False(c2M01Get.IsMetadataNewSlot()); 24947Assert.False(c2M01Set.IsAbstract); 24948Assert.False(c2M01Set.IsVirtual); 24949Assert.False(c2M01Set.IsMetadataVirtual()); 24950Assert.False(c2M01Set.IsMetadataFinal); 24951Assert.False(c2M01Set.IsMetadataNewSlot()); 24956Assert.False(c2M01Get.HasRuntimeSpecialName); 24957Assert.False(c2M01Get.HasSpecialName); 24962Assert.False(c2M01Set.HasRuntimeSpecialName); 24963Assert.False(c2M01Set.HasSpecialName); 24975Assert.False(c1M01.IsAbstract); 24976Assert.False(c1M01.IsVirtual); 24980Assert.False(c1M01Get.IsAbstract); 24981Assert.False(c1M01Get.IsVirtual); 24982Assert.False(c1M01Get.IsMetadataVirtual()); 24983Assert.False(c1M01Get.IsMetadataFinal); 24984Assert.False(c1M01Get.IsMetadataNewSlot()); 24986Assert.False(c1M01Get.HasRuntimeSpecialName); 24991Assert.False(c1M01Set.IsAbstract); 24992Assert.False(c1M01Set.IsVirtual); 24993Assert.False(c1M01Set.IsMetadataVirtual()); 24994Assert.False(c1M01Set.IsMetadataFinal); 24995Assert.False(c1M01Set.IsMetadataNewSlot()); 24997Assert.False(c1M01Set.HasRuntimeSpecialName); 25004Assert.False(c2M01.IsAbstract); 25005Assert.False(c2M01.IsVirtual); 25011Assert.False(c2M01Get.HasRuntimeSpecialName); 25017Assert.False(c2M01Set.HasRuntimeSpecialName); 25131Assert.False(c1M01.IsAbstract); 25132Assert.False(c1M01.IsVirtual); 25137Assert.False(c1M01Get.IsAbstract); 25138Assert.False(c1M01Get.IsVirtual); 25139Assert.False(c1M01Get.IsMetadataVirtual()); 25140Assert.False(c1M01Get.IsMetadataFinal); 25141Assert.False(c1M01Get.IsMetadataNewSlot()); 25148Assert.False(c1M01Set.IsAbstract); 25149Assert.False(c1M01Set.IsVirtual); 25150Assert.False(c1M01Set.IsMetadataVirtual()); 25151Assert.False(c1M01Set.IsMetadataFinal); 25152Assert.False(c1M01Set.IsMetadataNewSlot()); 25164Assert.False(c1M01Set.IsAbstract); 25165Assert.False(c1M01Set.IsVirtual); 25166Assert.False(c1M01Set.IsMetadataVirtual()); 25167Assert.False(c1M01Set.IsMetadataFinal); 25168Assert.False(c1M01Set.IsMetadataNewSlot()); 25185Assert.False(c2M01.IsAbstract); 25186Assert.False(c2M01.IsVirtual); 25190Assert.False(c2M01Get.IsAbstract); 25191Assert.False(c2M01Get.IsVirtual); 25192Assert.False(c2M01Get.IsMetadataVirtual()); 25193Assert.False(c2M01Get.IsMetadataFinal); 25194Assert.False(c2M01Get.IsMetadataNewSlot()); 25201Assert.False(c2M01Set.IsAbstract); 25202Assert.False(c2M01Set.IsVirtual); 25203Assert.False(c2M01Set.IsMetadataVirtual()); 25204Assert.False(c2M01Set.IsMetadataFinal); 25205Assert.False(c2M01Set.IsMetadataNewSlot()); 25225Assert.False(c3M01.IsAbstract); 25226Assert.False(c3M01.IsVirtual); 25230Assert.False(c3M01Get.IsAbstract); 25231Assert.False(c3M01Get.IsVirtual); 25232Assert.False(c3M01Get.IsMetadataVirtual()); 25233Assert.False(c3M01Get.IsMetadataFinal); 25234Assert.False(c3M01Get.IsMetadataNewSlot()); 25241Assert.False(c3M01Set.IsAbstract); 25242Assert.False(c3M01Set.IsVirtual); 25243Assert.False(c3M01Set.IsMetadataVirtual()); 25244Assert.False(c3M01Set.IsMetadataFinal); 25245Assert.False(c3M01Set.IsMetadataNewSlot()); 25331Assert.False(c1M01.IsAbstract); 25332Assert.False(c1M01.IsVirtual); 25338Assert.False(c1M01Get.IsAbstract); 25339Assert.False(c1M01Get.IsVirtual); 25340Assert.False(c1M01Get.IsMetadataVirtual()); 25341Assert.False(c1M01Get.IsMetadataFinal); 25342Assert.False(c1M01Get.IsMetadataNewSlot()); 25348Assert.False(c1M01Set.IsAbstract); 25349Assert.False(c1M01Set.IsVirtual); 25350Assert.False(c1M01Set.IsMetadataVirtual()); 25351Assert.False(c1M01Set.IsMetadataFinal); 25352Assert.False(c1M01Set.IsMetadataNewSlot()); 25463Assert.False(c2M01.IsAbstract); 25464Assert.False(c2M01.IsVirtual); 25468Assert.False(c2M01Get.IsAbstract); 25469Assert.False(c2M01Get.IsVirtual); 25470Assert.False(c2M01Get.IsMetadataVirtual()); 25471Assert.False(c2M01Get.IsMetadataFinal); 25472Assert.False(c2M01Get.IsMetadataNewSlot()); 25476Assert.False(c2M01Set.IsAbstract); 25477Assert.False(c2M01Set.IsVirtual); 25478Assert.False(c2M01Set.IsMetadataVirtual()); 25479Assert.False(c2M01Set.IsMetadataFinal); 25480Assert.False(c2M01Set.IsMetadataNewSlot()); 26259Assert.False(cM01.IsAbstract); 26260Assert.False(cM01.IsVirtual); 26268Assert.False(cM01Add.IsAbstract); 26269Assert.False(cM01Add.IsVirtual); 26270Assert.False(cM01Add.IsMetadataVirtual()); 26271Assert.False(cM01Add.IsMetadataFinal); 26272Assert.False(cM01Add.IsMetadataNewSlot()); 26274Assert.False(cM01Add.HasRuntimeSpecialName); 26283Assert.False(cM01Remove.IsAbstract); 26284Assert.False(cM01Remove.IsVirtual); 26285Assert.False(cM01Remove.IsMetadataVirtual()); 26286Assert.False(cM01Remove.IsMetadataFinal); 26287Assert.False(cM01Remove.IsMetadataNewSlot()); 26289Assert.False(cM01Remove.HasRuntimeSpecialName); 26354Assert.False(cM01.IsAbstract); 26355Assert.False(cM01.IsVirtual); 26363Assert.False(cM01Add.IsAbstract); 26364Assert.False(cM01Add.IsVirtual); 26365Assert.False(cM01Add.IsMetadataVirtual()); 26366Assert.False(cM01Add.IsMetadataFinal); 26367Assert.False(cM01Add.IsMetadataNewSlot()); 26369Assert.False(cM01Add.HasRuntimeSpecialName); 26378Assert.False(cM01Remove.IsAbstract); 26379Assert.False(cM01Remove.IsVirtual); 26380Assert.False(cM01Remove.IsMetadataVirtual()); 26381Assert.False(cM01Remove.IsMetadataFinal); 26382Assert.False(cM01Remove.IsMetadataNewSlot()); 26384Assert.False(cM01Remove.HasRuntimeSpecialName); 26902Assert.False(cM01.IsAbstract); 26903Assert.False(cM01.IsVirtual); 26911Assert.False(cM01Add.IsAbstract); 26912Assert.False(cM01Add.IsVirtual); 26913Assert.False(cM01Add.IsMetadataVirtual()); 26914Assert.False(cM01Add.IsMetadataFinal); 26915Assert.False(cM01Add.IsMetadataNewSlot()); 26923Assert.False(cM01Remove.IsAbstract); 26924Assert.False(cM01Remove.IsVirtual); 26925Assert.False(cM01Remove.IsMetadataVirtual()); 26926Assert.False(cM01Remove.IsMetadataFinal); 26927Assert.False(cM01Remove.IsMetadataNewSlot()); 27176Assert.False(cM01.IsAbstract); 27177Assert.False(cM01.IsVirtual); 27185Assert.False(cM01Remove.IsAbstract); 27186Assert.False(cM01Remove.IsVirtual); 27187Assert.False(cM01Remove.IsMetadataVirtual()); 27188Assert.False(cM01Remove.IsMetadataFinal); 27189Assert.False(cM01Remove.IsMetadataNewSlot()); 27197Assert.False(cM01Add.IsAbstract); 27198Assert.False(cM01Add.IsVirtual); 27199Assert.False(cM01Add.IsMetadataVirtual()); 27200Assert.False(cM01Add.IsMetadataFinal); 27201Assert.False(cM01Add.IsMetadataNewSlot()); 27468Assert.False(c2M01Add.IsAbstract); 27469Assert.False(c2M01Add.IsVirtual); 27470Assert.False(c2M01Add.IsMetadataVirtual()); 27471Assert.False(c2M01Add.IsMetadataFinal); 27472Assert.False(c2M01Add.IsMetadataNewSlot()); 27475Assert.False(c2M01Remove.IsAbstract); 27476Assert.False(c2M01Remove.IsVirtual); 27477Assert.False(c2M01Remove.IsMetadataVirtual()); 27478Assert.False(c2M01Remove.IsMetadataFinal); 27479Assert.False(c2M01Remove.IsMetadataNewSlot()); 27484Assert.False(c2M01Add.HasRuntimeSpecialName); 27485Assert.False(c2M01Add.HasSpecialName); 27490Assert.False(c2M01Remove.HasRuntimeSpecialName); 27491Assert.False(c2M01Remove.HasSpecialName); 27503Assert.False(c1M01.IsAbstract); 27504Assert.False(c1M01.IsVirtual); 27508Assert.False(c1M01Add.IsAbstract); 27509Assert.False(c1M01Add.IsVirtual); 27510Assert.False(c1M01Add.IsMetadataVirtual()); 27511Assert.False(c1M01Add.IsMetadataFinal); 27512Assert.False(c1M01Add.IsMetadataNewSlot()); 27514Assert.False(c1M01Add.HasRuntimeSpecialName); 27519Assert.False(c1M01Remove.IsAbstract); 27520Assert.False(c1M01Remove.IsVirtual); 27521Assert.False(c1M01Remove.IsMetadataVirtual()); 27522Assert.False(c1M01Remove.IsMetadataFinal); 27523Assert.False(c1M01Remove.IsMetadataNewSlot()); 27525Assert.False(c1M01Remove.HasRuntimeSpecialName); 27532Assert.False(c2M01.IsAbstract); 27533Assert.False(c2M01.IsVirtual); 27539Assert.False(c2M01Add.HasRuntimeSpecialName); 27545Assert.False(c2M01Remove.HasRuntimeSpecialName); 27671Assert.False(c1M01.IsAbstract); 27672Assert.False(c1M01.IsVirtual); 27679Assert.False(c1M01Add.IsAbstract); 27680Assert.False(c1M01Add.IsVirtual); 27681Assert.False(c1M01Add.IsMetadataVirtual()); 27682Assert.False(c1M01Add.IsMetadataFinal); 27683Assert.False(c1M01Add.IsMetadataNewSlot()); 27690Assert.False(c1M01Remove.IsAbstract); 27691Assert.False(c1M01Remove.IsVirtual); 27692Assert.False(c1M01Remove.IsMetadataVirtual()); 27693Assert.False(c1M01Remove.IsMetadataFinal); 27694Assert.False(c1M01Remove.IsMetadataNewSlot()); 27704Assert.False(c1M01Add.IsAbstract); 27705Assert.False(c1M01Add.IsVirtual); 27706Assert.False(c1M01Add.IsMetadataVirtual()); 27707Assert.False(c1M01Add.IsMetadataFinal); 27708Assert.False(c1M01Add.IsMetadataNewSlot()); 27716Assert.False(c1M01Remove.IsAbstract); 27717Assert.False(c1M01Remove.IsVirtual); 27718Assert.False(c1M01Remove.IsMetadataVirtual()); 27719Assert.False(c1M01Remove.IsMetadataFinal); 27720Assert.False(c1M01Remove.IsMetadataNewSlot()); 27741Assert.False(c2M01.IsAbstract); 27742Assert.False(c2M01.IsVirtual); 27746Assert.False(c2M01Add.IsAbstract); 27747Assert.False(c2M01Add.IsVirtual); 27748Assert.False(c2M01Add.IsMetadataVirtual()); 27749Assert.False(c2M01Add.IsMetadataFinal); 27750Assert.False(c2M01Add.IsMetadataNewSlot()); 27758Assert.False(c2M01Remove.IsAbstract); 27759Assert.False(c2M01Remove.IsVirtual); 27760Assert.False(c2M01Remove.IsMetadataVirtual()); 27761Assert.False(c2M01Remove.IsMetadataFinal); 27762Assert.False(c2M01Remove.IsMetadataNewSlot()); 27782Assert.False(c3M02.IsAbstract); 27783Assert.False(c3M02.IsVirtual); 27790Assert.False(c3M02Add.IsAbstract); 27791Assert.False(c3M02Add.IsVirtual); 27792Assert.False(c3M02Add.IsMetadataVirtual()); 27793Assert.False(c3M02Add.IsMetadataFinal); 27794Assert.False(c3M02Add.IsMetadataNewSlot()); 27801Assert.False(c3M02Remove.IsAbstract); 27802Assert.False(c3M02Remove.IsVirtual); 27803Assert.False(c3M02Remove.IsMetadataVirtual()); 27804Assert.False(c3M02Remove.IsMetadataFinal); 27805Assert.False(c3M02Remove.IsMetadataNewSlot()); 27815Assert.False(c3M02Add.IsAbstract); 27816Assert.False(c3M02Add.IsVirtual); 27817Assert.False(c3M02Add.IsMetadataVirtual()); 27818Assert.False(c3M02Add.IsMetadataFinal); 27819Assert.False(c3M02Add.IsMetadataNewSlot()); 27827Assert.False(c3M02Remove.IsAbstract); 27828Assert.False(c3M02Remove.IsVirtual); 27829Assert.False(c3M02Remove.IsMetadataVirtual()); 27830Assert.False(c3M02Remove.IsMetadataFinal); 27831Assert.False(c3M02Remove.IsMetadataNewSlot()); 27854Assert.False(c4M02.IsAbstract); 27855Assert.False(c4M02.IsVirtual); 27859Assert.False(c4M02Add.IsAbstract); 27860Assert.False(c4M02Add.IsVirtual); 27861Assert.False(c4M02Add.IsMetadataVirtual()); 27862Assert.False(c4M02Add.IsMetadataFinal); 27863Assert.False(c4M02Add.IsMetadataNewSlot()); 27872Assert.False(c4M02Remove.IsAbstract); 27873Assert.False(c4M02Remove.IsVirtual); 27874Assert.False(c4M02Remove.IsMetadataVirtual()); 27875Assert.False(c4M02Remove.IsMetadataFinal); 27876Assert.False(c4M02Remove.IsMetadataNewSlot()); 27996Assert.False(c1M01.IsAbstract); 27997Assert.False(c1M01.IsVirtual); 28003Assert.False(c1M01Add.IsAbstract); 28004Assert.False(c1M01Add.IsVirtual); 28005Assert.False(c1M01Add.IsMetadataVirtual()); 28006Assert.False(c1M01Add.IsMetadataFinal); 28007Assert.False(c1M01Add.IsMetadataNewSlot()); 28013Assert.False(c1M01Remove.IsAbstract); 28014Assert.False(c1M01Remove.IsVirtual); 28015Assert.False(c1M01Remove.IsMetadataVirtual()); 28016Assert.False(c1M01Remove.IsMetadataFinal); 28017Assert.False(c1M01Remove.IsMetadataNewSlot()); 28129Assert.False(c2M01.IsAbstract); 28130Assert.False(c2M01.IsVirtual); 28134Assert.False(c2M01Add.IsAbstract); 28135Assert.False(c2M01Add.IsVirtual); 28136Assert.False(c2M01Add.IsMetadataVirtual()); 28137Assert.False(c2M01Add.IsMetadataFinal); 28138Assert.False(c2M01Add.IsMetadataNewSlot()); 28142Assert.False(c2M01Remove.IsAbstract); 28143Assert.False(c2M01Remove.IsVirtual); 28144Assert.False(c2M01Remove.IsMetadataVirtual()); 28145Assert.False(c2M01Remove.IsMetadataFinal); 28146Assert.False(c2M01Remove.IsMetadataNewSlot()); 29208Assert.False(cM01.IsAbstract); 29209Assert.False(cM01.IsVirtual); 29210Assert.False(cM01.IsMetadataVirtual()); 29211Assert.False(cM01.IsMetadataFinal); 29212Assert.False(cM01.IsMetadataNewSlot()); 29214Assert.False(cM01.HasRuntimeSpecialName); 29233Assert.False(cM02.IsAbstract); 29234Assert.False(cM02.IsVirtual); 29235Assert.False(cM02.IsMetadataVirtual()); 29236Assert.False(cM02.IsMetadataFinal); 29237Assert.False(cM02.IsMetadataNewSlot()); 29239Assert.False(cM02.HasRuntimeSpecialName); 29334Assert.False(cM01.IsAbstract); 29335Assert.False(cM01.IsVirtual); 29336Assert.False(cM01.IsMetadataVirtual()); 29337Assert.False(cM01.IsMetadataFinal); 29338Assert.False(cM01.IsMetadataNewSlot()); 29340Assert.False(cM01.HasRuntimeSpecialName); 29341Assert.False(cM01.HasSpecialName); 29350Assert.False(cM02.IsAbstract); 29351Assert.False(cM02.IsVirtual); 29352Assert.False(cM02.IsMetadataVirtual()); 29353Assert.False(cM02.IsMetadataFinal); 29354Assert.False(cM02.IsMetadataNewSlot()); 29356Assert.False(cM02.HasRuntimeSpecialName); 29357Assert.False(cM02.HasSpecialName); 29800Assert.False(c2M01.IsAbstract); 29801Assert.False(c2M01.IsVirtual); 29802Assert.False(c2M01.IsMetadataVirtual()); 29803Assert.False(c2M01.IsMetadataFinal); 29804Assert.False(c2M01.IsMetadataNewSlot()); 29809Assert.False(c2M01.HasRuntimeSpecialName); 29810Assert.False(c2M01.HasSpecialName); 29818Assert.False(c1M01.IsAbstract); 29819Assert.False(c1M01.IsVirtual); 29820Assert.False(c1M01.IsMetadataVirtual()); 29821Assert.False(c1M01.IsMetadataFinal); 29822Assert.False(c1M01.IsMetadataNewSlot()); 29824Assert.False(c1M01.HasRuntimeSpecialName); 29831Assert.False(c2M01.HasRuntimeSpecialName); 29915Assert.False(c1M01.IsAbstract); 29916Assert.False(c1M01.IsVirtual); 29917Assert.False(c1M01.IsMetadataVirtual()); 29918Assert.False(c1M01.IsMetadataFinal); 29919Assert.False(c1M01.IsMetadataNewSlot()); 29931Assert.False(c1M01.IsAbstract); 29932Assert.False(c1M01.IsVirtual); 29933Assert.False(c1M01.IsMetadataVirtual()); 29934Assert.False(c1M01.IsMetadataFinal); 29935Assert.False(c1M01.IsMetadataNewSlot()); 29952Assert.False(c2M01.IsAbstract); 29953Assert.False(c2M01.IsVirtual); 29954Assert.False(c2M01.IsMetadataVirtual()); 29955Assert.False(c2M01.IsMetadataFinal); 29956Assert.False(c2M01.IsMetadataNewSlot()); 30068Assert.False(c1M01.IsAbstract); 30069Assert.False(c1M01.IsVirtual); 30070Assert.False(c1M01.IsMetadataVirtual()); 30071Assert.False(c1M01.IsMetadataFinal); 30072Assert.False(c1M01.IsMetadataNewSlot()); 34214Assert.False(modifier.IsOptional); 34271Assert.False(modifier.IsOptional);
Symbols\SymbolDistinguisherTests.cs (4)
702Assert.False(AreEqual(new SymbolDistinguisher(compilation, sA, sB), new SymbolDistinguisher(compilation, sA, sC))); 703Assert.False(AreEqual(new SymbolDistinguisher(compilation, sA, sB), new SymbolDistinguisher(compilation, sC, sB))); 725Assert.False(arg1A.Equals(arg2A)); 726Assert.False(arg2A.Equals(arg1A));
Symbols\SymbolEqualityTests.cs (12)
199Assert.False(member1.Equals(member2)); 200Assert.False(member2.Equals(member1)); 207Assert.False(field1.Equals(field2)); 208Assert.False(field2.Equals(field1)); 380Assert.False(SymbolEqualityComparer.Default.Equals(symbol1, symbol2)); 381Assert.False(SymbolEqualityComparer.Default.Equals(symbol2, symbol1)); 383Assert.False(SymbolEqualityComparer.ConsiderEverything.Equals(symbol1, symbol2)); 384Assert.False(SymbolEqualityComparer.ConsiderEverything.Equals(symbol2, symbol1)); 421Assert.False(member1.Equals(member2)); 422Assert.False(member2.Equals(member1)); 429Assert.False(field1.Equals(field2)); 430Assert.False(field2.Equals(field1));
Symbols\SymbolErrorTests.cs (3)
10310Assert.False(classAProp1.GetMethod.IsVirtual); //NB: non-virtual since private 10364Assert.False(classAProp1.SetMethod.IsVirtual); //NB: non-virtual since private 18526Assert.False(methods.Any(n => n.StartsWith("B..ctor", StringComparison.Ordinal))); // Haven't tried to emit it
Symbols\TypeTests.cs (16)
478Assert.False(elemType1.Type.IsStatic); 479Assert.False(elemType1.Type.IsAbstract); 480Assert.False(elemType1.Type.IsSealed); 1518Assert.False(memType.CanBeConst()); 1536Assert.False(memType.CanBeConst()); 1577Assert.False(paras[1].IsParamsCollection); 1622Assert.False(paras[0].IsOptional); 1633Assert.False(memType.CanBeConst()); 1705Assert.False(memType.GetSymbol().CanBeConst()); 1861Assert.False(symbol.ContainingType.IsUnboundGenericType); 1921Assert.False(i1.IsExplicitDefinitionOfNoPiaLocalType); 1935Assert.False(i1.IsExplicitDefinitionOfNoPiaLocalType); 1956Assert.False(i1.IsExplicitDefinitionOfNoPiaLocalType); 2179Assert.False(i2.IsExplicitDefinitionOfNoPiaLocalType); 2230Assert.False(i2.IsExplicitDefinitionOfNoPiaLocalType); 2249Assert.False(i1.IsExplicitDefinitionOfNoPiaLocalType);
Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (583)
Diagnostics\DiagnosticTest.cs (1)
224Assert.False(ErrorFacts.IsWarning(errorCode));
Diagnostics\LocationsTests.cs (3)
532Assert.False(lineInfo.HasMappedPath); 537Assert.False(mappedLineInfo.HasMappedPath); 542Assert.False(lineInfo.HasMappedPath);
IncrementalParsing\GrammarAmbiguities.cs (1)
91Assert.False(originalTree.GetCompilationUnitRoot().ContainsDiagnostics);
IncrementalParsing\IncrementalParsingTests.cs (4)
492Assert.False(tree.GetRoot().DescendantNodesAndSelf().Any(n => n is CollectionExpressionSyntax)); 501Assert.False(tree.GetRoot().DescendantNodesAndSelf().Any(n => n is AttributeSyntax)); 523Assert.False(tree.GetRoot().DescendantNodesAndSelf().Any(n => n is AttributeSyntax)); 534Assert.False(tree.GetRoot().DescendantNodesAndSelf().Any(n => n is CollectionExpressionSyntax));
LexicalAndXml\LexicalTests.cs (5)
168Assert.False(token.ContainsDiagnostics); 176Assert.False(trivia.ContainsDiagnostics); 3825Assert.False(tree.GetRoot().DescendantTokens().Any( 3908Assert.False(token.ContainsDiagnostics); 3931Assert.False(token.ContainsDiagnostics);
LexicalAndXml\PreprocessorTests.cs (3)
168Assert.False(dt.IsActive); 177Assert.False(((BranchingDirectiveTriviaSyntax)dt).BranchTaken); 186Assert.False(((ConditionalDirectiveTriviaSyntax)dt).ConditionValue);
LexicalAndXml\XmlDocCommentTests.cs (4)
1657Assert.False(xmltext.ChildNodesAndTokens()[1].HasLeadingTrivia); 1660Assert.False(xmltext.ChildNodesAndTokens()[2].HasLeadingTrivia); 1718Assert.False(trivias[0].HasStructure); 1719Assert.False(trivias[4].HasStructure);
Parsing\CSharpParseOptionsTests.cs (1)
159Assert.False(options1.Equals(options2));
Parsing\DeclarationParsingTests.cs (108)
45Assert.False(ea.AliasKeyword.IsMissing); 1130Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1171Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1233Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1238Assert.False(bound.NewKeyword.IsMissing); 1240Assert.False(bound.OpenParenToken.IsMissing); 1242Assert.False(bound.CloseParenToken.IsMissing); 1277Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1282Assert.False(bound.ClassOrStructKeyword.IsMissing); 1318Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1323Assert.False(bound.ClassOrStructKeyword.IsMissing); 1359Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1365Assert.False(classBound.ClassOrStructKeyword.IsMissing); 1376Assert.False(bound.NewKeyword.IsMissing); 1378Assert.False(bound.OpenParenToken.IsMissing); 1380Assert.False(bound.CloseParenToken.IsMissing); 1415Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1426Assert.False(cs.ConstraintClauses[1].ColonToken.IsMissing); 1431Assert.False(bound.NewKeyword.IsMissing); 1433Assert.False(bound.OpenParenToken.IsMissing); 1435Assert.False(bound.CloseParenToken.IsMissing); 1470Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1516Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1564Assert.False(cs.ConstraintClauses[0].ColonToken.IsMissing); 1570Assert.False(classBound.ClassOrStructKeyword.IsMissing); 1581Assert.False(bound.NewKeyword.IsMissing); 1583Assert.False(bound.OpenParenToken.IsMissing); 1585Assert.False(bound.CloseParenToken.IsMissing); 2011Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2014Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2016Assert.False(ds.SemicolonToken.IsMissing); 2038Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2041Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2043Assert.False(ds.SemicolonToken.IsMissing); 2066Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2069Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2071Assert.False(ds.SemicolonToken.IsMissing); 2113Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2116Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2118Assert.False(ds.SemicolonToken.IsMissing); 2159Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2170Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2172Assert.False(ds.SemicolonToken.IsMissing); 2194Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2205Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2207Assert.False(ds.SemicolonToken.IsMissing); 2229Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2247Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2249Assert.False(ds.SemicolonToken.IsMissing); 2271Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2283Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2285Assert.False(ds.SemicolonToken.IsMissing); 2307Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2319Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2321Assert.False(ds.SemicolonToken.IsMissing); 2343Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2355Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2357Assert.False(ds.SemicolonToken.IsMissing); 2380Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2389Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2391Assert.False(ds.SemicolonToken.IsMissing); 2413Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2425Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2427Assert.False(ds.SemicolonToken.IsMissing); 2464Assert.False(ds.ParameterList.OpenParenToken.IsMissing); 2467Assert.False(ds.ParameterList.CloseParenToken.IsMissing); 2469Assert.False(ds.SemicolonToken.IsMissing); 2507Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 2510Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 2552Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 2555Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 2598Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 2601Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 2706Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 2709Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 2771Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 2774Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 2818Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 2821Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 2868Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 2871Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 3016Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 3025Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 3068Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 3087Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 3129Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 3142Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 3194Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 3205Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 3268Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 3271Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 3333Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 3342Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 3385Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 3388Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 3433Assert.False(ms.ParameterList.OpenParenToken.IsMissing); 3436Assert.False(ms.ParameterList.CloseParenToken.IsMissing); 3443Assert.False(ms.ConstraintClauses[0].ColonToken.IsMissing); 3634Assert.False(fs.SemicolonToken.IsMissing); 3694Assert.False(fs.SemicolonToken.IsMissing); 3735Assert.False(fs.SemicolonToken.IsMissing); 3790Assert.False(fs.SemicolonToken.IsMissing); 3848Assert.False(fs.SemicolonToken.IsMissing); 3892Assert.False(fs.SemicolonToken.IsMissing); 3937Assert.False(fs.SemicolonToken.IsMissing); 3991Assert.False(fs.SemicolonToken.IsMissing); 4054Assert.False(fs.SemicolonToken.IsMissing); 4100Assert.False(fs.SemicolonToken.IsMissing);
Parsing\DeconstructionTests.cs (12)
1879Assert.False(statement.HasErrors); 1892Assert.False(statement.HasErrors); 1904Assert.False(statement.HasErrors); 1916Assert.False(statement.HasErrors); 1928Assert.False(statement.HasErrors); 1945Assert.False(statement.HasErrors); 1962Assert.False(statement.HasErrors); 1976Assert.False(statement.HasErrors); 1990Assert.False(statement.HasErrors); 2006Assert.False(statement.HasErrors); 2017Assert.False(statement.HasErrors); 2047Assert.False(statement.HasErrors);
Parsing\ExpressionParsingTests.cs (163)
433Assert.False(((IdentifierNameSyntax)expr).Identifier.IsMissing); 804Assert.False(openParen.IsMissing); 806Assert.False(closeParen.IsMissing); 887Assert.False(fs.OpenParenToken.IsMissing); 889Assert.False(fs.CloseParenToken.IsMissing); 921Assert.False(expr.HasErrors); 937Assert.False(cs.OpenParenToken.IsMissing); 938Assert.False(cs.CloseParenToken.IsMissing); 958Assert.False(cs.ArgumentList.OpenParenToken.IsMissing); 959Assert.False(cs.ArgumentList.CloseParenToken.IsMissing); 979Assert.False(cs.ArgumentList.OpenParenToken.IsMissing); 980Assert.False(cs.ArgumentList.CloseParenToken.IsMissing); 1004Assert.False(cs.ArgumentList.OpenParenToken.IsMissing); 1005Assert.False(cs.ArgumentList.CloseParenToken.IsMissing); 1029Assert.False(cs.ArgumentList.OpenParenToken.IsMissing); 1030Assert.False(cs.ArgumentList.CloseParenToken.IsMissing); 1054Assert.False(ea.ArgumentList.OpenBracketToken.IsMissing); 1055Assert.False(ea.ArgumentList.CloseBracketToken.IsMissing); 1075Assert.False(ea.ArgumentList.OpenBracketToken.IsMissing); 1076Assert.False(ea.ArgumentList.CloseBracketToken.IsMissing); 1100Assert.False(ea.ArgumentList.OpenBracketToken.IsMissing); 1101Assert.False(ea.ArgumentList.CloseBracketToken.IsMissing); 1125Assert.False(ea.ArgumentList.OpenBracketToken.IsMissing); 1126Assert.False(ea.ArgumentList.CloseBracketToken.IsMissing); 1147Assert.False(oc.ArgumentList.OpenParenToken.IsMissing); 1148Assert.False(oc.ArgumentList.CloseParenToken.IsMissing); 1169Assert.False(oc.ArgumentList.OpenParenToken.IsMissing); 1170Assert.False(oc.ArgumentList.CloseParenToken.IsMissing); 1192Assert.False(oc.ArgumentList.OpenParenToken.IsMissing); 1193Assert.False(oc.ArgumentList.CloseParenToken.IsMissing); 1215Assert.False(oc.ArgumentList.OpenParenToken.IsMissing); 1216Assert.False(oc.ArgumentList.CloseParenToken.IsMissing); 1224Assert.False(oc.Initializer.OpenBraceToken.IsMissing); 1225Assert.False(oc.Initializer.CloseBraceToken.IsMissing); 1247Assert.False(oc.Initializer.OpenBraceToken.IsMissing); 1248Assert.False(oc.Initializer.CloseBraceToken.IsMissing); 1270Assert.False(oc.Initializer.OpenBraceToken.IsMissing); 1271Assert.False(oc.Initializer.CloseBraceToken.IsMissing); 1294Assert.False(oc.Initializer.OpenBraceToken.IsMissing); 1295Assert.False(oc.Initializer.CloseBraceToken.IsMissing); 1320Assert.False(oc.Initializer.OpenBraceToken.IsMissing); 1321Assert.False(oc.Initializer.CloseBraceToken.IsMissing); 1344Assert.False(oc.Initializer.OpenBraceToken.IsMissing); 1345Assert.False(oc.Initializer.CloseBraceToken.IsMissing); 1848Assert.False(ac.Initializer.OpenBraceToken.IsMissing); 1849Assert.False(ac.Initializer.CloseBraceToken.IsMissing); 1870Assert.False(ac.Initializer.OpenBraceToken.IsMissing); 1871Assert.False(ac.Initializer.CloseBraceToken.IsMissing); 1894Assert.False(ac.Initializer.OpenBraceToken.IsMissing); 1895Assert.False(ac.Initializer.CloseBraceToken.IsMissing); 1914Assert.False(ac.Initializer.OpenBraceToken.IsMissing); 1915Assert.False(ac.Initializer.CloseBraceToken.IsMissing); 1934Assert.False(ac.OpenBraceToken.IsMissing); 1935Assert.False(ac.CloseBraceToken.IsMissing); 1954Assert.False(am.DelegateKeyword.IsMissing); 1959Assert.False(am.ParameterList.OpenParenToken.IsMissing); 1960Assert.False(am.ParameterList.CloseParenToken.IsMissing); 1967Assert.False(am.Block.OpenBraceToken.IsMissing); 1968Assert.False(am.Block.CloseBraceToken.IsMissing); 1985Assert.False(am.DelegateKeyword.IsMissing); 1990Assert.False(am.ParameterList.OpenParenToken.IsMissing); 1991Assert.False(am.ParameterList.CloseParenToken.IsMissing); 1997Assert.False(am.Block.OpenBraceToken.IsMissing); 1998Assert.False(am.Block.CloseBraceToken.IsMissing); 2015Assert.False(am.DelegateKeyword.IsMissing); 2022Assert.False(am.Block.OpenBraceToken.IsMissing); 2023Assert.False(am.Block.CloseBraceToken.IsMissing); 2039Assert.False(lambda.Parameter.Identifier.IsMissing); 2057Assert.False(lambda.Parameter.Identifier.IsMissing); 2075Assert.False(lambda.Parameter.Identifier.IsMissing); 2096Assert.False(lambda.ParameterList.OpenParenToken.IsMissing); 2097Assert.False(lambda.ParameterList.CloseParenToken.IsMissing); 2116Assert.False(lambda.ParameterList.OpenParenToken.IsMissing); 2117Assert.False(lambda.ParameterList.CloseParenToken.IsMissing); 2136Assert.False(lambda.ParameterList.OpenParenToken.IsMissing); 2137Assert.False(lambda.ParameterList.CloseParenToken.IsMissing); 2158Assert.False(lambda.ParameterList.OpenParenToken.IsMissing); 2159Assert.False(lambda.ParameterList.CloseParenToken.IsMissing); 2182Assert.False(lambda.ParameterList.OpenParenToken.IsMissing); 2183Assert.False(lambda.ParameterList.CloseParenToken.IsMissing); 2209Assert.False(lambda.ParameterList.OpenParenToken.IsMissing); 2210Assert.False(lambda.ParameterList.CloseParenToken.IsMissing); 2234Assert.False(lambda.ParameterList.OpenParenToken.IsMissing); 2235Assert.False(lambda.ParameterList.CloseParenToken.IsMissing); 2261Assert.False(tuple.OpenParenToken.IsMissing); 2262Assert.False(tuple.CloseParenToken.IsMissing); 2281Assert.False(tuple.OpenParenToken.IsMissing); 2282Assert.False(tuple.CloseParenToken.IsMissing); 2306Assert.False(fs.FromKeyword.IsMissing); 2310Assert.False(fs.InKeyword.IsMissing); 2317Assert.False(ss.SelectKeyword.IsMissing); 2339Assert.False(fs.FromKeyword.IsMissing); 2344Assert.False(fs.InKeyword.IsMissing); 2350Assert.False(ss.SelectKeyword.IsMissing); 2373Assert.False(fs.FromKeyword.IsMissing); 2377Assert.False(fs.InKeyword.IsMissing); 2383Assert.False(ss.SelectKeyword.IsMissing); 2390Assert.False(qs.Body.Continuation.IntoKeyword.IsMissing); 2400Assert.False(ss.SelectKeyword.IsMissing); 2423Assert.False(fs.FromKeyword.IsMissing); 2427Assert.False(fs.InKeyword.IsMissing); 2434Assert.False(ws.WhereKeyword.IsMissing); 2441Assert.False(ss.SelectKeyword.IsMissing); 2463Assert.False(fs.FromKeyword.IsMissing); 2467Assert.False(fs.InKeyword.IsMissing); 2474Assert.False(fs.FromKeyword.IsMissing); 2478Assert.False(fs.InKeyword.IsMissing); 2484Assert.False(ss.SelectKeyword.IsMissing); 2506Assert.False(fs.FromKeyword.IsMissing); 2510Assert.False(fs.InKeyword.IsMissing); 2518Assert.False(ls.LetKeyword.IsMissing); 2522Assert.False(ls.EqualsToken.IsMissing); 2529Assert.False(ss.SelectKeyword.IsMissing); 2551Assert.False(fs.FromKeyword.IsMissing); 2555Assert.False(fs.InKeyword.IsMissing); 2563Assert.False(obs.OrderByKeyword.IsMissing); 2574Assert.False(ss.SelectKeyword.IsMissing); 2596Assert.False(fs.FromKeyword.IsMissing); 2600Assert.False(fs.InKeyword.IsMissing); 2607Assert.False(obs.OrderByKeyword.IsMissing); 2623Assert.False(ss.SelectKeyword.IsMissing); 2645Assert.False(fs.FromKeyword.IsMissing); 2649Assert.False(fs.InKeyword.IsMissing); 2656Assert.False(obs.OrderByKeyword.IsMissing); 2662Assert.False(os.AscendingOrDescendingKeyword.IsMissing); 2671Assert.False(ss.SelectKeyword.IsMissing); 2693Assert.False(fs.FromKeyword.IsMissing); 2697Assert.False(fs.InKeyword.IsMissing); 2704Assert.False(obs.OrderByKeyword.IsMissing); 2710Assert.False(os.AscendingOrDescendingKeyword.IsMissing); 2719Assert.False(ss.SelectKeyword.IsMissing); 2740Assert.False(fs.FromKeyword.IsMissing); 2744Assert.False(fs.InKeyword.IsMissing); 2751Assert.False(gbs.GroupKeyword.IsMissing); 2756Assert.False(gbs.ByKeyword.IsMissing); 2779Assert.False(fs.FromKeyword.IsMissing); 2783Assert.False(fs.InKeyword.IsMissing); 2789Assert.False(gbs.GroupKeyword.IsMissing); 2793Assert.False(gbs.ByKeyword.IsMissing); 2800Assert.False(qs.Body.Continuation.IntoKeyword.IsMissing); 2810Assert.False(ss.SelectKeyword.IsMissing); 2833Assert.False(fs.FromKeyword.IsMissing); 2837Assert.False(fs.InKeyword.IsMissing); 2844Assert.False(js.JoinKeyword.IsMissing); 2849Assert.False(js.InKeyword.IsMissing); 2854Assert.False(js.OnKeyword.IsMissing); 2859Assert.False(js.EqualsKeyword.IsMissing); 2867Assert.False(ss.SelectKeyword.IsMissing); 2889Assert.False(fs.FromKeyword.IsMissing); 2894Assert.False(fs.InKeyword.IsMissing); 2900Assert.False(js.JoinKeyword.IsMissing); 2906Assert.False(js.InKeyword.IsMissing); 2910Assert.False(js.OnKeyword.IsMissing); 2914Assert.False(js.EqualsKeyword.IsMissing); 2922Assert.False(ss.SelectKeyword.IsMissing); 2944Assert.False(fs.FromKeyword.IsMissing); 2948Assert.False(fs.InKeyword.IsMissing); 2954Assert.False(js.JoinKeyword.IsMissing); 2959Assert.False(js.InKeyword.IsMissing); 2963Assert.False(js.OnKeyword.IsMissing); 2967Assert.False(js.EqualsKeyword.IsMissing); 2972Assert.False(js.Into.IntoKeyword.IsMissing); 2979Assert.False(ss.SelectKeyword.IsMissing);
Parsing\LocalFunctionParsingTests.cs (4)
1290Assert.False(file.HasErrors); 1298Assert.False(s1.ContainsDiagnostics); 1302Assert.False(s1.ContainsDiagnostics); 1344Assert.False(file.HasErrors);
Parsing\NameParsingTests.cs (43)
37Assert.False(((IdentifierNameSyntax)name).Identifier.IsMissing); 50Assert.False(((IdentifierNameSyntax)name).Identifier.IsMissing); 122Assert.False(name.IsMissing); 134Assert.False(name.IsMissing); 150Assert.False(name.IsMissing); 163Assert.False(name.IsMissing); 169Assert.False(name.IsMissing); 192Assert.False(name.IsMissing); 198Assert.False(name.IsMissing); 210Assert.False(name.IsMissing); 214Assert.False(gname.IsUnboundGenericName); 226Assert.False(name.IsMissing); 230Assert.False(gname.IsUnboundGenericName); 242Assert.False(name.IsMissing); 246Assert.False(gname.IsUnboundGenericName); 302Assert.False(name.IsMissing); 319Assert.False(name.IsMissing); 337Assert.False(name.IsMissing); 351Assert.False(name.IsMissing); 365Assert.False(name.IsMissing); 369Assert.False(gname.IsUnboundGenericName); 382Assert.False(name.IsMissing); 386Assert.False(gname.IsUnboundGenericName); 443Assert.False(name.IsMissing); 494Assert.False(name.IsMissing); 509Assert.False(name.IsMissing); 535Assert.False(name.IsMissing); 557Assert.False(name.IsMissing); 579Assert.False(name.IsMissing); 610Assert.False(name.IsMissing); 626Assert.False(gname.IsUnboundGenericName); 651Assert.False(gname.IsUnboundGenericName); 677Assert.False(gname.IsUnboundGenericName); 703Assert.False(gname.IsUnboundGenericName); 716Assert.False(arg2.ContainsDiagnostics); 735Assert.False(gname.IsUnboundGenericName); 760Assert.False(gname.IsUnboundGenericName); 787Assert.False(SyntaxFacts.ContainsDroppedIdentifierCharacters(tok.ValueText)); 803Assert.False(SyntaxFacts.ContainsDroppedIdentifierCharacters(tok.ValueText)); 810Assert.False(SyntaxFacts.ContainsDroppedIdentifierCharacters(null)); 811Assert.False(SyntaxFacts.ContainsDroppedIdentifierCharacters("")); 812Assert.False(SyntaxFacts.ContainsDroppedIdentifierCharacters("a")); 813Assert.False(SyntaxFacts.ContainsDroppedIdentifierCharacters("a@"));
Parsing\ParsingErrorRecoveryTests.cs (59)
6409Assert.False(pd.AccessorList.OpenBraceToken.IsMissing); 6411Assert.False(pd.AccessorList.CloseBraceToken.IsMissing); 6434Assert.False(pd.AccessorList.OpenBraceToken.IsMissing); 6459Assert.False(pd.AccessorList.OpenBraceToken.IsMissing); 6466Assert.False(acc.Keyword.IsMissing); 6494Assert.False(pd.AccessorList.OpenBraceToken.IsMissing); 6501Assert.False(acc.Keyword.IsMissing); 6505Assert.False(acc.Body.OpenBraceToken.IsMissing); 6533Assert.False(pd.AccessorList.OpenBraceToken.IsMissing); 6540Assert.False(acc.Keyword.IsMissing); 6544Assert.False(acc.Body.OpenBraceToken.IsMissing); 6581Assert.False(getBodyStmts[0].ContainsDiagnostics); 6635Assert.False(md.Body.OpenBraceToken.IsMissing); 6637Assert.False(md.Body.CloseBraceToken.IsMissing); 6651Assert.False(oc.OrderByKeyword.IsMissing); 6680Assert.False(md.Body.OpenBraceToken.IsMissing); 6682Assert.False(md.Body.CloseBraceToken.IsMissing); 6696Assert.False(oc.OrderByKeyword.IsMissing); 6701Assert.False(nm.IsMissing); 6724Assert.False(md.Body.OpenBraceToken.IsMissing); 6726Assert.False(md.Body.CloseBraceToken.IsMissing); 6740Assert.False(oc.OrderByKeyword.IsMissing); 6745Assert.False(nm.IsMissing); 6774Assert.False(md.Body.OpenBraceToken.IsMissing); 6790Assert.False(oc.OrderByKeyword.IsMissing); 6822Assert.False(md.Body.OpenBraceToken.IsMissing); 6838Assert.False(oc.OrderByKeyword.IsMissing); 6843Assert.False(nm.IsMissing); 6869Assert.False(md.Body.OpenBraceToken.IsMissing); 6885Assert.False(oc.OrderByKeyword.IsMissing); 6890Assert.False(nm.IsMissing); 6916Assert.False(item1.OpenBraceToken.IsMissing); 6918Assert.False(item1.CloseBraceToken.IsMissing); 6923Assert.False(subitem1.Body.OpenBraceToken.IsMissing); 7018Assert.False(file.ContainsDiagnostics); 7034Assert.False(file.ContainsDiagnostics); 7113Assert.False(((NamespaceDeclarationSyntax)namespaceDeclaration).Name.IsMissing); 7137Assert.False(((FileScopedNamespaceDeclarationSyntax)namespaceDeclaration).Name.IsMissing); 7235Assert.False(file.ContainsDiagnostics); 7284Assert.False(methodDecl.ContainsDiagnostics); 7288Assert.False(methodBody.ContainsDiagnostics); 7301Assert.False(globalStatement.IsMissing); 7304Assert.False(expressionStatement.IsMissing); 7308Assert.False(collectionExpression.IsMissing); 7938Assert.False(classDecl.Identifier.IsMissing); 7942Assert.False(ns.OpenBraceToken.IsMissing); 7943Assert.False(ns.CloseBraceToken.IsMissing); 7959Assert.False(classDecl.Identifier.IsMissing); 7963Assert.False(ns.SemicolonToken.IsMissing); 7983Assert.False(ns.OpenBraceToken.IsMissing); 7984Assert.False(ns.CloseBraceToken.IsMissing); 8004Assert.False(structDecl.OpenBraceToken.IsMissing); 8005Assert.False(structDecl.CloseBraceToken.IsMissing); 8007Assert.False(ns.OpenBraceToken.IsMissing); 8008Assert.False(ns.CloseBraceToken.IsMissing); 8028Assert.False(classDecl.OpenBraceToken.IsMissing); 8029Assert.False(classDecl.CloseBraceToken.IsMissing); 8031Assert.False(ns.OpenBraceToken.IsMissing); 8032Assert.False(ns.CloseBraceToken.IsMissing);
Parsing\ParsingTests.cs (2)
215Assert.False(current.IsTrivia); 216Assert.False(current.IsMissing);
Parsing\ReadOnlyStructs.cs (11)
45Assert.False(s1.IsRefLikeType); 51Assert.False(s2.IsRefLikeType); 57Assert.False(s3.IsRefLikeType); 119Assert.False(s1.IsRefLikeType); 120Assert.False(s1.IsReadOnly); 125Assert.False(s2.IsRefLikeType); 126Assert.False(s2.IsReadOnly); 131Assert.False(s3.IsRefLikeType); 132Assert.False(s3.IsReadOnly); 187Assert.False(s1.IsRefLikeType); 225Assert.False(s2.IsRefLikeType);
Parsing\ScriptParsingTests.cs (4)
3158Assert.False(tree.GetCompilationUnitRoot().ContainsDiagnostics); 3190Assert.False(tree.GetCompilationUnitRoot().ContainsDiagnostics); 10249Assert.False(shebang.HasStructuredTrivia); 10259Assert.False(content.HasLeadingTrivia || content.HasTrailingTrivia);
Parsing\StatementParsingTests.cs (93)
69Assert.False(es.SemicolonToken.IsMissing); 89Assert.False(es.SemicolonToken.IsMissing); 108Assert.False(es.SemicolonToken.IsMissing); 128Assert.False(es.SemicolonToken.IsMissing); 148Assert.False(es.SemicolonToken.IsMissing); 164Assert.False(es.SemicolonToken.IsMissing); 204Assert.False(ds.SemicolonToken.IsMissing); 234Assert.False(ds.SemicolonToken.IsMissing); 268Assert.False(ds.SemicolonToken.IsMissing); 309Assert.False(ds.SemicolonToken.IsMissing); 339Assert.False(ds.SemicolonToken.IsMissing); 365Assert.False(ds.SemicolonToken.IsMissing); 391Assert.False(ds.SemicolonToken.IsMissing); 417Assert.False(ds.SemicolonToken.IsMissing); 443Assert.False(ds.SemicolonToken.IsMissing); 469Assert.False(ds.SemicolonToken.IsMissing); 495Assert.False(ds.SemicolonToken.IsMissing); 530Assert.False(ds.SemicolonToken.IsMissing); 555Assert.False(ds.Declaration.Variables[0].Initializer.EqualsToken.IsMissing); 560Assert.False(ds.SemicolonToken.IsMissing); 584Assert.False(ds.Declaration.Variables[0].Initializer.EqualsToken.IsMissing); 592Assert.False(ds.Declaration.Variables[1].Initializer.EqualsToken.IsMissing); 600Assert.False(ds.Declaration.Variables[2].Initializer.EqualsToken.IsMissing); 605Assert.False(ds.SemicolonToken.IsMissing); 630Assert.False(ds.Declaration.Variables[0].Initializer.EqualsToken.IsMissing); 636Assert.False(ds.SemicolonToken.IsMissing); 662Assert.False(ds.Declaration.Variables[0].Initializer.EqualsToken.IsMissing); 667Assert.False(ds.SemicolonToken.IsMissing); 694Assert.False(ds.Declaration.Variables[0].Initializer.EqualsToken.IsMissing); 699Assert.False(ds.SemicolonToken.IsMissing); 726Assert.False(ds.Declaration.Variables[0].Initializer.EqualsToken.IsMissing); 731Assert.False(ds.SemicolonToken.IsMissing); 758Assert.False(ds.Declaration.Variables[0].Initializer.EqualsToken.IsMissing); 763Assert.False(ds.SemicolonToken.IsMissing); 789Assert.False(ds.SemicolonToken.IsMissing); 815Assert.False(initializer.EqualsToken.IsMissing); 820Assert.False(ds.SemicolonToken.IsMissing); 846Assert.False(initializer.EqualsToken.IsMissing); 856Assert.False(initializer.EqualsToken.IsMissing); 861Assert.False(ds.SemicolonToken.IsMissing); 877Assert.False(fs.FixedKeyword.IsMissing); 879Assert.False(fs.FixedKeyword.IsMissing); 904Assert.False(fs.FixedKeyword.IsMissing); 906Assert.False(fs.FixedKeyword.IsMissing); 934Assert.False(fs.FixedKeyword.IsMissing); 936Assert.False(fs.FixedKeyword.IsMissing); 962Assert.False(es.SemicolonToken.IsMissing); 999Assert.False(b.BreakKeyword.IsMissing); 1002Assert.False(b.SemicolonToken.IsMissing); 1018Assert.False(cs.ContinueKeyword.IsMissing); 1021Assert.False(cs.SemicolonToken.IsMissing); 1037Assert.False(gs.GotoKeyword.IsMissing); 1043Assert.False(gs.SemicolonToken.IsMissing); 1059Assert.False(gs.GotoKeyword.IsMissing); 1062Assert.False(gs.CaseOrDefaultKeyword.IsMissing); 1067Assert.False(gs.SemicolonToken.IsMissing); 1083Assert.False(gs.GotoKeyword.IsMissing); 1086Assert.False(gs.CaseOrDefaultKeyword.IsMissing); 1090Assert.False(gs.SemicolonToken.IsMissing); 1106Assert.False(rs.ReturnKeyword.IsMissing); 1110Assert.False(rs.SemicolonToken.IsMissing); 1126Assert.False(rs.ReturnKeyword.IsMissing); 1131Assert.False(rs.SemicolonToken.IsMissing); 1147Assert.False(ys.YieldKeyword.IsMissing); 1150Assert.False(ys.ReturnOrBreakKeyword.IsMissing); 1155Assert.False(ys.SemicolonToken.IsMissing); 1171Assert.False(ys.YieldKeyword.IsMissing); 1174Assert.False(ys.ReturnOrBreakKeyword.IsMissing); 1178Assert.False(ys.SemicolonToken.IsMissing); 1194Assert.False(ts.ThrowKeyword.IsMissing); 1198Assert.False(ts.SemicolonToken.IsMissing); 1214Assert.False(ts.ThrowKeyword.IsMissing); 1219Assert.False(ts.SemicolonToken.IsMissing); 1235Assert.False(ts.TryKeyword.IsMissing); 1265Assert.False(ts.TryKeyword.IsMissing); 1294Assert.False(ts.TryKeyword.IsMissing); 1318Assert.False(ts.TryKeyword.IsMissing); 1361Assert.False(ts.TryKeyword.IsMissing); 1384Assert.False(ts.TryKeyword.IsMissing); 1527Assert.False(fs.ForKeyword.IsMissing); 1553Assert.False(fs.ForKeyword.IsMissing); 1590Assert.False(fs.ForKeyword.IsMissing); 1629Assert.False(fs.ForKeyword.IsMissing); 1738Assert.False(fs.ForKeyword.IsMissing); 1767Assert.False(fs.ForKeyword.IsMissing); 1797Assert.False(fs.ForKeyword.IsMissing); 1827Assert.False(fs.ForKeyword.IsMissing); 1857Assert.False(fs.ForKeyword.IsMissing); 1888Assert.False(fs.ForKeyword.IsMissing); 1939Assert.False(fs.InKeyword.IsMissing); 1972Assert.False(fs.InKeyword.IsMissing); 2003Assert.False(fs.InKeyword.IsMissing); 3387Assert.False(fs.InKeyword.IsMissing);
Syntax\LambdaUtilitiesTests.cs (12)
52Assert.False(isLambdaBody && isReducedLambdaBody); 207Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 223Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 235Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 243Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 247Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 255Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 263Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 271Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 275Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 283Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies( 291Assert.False(LambdaUtilities.AreEquivalentIgnoringLambdaBodies(
Syntax\SeparatedSyntaxListTests.cs (1)
297Assert.False(list.Any(SyntaxKind.WhereClause));
Syntax\StructuredTriviaTests.cs (1)
150Assert.False(directives[1].File.IsMissing);
Syntax\SyntaxAnnotationTests.cs (2)
37Assert.False(newToken.ContainsAnnotations); 47Assert.False(newTrivia.ContainsAnnotations);
Syntax\SyntaxEquivalenceTests.cs (2)
27Assert.False(SyntaxFactory.AreEquivalent(tree1, tree2, topLevel)); 31Assert.False(SyntaxFactory.AreEquivalent(tree1, tree3, topLevel));
Syntax\SyntaxFactoryTests.cs (5)
66Assert.False(n.NamespaceKeyword.IsMissing); 68Assert.False(n.OpenBraceToken.IsMissing); 72Assert.False(n.CloseBraceToken.IsMissing); 88Assert.False(c.OpenBraceToken.IsMissing); 92Assert.False(c.CloseBraceToken.IsMissing);
Syntax\SyntaxListTests.cs (1)
284Assert.False(list.Any(SyntaxKind.WhereClause));
Syntax\SyntaxNodeTests.cs (27)
351Assert.False(SyntaxFactory.ParseCompilationUnit("").ContainsDirective(kind)); 355Assert.False(SyntaxFactory.ParseCompilationUnit("namespace N { }").ContainsDirective(kind)); 365Assert.False(compilationUnit.ContainsDirective(kind)); 478Assert.False(compilationUnit.ContainsDirective(kind)); 505Assert.False(compilationUnit.ContainsDirectives); 506Assert.False(compilationUnit.ContainsDirective(SyntaxKind.IfDirectiveTrivia)); 810Assert.False(tree.GetCompilationUnitRoot().IsEquivalentTo(null)); 829Assert.False(tree1.GetCompilationUnitRoot().IsEquivalentTo(tree2.GetCompilationUnitRoot())); 838Assert.False(tree1.GetCompilationUnitRoot().IsEquivalentTo(tree2.GetCompilationUnitRoot())); 859Assert.False(tree1.GetCompilationUnitRoot().IsEquivalentTo(tree2.GetCompilationUnitRoot())); 883Assert.False(tree.GetCompilationUnitRoot().GetFirstToken().IsIncrementallyIdenticalTo(tree.GetCompilationUnitRoot().GetFirstToken().GetNextToken())); 901Assert.False(tree1.GetCompilationUnitRoot().IsIncrementallyIdenticalTo(tree2.GetCompilationUnitRoot())); 921Assert.False( 1783Assert.False(rootNode.ToString().Contains("/*START*/")); 1801Assert.False(rootNode.ToString().Contains("/*START*/")); 1842Assert.False(trivia.IsDirective); 1957Assert.False(someNode.Identifier.TrailingTrivia[0].Equals(someNode.Identifier.TrailingTrivia[1])); 1994Assert.False(someNode.Identifier.TrailingTrivia[0].Equals(someNode.Identifier.TrailingTrivia[1])); 3761Assert.False(idToken.HasLeadingTrivia); 3763Assert.False(idToken.HasTrailingTrivia); 3786Assert.False(namedNode.HasLeadingTrivia); 3788Assert.False(namedNode.HasTrailingTrivia); 3820Assert.False(nodeOrToken.HasLeadingTrivia); 3822Assert.False(nodeOrToken.HasTrailingTrivia); 3827Assert.False(nodeOrToken.HasLeadingTrivia); 3829Assert.False(nodeOrToken.HasTrailingTrivia); 3885Assert.False(firstParens.Contains(a)); // fixing #8625 allows this to return quicker
Syntax\SyntaxRewriterTests.cs (8)
565Assert.False(token1.ContainsDiagnostics); 580Assert.False(expr2.ContainsDiagnostics); //gone after rewrite 584Assert.False(token2.ContainsDiagnostics); 611Assert.False(token1.ContainsDiagnostics); 626Assert.False(expr2.ContainsDiagnostics); //gone after rewrite 630Assert.False(token2.ContainsDiagnostics); 698Assert.False(green.ContainsDiagnostics); 710Assert.False(red.ContainsDiagnostics);
Syntax\SyntaxTests.cs (1)
22Assert.False(SyntaxFactory.IsCompleteSubmission(SyntaxFactory.ParseSyntaxTree(code, options: TestOptions.Script)));
Syntax\SyntaxTokenListTests.cs (1)
259Assert.False(list.Any(SyntaxKind.NullKeyword));
Syntax\SyntaxTriviaListTests.cs (1)
238Assert.False(list.Any(SyntaxKind.SingleLineCommentTrivia));
Microsoft.CodeAnalysis.CSharp.Test.Utilities (44)
FunctionPointerUtilities.cs (44)
31Assert.False(symbol.IsReferenceType); 32Assert.False(symbol.IsRefLikeType); 33Assert.False(symbol.IsReadOnly); 34Assert.False(symbol.IsStatic); 35Assert.False(symbol.IsAbstract); 36Assert.False(symbol.IsSealed); 37Assert.False(symbol.CanBeReferencedByName); 66Assert.False(symbol.IsExtensionMethod); 67Assert.False(symbol.HidesBaseMethodsByName); 68Assert.False(symbol.IsStatic); 69Assert.False(symbol.IsAsync); 70Assert.False(symbol.IsVirtual); 71Assert.False(symbol.IsOverride); 72Assert.False(symbol.IsAbstract); 73Assert.False(symbol.IsExtern); 74Assert.False(symbol.IsExtensionMethod); 75Assert.False(symbol.IsSealed); 76Assert.False(symbol.IsExtern); 77Assert.False(symbol.HasSpecialName); 78Assert.False(symbol.HasDeclarativeSecurity); 79Assert.False(symbol.RequiresSecurityObject); 80Assert.False(symbol.IsDeclaredReadOnly); 81Assert.False(symbol.IsMetadataNewSlot(true)); 82Assert.False(symbol.IsMetadataNewSlot(false)); 83Assert.False(symbol.IsMetadataVirtual(MethodSymbol.IsMetadataVirtualOption.IgnoreInterfaceImplementationChanges)); 84Assert.False(symbol.IsMetadataVirtual(MethodSymbol.IsMetadataVirtualOption.None)); 112Assert.False(symbol.IsDiscard); 113Assert.False(symbol.IsParams); 114Assert.False(symbol.IsParamsArray); 115Assert.False(symbol.IsParamsCollection); 116Assert.False(symbol.IsMetadataOptional); 117Assert.False(symbol.IsIDispatchConstant); 118Assert.False(symbol.IsIUnknownConstant); 119Assert.False(symbol.IsCallerFilePath); 120Assert.False(symbol.IsCallerLineNumber); 121Assert.False(symbol.IsCallerFilePath); 122Assert.False(symbol.IsCallerMemberName); 285Assert.False(CustomModifierUtils.HasOutAttributeModifier(signature.RefCustomModifiers)); 290Assert.False(CustomModifierUtils.HasInAttributeModifier(signature.RefCustomModifiers)); 291Assert.False(CustomModifierUtils.HasOutAttributeModifier(signature.RefCustomModifiers)); 311Assert.False(CustomModifierUtils.HasInAttributeModifier(parameter.RefCustomModifiers)); 316Assert.False(CustomModifierUtils.HasOutAttributeModifier(parameter.RefCustomModifiers)); 321Assert.False(CustomModifierUtils.HasInAttributeModifier(parameter.RefCustomModifiers)); 322Assert.False(CustomModifierUtils.HasOutAttributeModifier(parameter.RefCustomModifiers));
Microsoft.CodeAnalysis.CSharp.WinRT.UnitTests (14)
Metadata\WinMdEventTests.cs (14)
2850Assert.False(interfaceNormalEvent.IsWindowsRuntimeEvent); 2861Assert.False(implementingNormalEvent.IsWindowsRuntimeEvent); 2871Assert.False(substitutedNormalEvent.IsWindowsRuntimeEvent); 2885Assert.False(retargetingNormalEvent.IsWindowsRuntimeEvent); 2965Assert.False(normalEvent.IsWindowsRuntimeEvent); 3041Assert.False(normalEvent.IsWindowsRuntimeEvent); 3050Assert.False(normalEvent.IsWindowsRuntimeEvent); 3061Assert.False(winRTEvent.IsWindowsRuntimeEvent); 3100Assert.False(normalEvent.IsWindowsRuntimeEvent); 3265Assert.False(winRTEvent.IsWindowsRuntimeEvent); 3506Assert.False(instanceEvent.AddMethod.IsStatic); 3512Assert.False(staticEvent.RemoveMethod.IsStatic); 3581Assert.False(addMethod.ReturnsVoid); 3604Assert.False(@event.IsWindowsRuntimeEvent);
Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (2)
CSharpSyntaxFactsServiceTests.cs (1)
197=> Assert.False(IsQueryKeyword(WrapInMethod("""
EmbeddedLanguages\VirtualChars\CSharpVirtualCharServiceTests.cs (1)
51Assert.False(token.ContainsDiagnostics);
Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (6)
BraceMatching\AbstractBraceMatcherTests.cs (1)
40Assert.False(foundSpan.HasValue);
ExtractInterface\AbstractExtractInterfaceTests.cs (2)
106Assert.False(testState.Workspace.Documents.Select(d => d.Id).Contains(result.NavigationDocumentId)); 146Assert.False(result.Succeeded);
Options\OptionSerializerTests.cs (2)
204Assert.False(serializer.TryParse("1", out _)); 205Assert.False(serializer.TryParse(enumType.GetEnumNames().Join(","), out _));
RefactoringHelpers\RefactoringHelpersTestBase.cs (1)
57Assert.False(CodeRefactoringHelpers.IsNodeUnderselected(resultNode, selection));
Microsoft.CodeAnalysis.EditorFeatures.UnitTests (157)
CodeFixes\CodeFixServiceTests.cs (7)
135Assert.False(analyzerWithFix.ReceivedCallback); 136Assert.False(analyzerWithoutFix.ReceivedCallback); 147Assert.False(analyzerWithoutFix.ReceivedCallback); 172Assert.False(documentDiagnosticAnalyzer.ReceivedCallback); 208Assert.False(codeFix.Called); 285Assert.False(extensionManager.IsIgnored(codefix)); 307Assert.False(extensionManager.IsIgnored(codefix));
CodeRefactorings\CodeRefactoringServiceTest.cs (1)
113Assert.False(extensionManager.IsIgnored(codeRefactoring));
Collections\Immutable\Maps\BidirectionalMapTests.cs (8)
22Assert.False(map.TryGetKey(0, out _)); 23Assert.False(map.TryGetValue("0", out _)); 25Assert.False(map.ContainsKey("0")); 26Assert.False(map.ContainsValue(0)); 72Assert.False(map2.ContainsKey("1")); 76Assert.False(map2.ContainsValue(1)); 99Assert.False(map2.ContainsKey("1")); 103Assert.False(map2.ContainsValue(1));
Diagnostics\DiagnosticAnalyzerServiceTests.cs (1)
641Assert.False(analyzer2.ReceivedSymbolCallback);
EditAndContinue\EditAndContinueLanguageServiceTests.cs (2)
138Assert.False(sessionState.IsSessionActive); 349Assert.False(sessionState.IsSessionActive);
EditorConfigSettings\Data\CodeStyleSettingsTest.cs (2)
43Assert.False(setting.IsDefinedInEditorConfig); 74Assert.False(setting.IsDefinedInEditorConfig);
EmbeddedLanguages\Json\LanguageServices\JsonLanguageDetectorTests.cs (1)
46Assert.False(JsonLanguageDetector.CommentDetector.TryMatch(value, out _, out var stringOptions) &&
EmbeddedLanguages\RegularExpressions\LanguageServices\RegexPatternDetectorTests.cs (1)
46Assert.False(RegexLanguageDetector.CommentDetector.TryMatch(value, out _, out var stringOptions) &&
Extensions\ITextLineExtensionsTests.cs (4)
103Assert.False(value); 110Assert.False(value); 117Assert.False(value); 124Assert.False(value);
Extensions\ITextSnapshotExtensionsTests.cs (4)
156Assert.False(snapshot.TryGetPosition(1, 8, out _)); 157Assert.False(snapshot.TryGetPosition(3, -2, out _)); 160Assert.False(snapshot.TryGetPosition(18, 1, out _)); 161Assert.False(snapshot.TryGetPosition(-1, 1, out _));
Extensions\ITextSnapshotLineExtensionsTests.cs (4)
162Assert.False(value); 169Assert.False(value); 176Assert.False(value); 183Assert.False(value);
Extensions\SetExtensionTests.cs (1)
19Assert.False(set.AddAll(["b", "c"]));
Formatting\InferredIndentationTests.cs (2)
42Assert.False(options.UseTabs); 55Assert.False(options.UseTabs);
MetadataAsSource\AbstractMetadataAsSourceTests.cs (1)
127Assert.False(generatedSymbol.Locations.Where(loc => loc.IsInSource).IsEmpty());
Preview\PreviewWorkspaceTests.cs (1)
110Assert.False(previewWorkspace.IsDocumentOpen(document.Id));
RenameTracking\RenameTrackingTaggerProviderTests.cs (4)
868Assert.False(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(notRenamable, out _)); 871Assert.False(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(source.Task, out _)); 877Assert.False(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(source.Task, out _)); 881Assert.False(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(source.Task, out _));
Structure\StructureTaggerTests.cs (6)
70Assert.False(namespaceTag.IsImplementation); 84Assert.False(classTag.IsImplementation); 98Assert.False(ifTag.IsImplementation); 280Assert.False(namespaceTag.IsImplementation); 296Assert.False(moduleTag.IsImplementation); 310Assert.False(ifTag.IsImplementation);
Tagging\AsynchronousTaggerTests.cs (2)
175Assert.False(c.FrozenPartialSemantics); 223Assert.False(c.FrozenPartialSemantics);
Utilities\BloomFilterTests.cs (9)
65Assert.False(actualContains); 89Assert.False(filter.ProbablyContains(string.Empty)); 90Assert.False(filter.ProbablyContains("a")); 91Assert.False(filter.ProbablyContains("b")); 92Assert.False(filter.ProbablyContains("c")); 97Assert.False(filter.ProbablyContains(test)); 109Assert.False(BloomFilter.BloomFilterHash.TryGetCachedEntry(out _, out _)); 185Assert.False(actualContains); 250Assert.False(actualContains);
Utilities\PatternMatcherTests.cs (2)
399Assert.False(match.First().IsCaseSensitive); 414Assert.False(match.Value.IsCaseSensitive);
Utilities\SymbolEquivalenceComparerTests.cs (94)
91Assert.False(SymbolEquivalenceComparer.Instance.Equals(intField1.Type, intArrayField1.Type)); 92Assert.False(SymbolEquivalenceComparer.Instance.Equals(intArrayField1.Type, stringArrayField1.Type)); 93Assert.False(SymbolEquivalenceComparer.Instance.Equals(stringArrayField1.Type, intArrayArrayField1.Type)); 94Assert.False(SymbolEquivalenceComparer.Instance.Equals(intArrayArrayField1.Type, intArrayRank2Field1.Type)); 95Assert.False(SymbolEquivalenceComparer.Instance.Equals(intArrayRank2Field1.Type, int32Field1.Type)); 152Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpIntField1.Type, vbIntArrayField1.Type)); 153Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbIntArrayField1.Type, csharpStringArrayField1.Type)); 154Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpStringArrayField1.Type, vbIntArrayArrayField1.Type)); 155Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbIntArrayArrayField1.Type, csharpIntArrayRank2Field1.Type)); 156Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpIntArrayRank2Field1.Type, vbInt32Field1.Type)); 160Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbIntField1.Type, csharpIntArrayField1.Type)); 161Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpIntArrayField1.Type, vbStringArrayField1.Type)); 162Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbStringArrayField1.Type, csharpIntArrayArrayField1.Type)); 163Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpIntArrayArrayField1.Type, vbIntArrayRank2Field1.Type)); 164Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbIntArrayRank2Field1.Type, csharpInt32Field1.Type)); 221Assert.False(SymbolEquivalenceComparer.Instance.Equals(field2_v1, field2_v2)); 223Assert.False(SymbolEquivalenceComparer.Instance.Equals(field4_v1, field4_v2)); 273Assert.False(SymbolEquivalenceComparer.Instance.Equals(field2_v1, field2_v2)); 275Assert.False(SymbolEquivalenceComparer.Instance.Equals(field4_v1, field4_v2)); 312Assert.False(SymbolEquivalenceComparer.Instance.Equals(goo, goo_intInstantiation1)); 313Assert.False(SymbolEquivalenceComparer.Instance.Equals(goo, goo_intInstantiation2)); 314Assert.False(SymbolEquivalenceComparer.Instance.Equals(goo, goo_stringInstantiation)); 315Assert.False(SymbolEquivalenceComparer.Instance.Equals(goo_intInstantiation1, goo_stringInstantiation)); 352Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 381Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 410Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 439Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 590Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 650Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 692Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, csharpBarMethod)); 693Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, vbQuuxMethod)); 695Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, csharpGooMethod)); 696Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, vbGooMethod)); 697Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, vbQuuxMethod)); 739Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, csharpBarMethod)); 740Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, vbBarMethod)); 742Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, csharpGooMethod)); 743Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, vbGooMethod)); 744Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, vbBarMethod)); 765Assert.False(SymbolEquivalenceComparer.Instance.Equals(field1_v1, field2_v1)); 766Assert.False(SymbolEquivalenceComparer.Instance.Equals(field2_v1, field1_v1)); 833Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 834Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v2, method_v1)); 905Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 906Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v2, method_v1)); 959Assert.False(SymbolEquivalenceComparer.Instance.Equals(outer1, inner1)); 960Assert.False(SymbolEquivalenceComparer.Instance.Equals(inner1, outerType1)); 961Assert.False(SymbolEquivalenceComparer.Instance.Equals(outerType1, innerType1)); 962Assert.False(SymbolEquivalenceComparer.Instance.Equals(innerType1, outer1)); 1024Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type2_v1)); 1025Assert.False(SymbolEquivalenceComparer.Instance.Equals(type2_v1, type1_v1)); 1051Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type1_v2)); 1052Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v2, type1_v1)); 1078Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type1_v2)); 1079Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v2, type1_v1)); 1105Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type1_v2)); 1106Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v2, type1_v1)); 1140Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type1_v2)); 1141Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v2, type1_v1)); 1209Assert.False(trueComp.Equals(method_v1, method_v2)); 1210Assert.False(trueComp.Equals(method_v2, method_v1)); 1248Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 1280Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 1346Assert.False(SymbolEquivalenceComparer.TupleNamesMustMatchInstance.Equals(method_v1, method_v2)); 1379Assert.False(SymbolEquivalenceComparer.TupleNamesMustMatchInstance.Equals(method_v1, method_v2)); 1412Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 1467Assert.False(notIgnoreComparer.Equals(a1, a2)); 1468Assert.False(notIgnoreComparer.Equals(b1, b2)); 1469Assert.False(notIgnoreComparer.Equals(c1, c2)); 1470Assert.False(notIgnoreComparer.Equals(d1, d2)); 1598Assert.False(notIgnoreComparer.Equals(a1, a2)); 1599Assert.False(notIgnoreComparer.Equals(b1, b2)); 1600Assert.False(notIgnoreComparer.Equals(c1, c2)); 1601Assert.False(notIgnoreComparer.Equals(d1, d2)); 1663Assert.False(notIgnoreComparer.Equals(a1, a2)); 1664Assert.False(notIgnoreComparer.Equals(b1, b2)); 1665Assert.False(notIgnoreComparer.Equals(c1, c2)); 1666Assert.False(notIgnoreComparer.Equals(d1, d2)); 1835Assert.False(SymbolEquivalenceComparer.Instance.Equals(namespace1, namespace2)); 1871Assert.False(SymbolEquivalenceComparer.Instance.Equals(ta1, tb1)); 1872Assert.False(identityComparer.Equals(ta1, tb1)); 1877Assert.False(identityComparer.Equals(tb1, tb2)); 1953Assert.False(identityComparer.Equals(f1[0], f2[1])); 1954Assert.False(identityComparer.Equals(f1[0], f2[2])); 1955Assert.False(identityComparer.Equals(f1[0], f2[3])); 1957Assert.False(identityComparer.Equals(f1[1], f2[0])); 1959Assert.False(identityComparer.Equals(f1[1], f2[2])); 1960Assert.False(identityComparer.Equals(f1[1], f2[3])); 1962Assert.False(identityComparer.Equals(f1[2], f2[0])); 1963Assert.False(identityComparer.Equals(f1[2], f2[1])); 1965Assert.False(identityComparer.Equals(f1[2], f2[3])); 1967Assert.False(identityComparer.Equals(f1[3], f2[0])); 1968Assert.False(identityComparer.Equals(f1[3], f2[1])); 1969Assert.False(identityComparer.Equals(f1[3], f2[2]));
Microsoft.CodeAnalysis.Features.Test.Utilities (1)
EditAndContinue\EditAndContinueWorkspaceTestBase.cs (1)
65Assert.False(stream.CanRead);
Microsoft.CodeAnalysis.Features.UnitTests (24)
EditAndContinue\CompileTimeSolutionProviderTests.cs (2)
63Assert.False(compileTimeSolution.ContainsAnalyzerConfigDocument(analyzerConfigId)); 64Assert.False(compileTimeSolution.ContainsDocument(designTimeDocumentId));
EditAndContinue\EditAndContinueCapabilitiesTests.cs (2)
21Assert.False(service.HasFlag(EditAndContinueCapabilities.NewTypeDefinition)); 31Assert.False(service.HasFlag(EditAndContinueCapabilities.Baseline));
EditAndContinue\EditAndContinueMethodDebugInfoReaderTests.cs (3)
109Assert.False(reader.TryGetDocumentChecksum("/b/c.cs", out _, out _)); 110Assert.False(reader.TryGetDocumentChecksum("/a/d.cs", out _, out _)); 111Assert.False(reader.TryGetDocumentChecksum("/A/C.cs", out _, out _));
EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (16)
967Assert.False(designTimeOnlyDocument2.State.SupportsEditAndContinue()); 1800Assert.False(debuggingSession.LastCommittedSolution.StaleProjects.ContainsKey(projectId)); 1973Assert.False(debuggingSession.GetTestAccessor().HasProjectEmitBaseline(projectId)); 2004Assert.False(debuggingSession.GetTestAccessor().HasProjectEmitBaseline(projectId)); 2173Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: pathCommon, CancellationToken.None)); 2174Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: pathB, CancellationToken.None)); 2176Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: "NonexistentFile.cs", CancellationToken.None)); 2199Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 2202Assert.False(await EditSession.HasChangesAsync(solution, oldSolution, CancellationToken.None)); 2278Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, generatedDocument.FilePath, CancellationToken.None)); 2308Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, CancellationToken.None)); 2309Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, pathX, CancellationToken.None)); 2487Assert.False(await EditSession.HasChangesAsync(oldSolution, solution, sourceFilePath: sourcePath, CancellationToken.None)); 4187Assert.False(readers.Any(r => r is null)); 4322Assert.False(debuggingSession.GetTestAccessor().HasProjectEmitBaseline(projectBId)); 5466Assert.False(results.ModuleUpdates.Updates.IsEmpty);
EditAndContinue\RemoteEditAndContinueServiceTests.cs (1)
136Assert.False(captureAllMatchingDocuments);
Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (49)
CodeLens\CSharpCodeLensTests.cs (1)
447Assert.False(testLspServer.GetServerAccessor().HasShutdownStarted());
Completion\CompletionFeaturesTests.cs (5)
371Assert.False(someTextItem.Preselect); 377Assert.False(someTextItem.Preselect); 822Assert.False(results.IsIncomplete); 878Assert.False(results.IsIncomplete); 1107Assert.False(results.Items.Any(i => i.Label == "if"));
Completion\CompletionTests.cs (4)
322Assert.False(results.Items.Any(item => "Console" == item.Label)); 347Assert.False(results.Items.Any(item => "ctor" == item.Label)); 1232Assert.False(results.IsIncomplete); 1510Assert.False(list.IsIncomplete);
Configuration\DidChangeConfigurationNotificationHandlerTest.cs (1)
58Assert.False(clientCallbackTarget.ReceivedWorkspaceConfigurationRequest);
Diagnostics\DiagnosticRegistrationTests.cs (1)
82Assert.False(options.WorkspaceDiagnostics);
Diagnostics\PullDiagnosticTests.cs (11)
788Assert.False(results.Single().Diagnostics![1].Tags!.Contains(DiagnosticTag.Unnecessary)); 821AssertEx.All(results.Single().Diagnostics, d => Assert.False(d.Tags!.Contains(DiagnosticTag.Unnecessary))); 853Assert.False(results.Single().Diagnostics![0].Tags!.Contains(DiagnosticTag.Unnecessary)); 1459Assert.False(results.Any(r => r.TextDocument!.DocumentUri.GetRequiredParsedUri().LocalPath.Contains(".ts"))); 2079Assert.False(resultTask.IsCompleted); 2107Assert.False(resultTask.IsCompleted); 2136Assert.False(resultTask.IsCompleted); 2166Assert.False(resultTaskOne.IsCompleted); 2167Assert.False(resultTaskTwo.IsCompleted); 2192Assert.False(resultTaskOne.IsCompleted); 2193Assert.False(resultTaskTwo.IsCompleted);
DocumentChanges\DocumentChangesTests.cs (2)
379Assert.False(DidChangeHandler.AreChangesInReverseOrder([change1, change2, change3])); 389Assert.False(DidChangeHandler.AreChangesInReverseOrder([change1, change2, change3]));
HandlerTests.cs (4)
124Assert.False(server.GetServerAccessor().HasShutdownStarted()); 190Assert.False(didReport); 248Assert.False(didReport); 276Assert.False(didReport);
Hover\HoverTests.cs (1)
618Assert.False(classifiedTextElements.SelectMany(classifiedTextElements => classifiedTextElements.Runs).Any(run => run.NavigationAction != null));
InlayHint\AbstractInlayHintTests.cs (1)
54Assert.False(matchingInlayHint.PaddingLeft);
LanguageServerTargetTests.cs (6)
38Assert.False(server.GetServerAccessor().GetServerRpc().IsDisposed); 129Assert.False(statefulService.IsDisposed); 130Assert.False(statelessService.IsDisposed); 137Assert.False(statelessService.IsDisposed); 142Assert.False(server.GetServerAccessor().HasShutdownStarted()); 143Assert.False(server.GetQueueAccessor()!.Value.IsComplete());
Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (5)
46Assert.False(globalOptions.GetOption(FormattingOptions2.InsertFinalNewLine)); 80Assert.False(workspace.CurrentSolution.FallbackAnalyzerOptions.TryGetValue(LanguageNames.CSharp, out _)); 149Assert.False(workspace.CurrentSolution.FallbackAnalyzerOptions.TryGetValue(LanguageNames.CSharp, out _)); 278Assert.False(globalOptions.GetOption(option)); 287Assert.False(optionsAfterProjectAdded.ContainsKey("test_option"));
Ordering\RequestOrderingTests.cs (1)
154Assert.False(longRunningWaitable.IsCompleted);
ProtocolConversionsTests.cs (1)
310Assert.False(projectContext.IsMiscellaneous);
UriTests.cs (4)
113Assert.False(await testLspServer.GetManager().GetTestAccessor().IsMiscellaneousFilesDocumentAsync(document)); 124Assert.False(await testLspServer.GetManager().GetTestAccessor().IsMiscellaneousFilesDocumentAsync(document)); 316Assert.False(testLspServer.GetServerAccessor().HasShutdownStarted()); 317Assert.False(testLspServer.GetQueueAccessor()!.Value.IsComplete());
Workspaces\LspWorkspaceManagerTests.cs (1)
635Assert.False(oldClassDeclarations[2].IsIncrementallyIdenticalTo(newClassDeclarations[2]));
Microsoft.CodeAnalysis.LanguageServer.UnitTests (2)
LspFileChangeWatcherTests.cs (1)
33Assert.False(LspFileChangeWatcher.SupportsLanguageServerHost(testLspServer.LanguageServerHost));
Utilities\AbstractLanguageServerClientTests.TestLspClient.cs (1)
141Assert.False(_process.HasExited);
Microsoft.CodeAnalysis.Scripting.TestUtilities (1)
ScriptingTestHelpers.cs (1)
92Assert.False(noException);
Microsoft.CodeAnalysis.Scripting.UnitTests (6)
NuGetPackageResolverTests.cs (1)
55Assert.False(NuGetPackageResolver.TryParsePackageReference(reference, out name, out version));
ScriptOptionsTests.cs (5)
171Assert.False(ScriptOptions.Default.WithEmitDebugInformation(false).EmitDebugInformation); 172Assert.False(ScriptOptions.Default.EmitDebugInformation); 200Assert.False(ScriptOptions.Default.WithAllowUnsafe(false).AllowUnsafe); 227Assert.False(ScriptOptions.Default.WithCheckOverflow(false).CheckOverflow); 228Assert.False(ScriptOptions.Default.CheckOverflow);
Microsoft.CodeAnalysis.Test.Utilities (30)
Assert\EqualityTesting.cs (2)
27Assert.False(x.Equals(y)); 28Assert.False(((object)x).Equals(y));
Assert\EqualityUtil`1.cs (9)
79Assert.False(_compareWithEqualityOperator(unit.Value, value)); 80Assert.False(_compareWithEqualityOperator(value, unit.Value)); 94Assert.False(_compareWithEqualityOperator(default(T), value)); 95Assert.False(_compareWithEqualityOperator(value, default(T))); 105Assert.False(_compareWithInequalityOperator(unit.Value, value)); 106Assert.False(_compareWithInequalityOperator(value, unit.Value)); 176Assert.False(value.Equals((object)42)); 205Assert.False(equatableUnit.Equals(value)); 207Assert.False(equatableValue.Equals(unit.Value));
Compilation\ControlFlowGraphVerifier.cs (3)
218Assert.False(predecessorBranch.IsConditionalSuccessor); 285Assert.False(nextBranch.IsConditionalSuccessor); 1469Assert.False(region.Locals.IsEmpty && region.LocalFunctions.IsEmpty && region.CaptureIds.IsEmpty);
Compilation\OperationTreeVerifier.cs (2)
1024Assert.False(memberReference.Member.IsStatic && !operation.HasErrors(this._compilation)); 1028Assert.False(invocation.TargetMethod.IsStatic);
Compilation\TestOperationVisitor.cs (7)
393Assert.False(true); 1363Assert.False(pattern.ConstantValue.HasValue); 1425Assert.False(operation.MatchesNull); 1551Assert.False(operation.ConstantValue.HasValue); 1561Assert.False(operation.ConstantValue.HasValue); 1802Assert.False(operation.ConstantValue.HasValue); 1828Assert.False(operation.ConstantValue.HasValue);
CompilationVerifier.cs (1)
704Assert.False(GetEmitData().TestData.TryGetMethodData(qualifiedMethodName, out _));
Diagnostics\CommonDiagnosticAnalyzers.cs (1)
2062Assert.False(symbolEndContext.Symbol.IsImplicitlyDeclared);
Diagnostics\DiagnosticExtensions.cs (1)
126Assert.False(assemblyIds.IsEmpty);
Diagnostics\ThrowingDiagnosticAnalyzer.cs (1)
89Assert.False(diagnostics.Any(AnalyzerExecutor.IsAnalyzerExceptionDiagnostic));
Metadata\EncValidation.cs (3)
30Assert.False(currentModule.GenerationId.IsNil); 35Assert.False(currentModule.GenerationId.IsNil); 36Assert.False(currentModule.BaseGenerationId.IsNil);
Microsoft.CodeAnalysis.UnitTests (681)
Analyzers\AnalyzerConfigTests.cs (97)
380Assert.False(matcher.IsMatch("/aabc")); 381Assert.False(matcher.IsMatch("/ abc")); 382Assert.False(matcher.IsMatch("/cabc")); 410Assert.False(matcher.IsMatch("/abc.vb")); 431Assert.False(matcher.IsMatch("/aaa")); 432Assert.False(matcher.IsMatch("/???")); 433Assert.False(matcher.IsMatch("/abc")); 463Assert.False(matcher.IsMatch("/ab/c")); 464Assert.False(matcher.IsMatch("/ab\\\\c")); 474Assert.False(matcher.IsMatch("/ab/cd**efg*")); 475Assert.False(matcher.IsMatch("/*ab/cd*efg*")); 476Assert.False(matcher.IsMatch("/*ab/cd**ef/gh")); 487Assert.False(matcher.IsMatch("/aaaaaaaa")); 488Assert.False(matcher.IsMatch("/aa?cde?f")); 489Assert.False(matcher.IsMatch("/?a?cdexf")); 490Assert.False(matcher.IsMatch("/?axcde?f")); 501Assert.False(matcher.IsMatch("/abcdef")); 502Assert.False(matcher.IsMatch("/abc}{def")); 513Assert.False(matcher.IsMatch("/abcdef")); 514Assert.False(matcher.IsMatch("/abc\\,def")); 515Assert.False(matcher.IsMatch("/abc`def")); 531Assert.False(matcher.IsMatch("/abcxcs")); 532Assert.False(matcher.IsMatch("/abcxvb")); 533Assert.False(matcher.IsMatch("/abcxfs")); 534Assert.False(matcher.IsMatch("/subdir/abcxcs")); 535Assert.False(matcher.IsMatch("/subdir/abcxcb")); 536Assert.False(matcher.IsMatch("/subdir/abcxcs")); 557Assert.False(matcher.IsMatch("/subdir/test.cs")); 558Assert.False(matcher.IsMatch("/subdir/subdir/test.vb")); 559Assert.False(matcher.IsMatch("/test.vb")); 570Assert.False(matcher.IsMatch("/.")); 571Assert.False(matcher.IsMatch("/anything")); 582Assert.False(matcher.IsMatch("test.vb")); 583Assert.False(matcher.IsMatch("testxcs")); 613Assert.False(matcher.IsMatch("/test.fs")); 614Assert.False(matcher.IsMatch("/other.bbb")); 615Assert.False(matcher.IsMatch("/other.ccc")); 616Assert.False(matcher.IsMatch("/subdir/other.bbb")); 617Assert.False(matcher.IsMatch("/subdir/other.ccc")); 629Assert.False(matcher.IsMatch("/abcdef")); 630Assert.False(matcher.IsMatch("/ab--cd-ef")); 631Assert.False(matcher.IsMatch("/ab--cd--ef")); 644Assert.False(matcher.IsMatch("/abcs")); 645Assert.False(matcher.IsMatch("/abcd")); 646Assert.False(matcher.IsMatch("/vbcd")); 666Assert.False(matcher.IsMatch("/-1")); 667Assert.False(matcher.IsMatch("/-00000001")); 668Assert.False(matcher.IsMatch("/11")); 682Assert.False(matcher.IsMatch("/1")); 683Assert.False(matcher.IsMatch("/-11")); 684Assert.False(matcher.IsMatch("/--0")); 700Assert.False(matcher.IsMatch("/-11")); 701Assert.False(matcher.IsMatch("/11")); 702Assert.False(matcher.IsMatch("/--0")); 722Assert.False(matcher.IsMatch("/a-11b10")); 723Assert.False(matcher.IsMatch("/a-11b10")); 724Assert.False(matcher.IsMatch("/a-10b11")); 738Assert.False(matcher.IsMatch("/0")); 739Assert.False(matcher.IsMatch("/0.")); 740Assert.False(matcher.IsMatch("/0abc")); 744Assert.False(matcher.IsMatch("/0")); 745Assert.False(matcher.IsMatch("/0abc")); 762Assert.False(matcher.IsMatch("/abc.vs")); 771Assert.False(matcher.IsMatch("/abc.cs")); 772Assert.False(matcher.IsMatch("/abc.fs")); 775Assert.False(matcher.IsMatch("/abc.vxs")); 787Assert.False(matcher.IsMatch("/abc.vs")); 788Assert.False(matcher.IsMatch("/abc.xs")); 789Assert.False(matcher.IsMatch("/abc.vxs")); 801Assert.False(matcher.IsMatch("/yx")); 802Assert.False(matcher.IsMatch("/00x")); 811Assert.False(matcher.IsMatch("/0x")); 812Assert.False(matcher.IsMatch("/1x")); 813Assert.False(matcher.IsMatch("/9x")); 815Assert.False(matcher.IsMatch("/00x")); 829Assert.False(matcher.IsMatch("/yx")); 830Assert.False(matcher.IsMatch("/0ax")); 861Assert.False(matcher.IsMatch("/ab")); 862Assert.False(matcher.IsMatch("/[b")); 863Assert.False(matcher.IsMatch("/bc")); 864Assert.False(matcher.IsMatch("/ac")); 865Assert.False(matcher.IsMatch("/[c")); 878Assert.False(matcher.IsMatch("/bbd")); 879Assert.False(matcher.IsMatch("/-cd")); 880Assert.False(matcher.IsMatch("/bcd")); 893Assert.False(matcher.IsMatch("/bbd")); 894Assert.False(matcher.IsMatch("/-cd")); 895Assert.False(matcher.IsMatch("/bcd")); 907Assert.False(matcher.IsMatch("/acd")); 908Assert.False(matcher.IsMatch("/bcd")); 909Assert.False(matcher.IsMatch("/acd")); 922Assert.False(matcher.IsMatch("/dcd")); 923Assert.False(matcher.IsMatch("/\\\\cd")); 924Assert.False(matcher.IsMatch("/cd")); 935Assert.False(matcher.IsMatch("/ab[[cd")); 936Assert.False(matcher.IsMatch("/abc")); 937Assert.False(matcher.IsMatch("/abd"));
Analyzers\AnalyzerFileReferenceTests.cs (5)
76Assert.False(refA.Equals(null)); 82Assert.False(refA.Equals(new AnalyzerFileReference(path2, loader1))); 85Assert.False(refA.Equals(new AnalyzerFileReference(path1, loader2))); 89Assert.False(refA.Equals((AnalyzerReference?)null)); 92Assert.False(refA.Equals(new TestAnalyzerReference(path2)));
AsyncQueueTests.cs (9)
47Assert.False(queue.TryEnqueue(42)); 67Assert.False(task.IsCompleted); 87Assert.False(task.IsCompleted); 98Assert.False(task.IsCompleted); 168Assert.False(task.IsCanceled); 180Assert.False(task.IsCanceled); 188Assert.False(queue.IsCompleted); 197Assert.False(task.IsCompleted); 208Assert.False(queue.TryDequeue(out value));
CachingLookupTests.cs (4)
114Assert.False(look1.Contains(k)); 115Assert.False(look2.Contains(k)); 261Assert.False(lookedUp.Contains(s)); 267Assert.False(askedForKeys);
Collections\BitArrayTests.cs (4)
31Assert.False(arr[n]); 251Assert.False(i2.MoveNext()); 267Assert.False(b[index]); 289Assert.False(b[index]);
Collections\ByteSequenceComparerTests.cs (6)
18Assert.False(ByteSequenceComparer.Equals(new byte[] { 1 }, new byte[] { 2 })); 20Assert.False(ByteSequenceComparer.Equals(new byte[] { 1, 2 }, new byte[] { 1, 3 })); 30Assert.False(ByteSequenceComparer.Equals(new byte[] { 1 }, 0, new byte[] { 2 }, 0, 1)); 43Assert.False(ByteSequenceComparer.Equals(b, 0, b, 1, 1)); 45Assert.False(ByteSequenceComparer.Equals(null, b)); 46Assert.False(ByteSequenceComparer.Equals(null, new byte[] { }));
Collections\CachingFactoryTests.cs (1)
41Assert.False(found);
Collections\Extensions\EnumerableExtensionsTests.cs (22)
32Assert.False(RoslynEnumerableExtensions.SequenceEqual(new[] { 1 }, null, comparer)); 33Assert.False(RoslynEnumerableExtensions.SequenceEqual(null, new[] { 1 }, comparer)); 36Assert.False(RoslynEnumerableExtensions.SequenceEqual(new int[0], new[] { 1 }, comparer)); 37Assert.False(RoslynEnumerableExtensions.SequenceEqual(new[] { 1 }, new int[0], comparer)); 38Assert.False(RoslynEnumerableExtensions.SequenceEqual(new[] { 1, 2, 3 }, new[] { 1, 3, 2 }, comparer)); 123Assert.False(MakeEnumerable(0).IsEmpty()); 155Assert.False(seq.SequenceEqual(new int[] { 1, 2, 3, 4 }, equality)); 156Assert.False(seq.SequenceEqual(new int[] { 1, 2 }, equality)); 159Assert.False(seq.SequenceEqual(new int[] { 1, 2, 6 }, equality)); 176Assert.False(MakeEnumerable<int>().HasDuplicates()); 177Assert.False(MakeEnumerable<int>().HasDuplicates(comparer)); 178Assert.False(MakeEnumerable<int>().HasDuplicates(i => i + 1)); 180Assert.False(MakeEnumerable(1).HasDuplicates()); 181Assert.False(MakeEnumerable(1).HasDuplicates(comparer)); 182Assert.False(MakeEnumerable(1).HasDuplicates(i => i + 1)); 184Assert.False(MakeEnumerable(1, 2).HasDuplicates()); 185Assert.False(MakeEnumerable(1, 2).HasDuplicates(comparer)); 186Assert.False(MakeEnumerable(1, 2).HasDuplicates(i => i + 1)); 193Assert.False(MakeEnumerable(2, 0, 1, 3).HasDuplicates()); 194Assert.False(MakeEnumerable(2, 0, 1, 13).HasDuplicates(comparer)); 195Assert.False(MakeEnumerable(2, 0, 1, 53).HasDuplicates(i => i % 10)); 196Assert.False(MakeEnumerable(2.3, 0.1, 1.3, 53.4).HasDuplicates(i => (int)i, comparer));
Collections\Extensions\ImmutableArrayExtensionsTests.cs (42)
104Assert.False(nul.SetEquals(empty, comparer)); 105Assert.False(nul.SetEquals(original, comparer)); 107Assert.False(empty.SetEquals(nul, comparer)); 108Assert.False(empty.SetEquals(original, comparer)); 110Assert.False(original.SetEquals(nul, comparer)); 111Assert.False(original.SetEquals(empty, comparer)); 112Assert.False(original.SetEquals(notEqualSubset, comparer)); 113Assert.False(original.SetEquals(notEqualSuperset, comparer)); 120Assert.False(singleton1.SetEquals(singleton2, comparer)); 181Assert.False(roaNull != null); 183Assert.False(null != roaNull); 187Assert.False(copy != roaNull); 190Assert.False(notnull == null); 192Assert.False(null == notnull); 202Assert.False(roaCopy[0].HasValue); 204Assert.False(roaCopy[2].HasValue); 213Assert.False(roa.ElementAt(1).HasValue); 221Assert.False(roa.ElementAtOrDefault(-1).HasValue); 225Assert.False(roa.ElementAtOrDefault(10).HasValue); 242Assert.False(roa.LastOrDefault().HasValue); 244Assert.False(roa.LastOrDefault(i => i < 1).HasValue); 252Assert.False(roa.SingleOrDefault().HasValue); 340Assert.False(a.SequenceEqual(b)); 343Assert.False(a.SequenceEqual(c)); 344Assert.False(a.SequenceEqual(c, StringComparer.OrdinalIgnoreCase)); 345Assert.False(c.SequenceEqual(a)); 349Assert.False(r.SequenceEqual(Enumerable.Range(1, 2))); 350Assert.False(r.SequenceEqual(Enumerable.Range(1, 4))); 533Assert.False(other.ToImmutableArray().IsSubsetOf(array.ToImmutableArray())); 561Assert.False(ImmutableArray<int>.Empty.HasDuplicates()); 562Assert.False(ImmutableArray<int>.Empty.HasDuplicates(comparer)); 563Assert.False(ImmutableArray<int>.Empty.HasDuplicates(i => i + 1)); 565Assert.False(ImmutableArray.Create(1).HasDuplicates()); 566Assert.False(ImmutableArray.Create(1).HasDuplicates(comparer)); 567Assert.False(ImmutableArray.Create(1).HasDuplicates(i => i + 1)); 569Assert.False(ImmutableArray.Create(1, 2).HasDuplicates()); 570Assert.False(ImmutableArray.Create(1, 2).HasDuplicates(comparer)); 571Assert.False(ImmutableArray.Create(1, 2).HasDuplicates(i => i + 1)); 578Assert.False(ImmutableArray.Create(2, 0, 1, 3).HasDuplicates()); 579Assert.False(ImmutableArray.Create(2, 0, 1, 13).HasDuplicates(comparer)); 580Assert.False(ImmutableArray.Create(2, 0, 1, 53).HasDuplicates(i => i % 10)); 581Assert.False(ImmutableArray.Create(2.3, 0.1, 1.3, 53.4).HasDuplicates(i => (int)i, comparer));
Collections\Extensions\ListExtensionsTests.cs (13)
30Assert.False(new int[0].HasDuplicates()); 31Assert.False(new int[0].HasDuplicates(comparer)); 32Assert.False(new int[0].HasDuplicates(i => i + 1)); 34Assert.False(new[] { 1 }.HasDuplicates()); 35Assert.False(new[] { 1 }.HasDuplicates(comparer)); 36Assert.False(new[] { 1 }.HasDuplicates(i => i + 1)); 38Assert.False(new[] { 1, 2 }.HasDuplicates()); 39Assert.False(new[] { 1, 2 }.HasDuplicates(comparer)); 40Assert.False(new[] { 1, 2 }.HasDuplicates(i => i + 1)); 47Assert.False(new[] { 2, 0, 1, 3 }.HasDuplicates()); 48Assert.False(new[] { 2, 0, 1, 13 }.HasDuplicates(comparer)); 49Assert.False(new[] { 2, 0, 1, 53 }.HasDuplicates(i => i % 10)); 50Assert.False(new[] { 2.3, 0.1, 1.3, 53.4 }.HasDuplicates(i => (int)i, comparer));
Collections\HashSet\ISet_Generic_Tests`1.cs (6)
96Assert.False(set.Add(newValue)); 225Assert.False(set.IsSubsetOf(enumerable)); 237Assert.False(set.IsSupersetOf(enumerable)); 254Assert.False(set.Overlaps(enumerable)); 264Assert.False(set.SetEquals(enumerable)); 272Assert.False(set.SetEquals(enumerable));
Collections\HashSet\SegmentedHashSet_Generic_Tests`1.cs (5)
320Assert.False(noComparerSet.SetEquals(set)); 348Assert.False(noComparerSet.SequenceEqual(set)); 350Assert.False(comparerSet.SequenceEqual(set)); 477Assert.False(set.TryGetValue(equalValue, out T? actualValue)); 490Assert.False(set.TryGetValue(equalValue, out actualValue));
Collections\IdentifierCollectionTests.cs (1)
108Assert.False(collection.Contains(str));
Collections\ImmutableDictionaryBuilderTestBase.cs (14)
30Assert.False(builder.ContainsKey("four")); 91Assert.False(builder.Remove(new KeyValuePair<string, int>("foo", 1))); 123Assert.False(builder.IsReadOnly); 151Assert.False(builder.TryGetValue("four", out value)); 164Assert.False(enumerator.MoveNext()); 170Assert.False(manualEnum.MoveNext()); 187Assert.False(dictionary.Contains("a")); 188Assert.False(dictionary.IsFixedSize); 189Assert.False(dictionary.IsReadOnly); 209Assert.False(enumerator.MoveNext()); 214Assert.False(enumerator.MoveNext()); 226Assert.False(enumerator.MoveNext()); 231Assert.False(enumerator.MoveNext()); 255Assert.False(collection.IsSynchronized);
Collections\ImmutableDictionaryBuilderTestBase.nonnetstandard.cs (1)
29Assert.False(TryGetKeyHelper(builder, "b", out actualKey));
Collections\ImmutableDictionaryTestBase.cs (14)
172Assert.False(dictionary.Contains("a")); 197Assert.False(enumerator.MoveNext()); 202Assert.False(enumerator.MoveNext()); 214Assert.False(enumerator.MoveNext()); 219Assert.False(enumerator.MoveNext()); 233Assert.False(dictionary.TryGetKey("b", out actualKey)); 246Assert.False(empty.ContainsKey(someKey)); 247Assert.False(empty.Contains(new KeyValuePair<K, V?>(someKey, default(V)))); 250Assert.False(empty.TryGetValue(someKey, out V? value)); 284Assert.False(GetValueComparer(map).Equals(value1, value2)); 294Assert.False(map.ContainsKey(key)); 301Assert.False(map.Contains(new KeyValuePair<TKey, TValue>(key, value))); 302Assert.False(map.Contains(key, value)); 318Assert.False(removedMap.ContainsKey(key));
Collections\ImmutableDictionaryTestBase.nonnetstandard.cs (12)
70Assert.False(Empty<int, int>().Equals(null)); 71Assert.False(Empty<int, int>().Equals("hi")); 73Assert.False(Empty<int, int>().Add(3, 2).Equals(Empty<int, int>().Add(3, 2))); 74Assert.False(Empty<int, int>().Add(3, 2).Equals(Empty<int, int>().Add(3, 1))); 75Assert.False(Empty<int, int>().Add(5, 1).Equals(Empty<int, int>().Add(3, 1))); 76Assert.False(Empty<int, int>().Add(3, 1).Add(5, 1).Equals(Empty<int, int>().Add(3, 1))); 77Assert.False(Empty<int, int>().Add(3, 1).Equals(Empty<int, int>().Add(3, 1).Add(5, 1))); 82Assert.False(Empty<int, int>().Add(3, 1).ToReadOnlyDictionary().Equals(Empty<int, int>())); 83Assert.False(Empty<int, int>().Equals(Empty<int, int>().Add(3, 1).ToReadOnlyDictionary())); 84Assert.False(Empty<int, int>().ToReadOnlyDictionary().Equals(Empty<int, int>().Add(3, 1).ToReadOnlyDictionary())); 133Assert.False(map.ContainsKey(key)); 266Assert.False(manualEnum.MoveNext());
Collections\ImmutableListTestBase.cs (3)
120Assert.False(hitTest[i]); 134Assert.False(ExistsImpl(ImmutableSegmentedList<int>.Empty, n => true)); 138Assert.False(ExistsImpl(list, n => n == 8));
Collections\ImmutableSegmentedDictionaryBuilderTest.cs (10)
43Assert.False(builder.ContainsKey(7)); 51Assert.False(set.ContainsKey(8)); 65Assert.False(builder.ContainsKey(7)); 75Assert.False(set.ContainsKey(8)); 76Assert.False(set2.ContainsKey(8)); 88Assert.False(IsSame(immutable1, immutable2)); // "Mutating the collection did not reset the Immutable property." 132Assert.False(IsSame(collection, newImmutable)); // first ToImmutable with changes should be a new instance. 175Assert.False(builder.ContainsValue(4)); 185Assert.False(builder.ContainsKey("A")); 285Assert.False(dictionary.IsEmpty);
Collections\ImmutableSegmentedDictionaryTest.cs (8)
44Assert.False(map.ContainsKey("johnny")); 85Assert.False(dictionary.ContainsValue("c")); 86Assert.False(dictionary.ContainsValue(null)); 176Assert.False(map.ContainsKey("A")); 286Assert.False(IsSame(ImmutableSegmentedDictionary<string, int>.Empty, clearedDictionary.Clear())); 310Assert.False(map.Keys.All((key, arg) => key == arg, "a")); 323Assert.False(map.Values.All((key, arg) => key == arg, "1")); 347Assert.False(map.ContainsValue(value));
Collections\ImmutableSegmentedHashSetBuilderTest.cs (21)
37Assert.False(builder.Add(5)); 41Assert.False(builder.Contains(7)); 49Assert.False(set.Contains(8)); 60Assert.False(builder.Add(5)); 64Assert.False(builder.Contains(7)); 74Assert.False(set.Contains(8)); 75Assert.False(set2.Contains(8)); 109Assert.False(IsSame(collection, newImmutable)); // first ToImmutable with changes should be a new instance. 135Assert.False(builder.Contains("A")); 213Assert.False(builder.IsProperSubsetOf(Enumerable.Range(1, 3))); 222Assert.False(builder.IsProperSupersetOf(Enumerable.Range(1, 3))); 231Assert.False(builder.IsSubsetOf(Enumerable.Range(1, 2))); 241Assert.False(builder.IsSupersetOf(Enumerable.Range(1, 4))); 252Assert.False(builder.Overlaps(Enumerable.Range(4, 3))); 259Assert.False(builder.Remove("b")); 268Assert.False(builder.SetEquals(new[] { "b" })); 285Assert.False(builder.IsReadOnly); 295Assert.False(builder.Add(null)); 309Assert.False(builder.Remove(null)); 332Assert.False(builder.Contains(3)); 337Assert.False(set.IsEmpty);
Collections\ImmutableSegmentedHashSetTest.cs (4)
51Assert.False(ordinalSet.Contains("aPpLe")); 89Assert.False(enumerator.MoveNext()); 91Assert.False(enumerator.MoveNext()); 104Assert.False(enumerator.MoveNext());
Collections\ImmutableSegmentedListBuilderTest.cs (15)
42Assert.False(builder.Contains(7)); 50Assert.False(list.Contains(8)); 65Assert.False(builder.Contains(7)); 75Assert.False(list.Contains(8)); 76Assert.False(list2.Contains(8)); 88Assert.False(IsSame(immutable1, immutable2)); //, "Mutating the collection did not reset the Immutable property."); 124Assert.False(IsSame(collection, newImmutable)); // first ToImmutable with changes should be a new instance. 176Assert.False(mutable.Remove(5)); 188Assert.False(mutable.Remove(5)); 250Assert.False(builder.IsReadOnly); 305Assert.False(collection.IsSynchronized); 312Assert.False(list.IsReadOnly); 313Assert.False(list.IsFixedSize); 318Assert.False(list.Contains(7)); 420Assert.False(list.IsEmpty);
Collections\ImmutableSegmentedListTest.cs (24)
130Assert.False(list.IsEmpty); 313Assert.False(list.Contains(null)); 325Assert.False(list.Contains(null)); 353Assert.False(list.Contains(30)); 357Assert.False(list.Contains(100)); 361Assert.False(list.Contains(10)); 366Assert.False(list.Contains(20)); 367Assert.False(list.Contains(70)); 377Assert.False(list2.Contains(30)); 381Assert.False(list2.Contains(100)); 385Assert.False(list2.Contains(10)); 389Assert.False(list2.Contains(20)); 390Assert.False(list2.Contains(70)); 434Assert.False(list.Contains(30)); 438Assert.False(list.Contains(100)); 442Assert.False(list.Contains(10)); 453Assert.False(list.Contains(newElement)); 551Assert.False(IsSame(list, updatedList)); 568Assert.False(ImmutableSegmentedList<int>.Empty.Equals(null)); 569Assert.False(ImmutableSegmentedList<int>.Empty.Equals("hi")); 571Assert.False(ImmutableSegmentedList<int>.Empty.Add(3).Equals(ImmutableSegmentedList<int>.Empty.Add(3))); 672Assert.False(enumerator.MoveNext()); 679Assert.False(enumerator.MoveNext()); 694Assert.False(enumerator.MoveNext());
Collections\ImmutableSetTest.cs (8)
143Assert.False(Empty<int>().Equals(null)); 144Assert.False(Empty<int>().Equals("hi")); 146Assert.False(Empty<int>().Add(3).Equals(Empty<int>().Add(3))); 147Assert.False(Empty<int>().Add(5).Equals(Empty<int>().Add(3))); 148Assert.False(Empty<int>().Add(3).Add(5).Equals(Empty<int>().Add(3))); 149Assert.False(Empty<int>().Add(3).Equals(Empty<int>().Add(3).Add(5))); 229Assert.False(set.Contains(null)); 464Assert.False(enumerator.MoveNext()); // call it again to make sure it still returns false
Collections\ImmutableSetTest.nonnetstandard.cs (2)
103Assert.False(set.TryGetValue("foo", out actual)); 106Assert.False(set.Clear().TryGetValue("nonexistent", out actual));
Collections\ImmutablesTestBase.cs (2)
157Assert.False(enumerator.MoveNext()); 159Assert.False(enumerator.MoveNext());
Collections\List\ICollection.Generic.Tests.cs (6)
401Assert.False(collection.Contains(item)); 420Assert.False(collection.Contains(default(T)!)); 470Assert.False(collection.Contains(default(T)!)); 578Assert.False(collection.Remove(value)); 594Assert.False(collection.Remove(value)); 692Assert.False(collection.Remove(default(T)!));
Collections\List\IEnumerable.Generic.Tests.cs (4)
374Assert.False(enumerator.MoveNext()); 385Assert.False(enumerator.MoveNext()); 386Assert.False(enumerator.MoveNext()); 548Assert.False(enumerator.MoveNext());
Collections\List\IEnumerable.NonGeneric.Tests.cs (2)
187Assert.False(enumerator.MoveNext()); 188Assert.False(enumerator.MoveNext());
Collections\List\IList.NonGeneric.Tests.cs (2)
567Assert.False(collection.Contains(item)); 585Assert.False(collection.Contains(null));
Collections\List\SegmentedList.Generic.Tests.Constructor.cs (3)
30Assert.False(((IList<T>)list).IsReadOnly); //"List should not be readonly" 45Assert.False(((IList<T>)list).IsReadOnly); //"List should not be readonly" 71Assert.False(((IList<T>)list).IsReadOnly); //"List should not be readonly"
Collections\List\SegmentedList.Generic.Tests.Misc.cs (7)
450Assert.False(list.Contains(itemsY[i])); //"Should not contain item" 460Assert.False(list.Contains(items[i])); //"Should not contain item" 490Assert.False(list.Contains(items[items.Length / 2])); //"Should not contain item" 522Assert.False(_ilist.Contains(itemsY[i])); //"Should not contain item" 533Assert.False(_ilist.Contains(items[i])); //"Should not contain item" 565Assert.False(_ilist.Contains(items[items.Length / 2])); //"Should not contain item" 684Assert.False(list.TrueForAll(expectedItemDelegate)); //"Err_282308ahid Verify TrueForAll looks at every item FAILED\n"
Collections\SegmentedArrayTests.cs (2)
48Assert.False(data.IsSynchronized); 127Assert.False(data.IsSynchronized);
Collections\SegmentedCollectionsMarshalTests.cs (3)
442Assert.False(immutableList.IsDefault); 568Assert.False(immutableHashSet.IsDefault); 704Assert.False(immutableDictionary.IsDefault);
Collections\TemporaryArrayTests.cs (8)
37Assert.False(TemporaryArray<int>.Empty.GetEnumerator().MoveNext()); 48Assert.False(TemporaryArray<int>.TestAccessor.HasDynamicStorage(in array)); 54Assert.False(TemporaryArray<int>.TestAccessor.HasDynamicStorage(in array)); 96Assert.False(TemporaryArray<int>.TestAccessor.HasDynamicStorage(in array)); 118Assert.False(TemporaryArray<int>.TestAccessor.HasDynamicStorage(in array)); 166Assert.False(enumerator.MoveNext()); 302Assert.False(array.Contains(-1)); 303Assert.False(array.Contains(initialItems));
Collections\TopologicalSortTests.cs (2)
107Assert.False(wasAcyclic); 165Assert.False(wasAcyclic);
CommonSqmUtilitiesTests.cs (2)
38Assert.False(result); 49Assert.False(result);
CommonSyntaxTests.cs (2)
49Assert.False(d.IsNode); 66Assert.False(d.IsNode);
CorLibTypesTests.cs (4)
170Assert.False(cv4.IsDateTime); 173Assert.False(cv5.IsNumeric); 174Assert.False(cv5.IsBoolean); 175Assert.False(cv5.IsFloating);
CryptoBlobParserTests.cs (4)
173Assert.False(CryptoBlobParser.TryParseKey(TestHelpers.HexToByte(invalidKeyBlobs[0].AsSpan()), out _, out _)); 174Assert.False(CryptoBlobParser.TryParseKey(TestHelpers.HexToByte(invalidKeyBlobs[1].AsSpan()), out _, out _)); 175Assert.False(CryptoBlobParser.TryParseKey(TestHelpers.HexToByte(invalidKeyBlobs[2].AsSpan()), out _, out _)); 176Assert.False(CryptoBlobParser.TryParseKey(TestHelpers.HexToByte(invalidKeyBlobs[3].AsSpan()), out _, out _));
Diagnostics\DiagnosticLocalizationTests.cs (3)
254Assert.False(str.Equals(42)); 255Assert.False(str.Equals(42)); 256Assert.False(threw);
Emit\EmitOptionsTests.cs (1)
42Assert.False(newOpt1.Equals(oldOpt1));
FileSystem\PathUtilitiesTests.cs (32)
183Assert.False( 187Assert.False( 189Assert.False( 196Assert.False( 200Assert.False( 202Assert.False( 209Assert.False( 213Assert.False( 215Assert.False( 218Assert.False( 220Assert.False( 222Assert.False( 224Assert.False( 226Assert.False( 228Assert.False( 235Assert.False( 239Assert.False( 241Assert.False( 244Assert.False( 246Assert.False( 248Assert.False( 250Assert.False( 252Assert.False( 254Assert.False( 288Assert.False(PathUtilities.IsSameDirectoryOrChildOf(@"C:\", @"C:\ABCD")); 289Assert.False(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABC", @"C:\ABCD")); 290Assert.False(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCDE", @"C:\ABCD")); 292Assert.False(PathUtilities.IsSameDirectoryOrChildOf(@"C:\A\B\C", @"C:\A\B\C\D")); 301Assert.False(PathUtilities.IsSameDirectoryOrChildOf(@"C:\a\B\C", @"C:\A\B", StringComparison.Ordinal)); 302Assert.False(PathUtilities.IsSameDirectoryOrChildOf(@"C:\A\b\C", @"C:\A\B", StringComparison.Ordinal)); 311Assert.False(PathUtilities.IsSameDirectoryOrChildOf(@"/a/B/C", @"/A/B", StringComparison.Ordinal)); 312Assert.False(PathUtilities.IsSameDirectoryOrChildOf(@"/A/b/C", @"/A/B", StringComparison.Ordinal));
FileUtilitiesTests.cs (7)
22Assert.False(PathUtilities.IsAbsolute(null)); 23Assert.False(PathUtilities.IsAbsolute("")); 24Assert.False(PathUtilities.IsAbsolute("C")); 25Assert.False(PathUtilities.IsAbsolute("C:")); 29Assert.False(PathUtilities.IsAbsolute(@"C\")); 37Assert.False(PathUtilities.IsAbsolute(@"\C")); 38Assert.False(PathUtilities.IsAbsolute(@"/C"));
GivesAccessTo.cs (2)
58Assert.False(CS.ContainingAssembly.GivesAccessTo(VB2.ContainingAssembly)); 62Assert.False(VB.ContainingAssembly.GivesAccessTo(CS2.ContainingAssembly));
InternalUtilities\OneOrManyTests.cs (40)
82Assert.False(OneOrMany.Create(1).Contains(0)); 84Assert.False(OneOrMany.Create(ImmutableArray<int>.Empty).Contains(0)); 87Assert.False(OneOrMany.Create(ImmutableArray.Create(1)).Contains(0)); 91Assert.False(OneOrMany.Create(ImmutableArray.Create(1, 2)).Contains(0)); 154Assert.False(OneOrMany.Create(1).All(i => i > 1)); 157Assert.False(OneOrMany.Create(1, 2).All(i => i > 1)); 167Assert.False(OneOrMany.Create(1).All((i, a) => i > a, 1)); 170Assert.False(OneOrMany.Create(1, 2).All((i, a) => i > a, 1)); 177Assert.False(OneOrMany<int>.Empty.Any()); 185Assert.False(OneOrMany<int>.Empty.Any(_ => false)); 186Assert.False(OneOrMany<int>.Empty.Any(_ => true)); 188Assert.False(OneOrMany.Create(1).Any(i => i > 1)); 191Assert.False(OneOrMany.Create(1, 2).Any(i => i < 0)); 198Assert.False(OneOrMany<int>.Empty.Any((_, _) => false, 0)); 199Assert.False(OneOrMany<int>.Empty.Any((_, _) => true, 0)); 201Assert.False(OneOrMany.Create(1).Any((i, a) => i > a, 1)); 204Assert.False(OneOrMany.Create(1, 2).Any((i, a) => i < a, 0)); 225Assert.False(OneOrMany<int>.Empty.SequenceEqual(OneOrMany.Create(1))); 226Assert.False(OneOrMany<int>.Empty.SequenceEqual(OneOrMany.Create(1, 2))); 227Assert.False(OneOrMany.Create(1).SequenceEqual(OneOrMany<int>.Empty)); 228Assert.False(OneOrMany.Create(1, 2).SequenceEqual(OneOrMany<int>.Empty)); 230Assert.False(OneOrMany.Create(1).SequenceEqual(OneOrMany.Create(2))); 232Assert.False(OneOrMany.Create(1, 2).SequenceEqual(OneOrMany.Create(1, 0))); 234Assert.False(OneOrMany.Create(1, 2).SequenceEqual(OneOrMany.Create(ImmutableArray.Create(1, 2, 3)))); 238Assert.False(OneOrMany<int>.Empty.SequenceEqual(new[] { 1 })); 239Assert.False(OneOrMany<int>.Empty.SequenceEqual(new[] { 1, 2 })); 241Assert.False(OneOrMany.Create(1).SequenceEqual(new[] { 2 })); 243Assert.False(OneOrMany.Create(1, 2).SequenceEqual(new[] { 1, 0 })); 244Assert.False(OneOrMany.Create(1, 2).SequenceEqual(new[] { 1, 2, 3 })); 247Assert.False(new[] { 1 }.SequenceEqual(OneOrMany<int>.Empty)); 248Assert.False(new[] { 1, 2 }.SequenceEqual(OneOrMany<int>.Empty)); 250Assert.False(new[] { 1 }.SequenceEqual(OneOrMany.Create(2))); 252Assert.False(new[] { 1, 2 }.SequenceEqual(OneOrMany.Create(1, 0))); 253Assert.False(new[] { 1, 2 }.SequenceEqual(OneOrMany.Create(ImmutableArray.Create(1, 2, 3)))); 256Assert.False(ImmutableArray.Create(1).SequenceEqual(OneOrMany<int>.Empty)); 257Assert.False(ImmutableArray.Create(1, 2).SequenceEqual(OneOrMany<int>.Empty)); 259Assert.False(ImmutableArray.Create(1).SequenceEqual(OneOrMany.Create(2))); 261Assert.False(ImmutableArray.Create(1, 2).SequenceEqual(OneOrMany.Create(1, 0))); 262Assert.False(ImmutableArray.Create(1, 2).SequenceEqual(OneOrMany.Create(ImmutableArray.Create(1, 2, 3)))); 271Assert.False(OneOrMany.Create(1, 2).SequenceEqual(new[] { 0, 1 }, comparer));
InternalUtilities\SpecializedCollectionsTests.cs (10)
30Assert.False(emptySet.GetEnumerator().MoveNext()); 31Assert.False(((IEnumerable)emptySet).GetEnumerator().MoveNext()); 36Assert.False(emptySet.Contains(0)); 45Assert.False(emptySet.IsProperSubsetOf(new int[0])); 47Assert.False(emptySet.IsProperSupersetOf(new int[0])); 48Assert.False(emptySet.IsProperSupersetOf(new int[1])); 52Assert.False(emptySet.IsSupersetOf(new int[1])); 53Assert.False(emptySet.Overlaps(new int[0])); 54Assert.False(emptySet.Overlaps(new int[1])); 56Assert.False(emptySet.SetEquals(new int[1]));
MetadataReferences\AssemblyIdentityDisplayNameTests.cs (3)
27Assert.False(AssemblyIdentity.TryParseVersion(value, out actual, out actualParts)); 378Assert.False( 410Assert.False(AssemblyIdentity.TryParseDisplayName(name, out _));
MetadataReferences\AssemblyIdentityMapTests.cs (4)
39Assert.False(map.Contains(new AssemblyIdentity("a", new Version(1, 1, 0, 0)), allowHigherVersion: false)); 40Assert.False(map.TryGetValue(new AssemblyIdentity("a", new Version(1, 1, 0, 0)), out value, allowHigherVersion: false)); 43Assert.False(map.Contains(new AssemblyIdentity("b", new Version(1, 1, 0, 0)), allowHigherVersion: true)); 44Assert.False(map.Contains(new AssemblyIdentity("b", new Version(1, 1, 0, 0)), allowHigherVersion: false));
MetadataReferences\AssemblyIdentityTests.cs (20)
45Assert.False(id1.Equals(id3)); 46Assert.False(id1.Equals(id4)); 47Assert.False(id1.Equals(id5)); 48Assert.False(id1.Equals(id6)); 49Assert.False(id1.Equals(id7)); 53Assert.False(id2.Equals((AssemblyIdentity)null)); 57Assert.False(win1.Equals(win2)); 58Assert.False(win1.Equals(id1)); 102Assert.False(id.HasPublicKey); 103Assert.False(id.IsStrongName); 148Assert.False(id.HasPublicKey); 149Assert.False(id.IsRetargetable); 160Assert.False(id.IsRetargetable); 170Assert.False(id.HasPublicKey); 193Assert.False(id.IsRetargetable); 209Assert.False(id3.IsStrongName); 214Assert.False(id4.IsStrongName); 274Assert.False(id.HasPublicKey); 286Assert.False(id.HasPublicKey); 287Assert.False(id.IsRetargetable);
MetadataReferences\MetadataHelpersTests.cs (16)
30Assert.False(MetadataHelpers.IsValidMetadataIdentifier(null)); 31Assert.False(MetadataHelpers.IsValidMetadataIdentifier("")); 33Assert.False(MetadataHelpers.IsValidMetadataIdentifier("\0")); 34Assert.False(MetadataHelpers.IsValidMetadataIdentifier("x\0")); 35Assert.False(MetadataHelpers.IsValidMetadataIdentifier("\0x")); 36Assert.False(MetadataHelpers.IsValidMetadataIdentifier("abc\0xyz\0uwq")); 37Assert.False(MetadataHelpers.IsValidMetadataIdentifier(lowSurrogate)); 38Assert.False(MetadataHelpers.IsValidMetadataIdentifier(highSurrogate)); 40Assert.False(MetadataHelpers.IsValidMetadataIdentifier(lowSurrogate + highSurrogate)); 41Assert.False(MetadataHelpers.IsValidMetadataIdentifier(highSurrogate + "x" + lowSurrogate)); 42Assert.False(MetadataHelpers.IsValidMetadataIdentifier(lowSurrogate + "x" + highSurrogate)); 43Assert.False(MetadataHelpers.IsValidMetadataIdentifier(highSurrogate + "xxx")); 44Assert.False(MetadataHelpers.IsValidMetadataIdentifier(lowSurrogate + "xxx")); 45Assert.False(MetadataHelpers.IsValidMetadataIdentifier(lowSurrogate + "\0" + highSurrogate)); 46Assert.False(MetadataHelpers.IsValidMetadataIdentifier(highSurrogate + "\0" + lowSurrogate)); 451Assert.False(nestedNamespaces.GroupBy(pair => pair.Key).Where(g => g.Count() > 1).Any());
MetadataReferences\MetadataReferencePropertiesTests.cs (2)
22Assert.False(m.EmbedInteropTypes); 32Assert.False(m.EmbedInteropTypes);
MetadataReferences\MetadataReferenceTests.cs (16)
72Assert.False(r.Properties.EmbedInteropTypes); 88Assert.False(r.Properties.EmbedInteropTypes); 101Assert.False(stream.CanRead); 106Assert.False(r.Properties.EmbedInteropTypes); 137Assert.False(r.Properties.EmbedInteropTypes); 153Assert.False(r.Properties.EmbedInteropTypes); 169Assert.False(r.Properties.EmbedInteropTypes); 192Assert.False(r.Properties.EmbedInteropTypes); 212Assert.False(r.Properties.EmbedInteropTypes); 261Assert.False(r.Properties.EmbedInteropTypes); 320Assert.False(r4.Properties.EmbedInteropTypes); 328Assert.False(r5.Properties.EmbedInteropTypes); 342Assert.False(r.Properties.EmbedInteropTypes); 348Assert.False(r1.Properties.EmbedInteropTypes); 373Assert.False(r.Properties.EmbedInteropTypes); 379Assert.False(r1.Properties.EmbedInteropTypes);
MetadataReferences\ModuleMetadataTests.cs (8)
198Assert.False(seeked); 226Assert.False(seeked); 250Assert.False(disposed); 256Assert.False(seeked); 281Assert.False(disposed); 287Assert.False(seeked); 345Assert.False(disposed); 384Assert.False(seeked);
MetadataReferences\ModuleNoPiaTests.cs (2)
25Assert.False(pia1.ContainsNoPiaLocalTypes()); 26Assert.False(pia1.ContainsNoPiaLocalTypes());
PEWriter\UsedNamespaceOrTypeTests.cs (1)
72Assert.False(type1.Object.Equals(type3.Object));
ShadowCopyAnalyzerPathResolverTests.cs (2)
46Assert.False(Directory.Exists(PathResolver.ShadowDirectory)); 57Assert.False(File.Exists(shadowPath));
StringTableTests.cs (20)
104Assert.False(TestTextEqualsASCII("a", "")); 105Assert.False(TestTextEqualsASCII("", "a")); 107Assert.False(TestTextEqualsASCII("a", "ab")); 108Assert.False(TestTextEqualsASCII("ab", "a")); 109Assert.False(TestTextEqualsASCII("abc", "a")); 110Assert.False(TestTextEqualsASCII("abcd", "a")); 111Assert.False(TestTextEqualsASCII("abcde", "a")); 112Assert.False(TestTextEqualsASCII("abcdef", "a")); 113Assert.False(TestTextEqualsASCII("abcdefg", "a")); 114Assert.False(TestTextEqualsASCII("abcdefgh", "a")); 115Assert.False(TestTextEqualsASCII("a", "ab")); 116Assert.False(TestTextEqualsASCII("a", "abc")); 117Assert.False(TestTextEqualsASCII("a", "abcd")); 118Assert.False(TestTextEqualsASCII("a", "abcde")); 119Assert.False(TestTextEqualsASCII("a", "abcdef")); 120Assert.False(TestTextEqualsASCII("a", "abcdefg")); 121Assert.False(TestTextEqualsASCII("a", "abcdefgh")); 122Assert.False(TestTextEqualsASCII("\u1234", "a")); 123Assert.False(TestTextEqualsASCII("\ud800", "xx")); 124Assert.False(TestTextEqualsASCII("\uffff", ""));
Text\SourceTextTests.cs (12)
216Assert.False(f.ContentEquals(SourceText.From(HelloWorld + "o", s_utf8))); 291Assert.False(sourceText1.ContentEquals(sourceText2)); 292Assert.False(sourceText1.GetContentHash().SequenceEqual(sourceText2.GetContentHash())); 313Assert.False(sourceText1.ContentEquals(sourceText2)); 315Assert.False(sourceText1.GetContentHash().SequenceEqual(sourceText2.GetContentHash())); 321Assert.False(SourceText.IsBinary("")); 323Assert.False(SourceText.IsBinary("\0abc")); 324Assert.False(SourceText.IsBinary("a\0bc")); 325Assert.False(SourceText.IsBinary("abc\0")); 326Assert.False(SourceText.IsBinary("a\0b\0c")); 333Assert.False(SourceText.IsBinary(encoding.GetString(new byte[] { 0x81, 0x8D, 0x8F, 0x90, 0x9D }))); 335Assert.False(SourceText.IsBinary("abc def baz aeiouy \u00E4\u00EB\u00EF\u00F6\u00FC\u00FB"));
Text\TextSpanTest.cs (28)
105Assert.False(span.IsEmpty); 133Assert.False(span.Contains(30)); 134Assert.False(span.Contains(11)); 135Assert.False(span.Contains(-1)); 147Assert.False(span_05_15.Contains(span_00_03)); 148Assert.False(span_00_03.Contains(span_05_15)); 157Assert.False(span_05_15.Contains(span_03_10)); 158Assert.False(span_03_10.Contains(span_05_15)); 165Assert.False(new TextSpan(2, 5).Contains(new TextSpan(0, 0))); 166Assert.False(new TextSpan(2, 5).Contains(new TextSpan(10, 0))); 185Assert.False(new TextSpan(0, 0).Contains(new TextSpan(2, 5))); 186Assert.False(new TextSpan(10, 0).Contains(new TextSpan(2, 5))); 189Assert.False(new TextSpan(3, 0).Contains(new TextSpan(2, 5))); 192Assert.False(new TextSpan(2, 0).Contains(new TextSpan(2, 5))); 195Assert.False(new TextSpan(7, 0).Contains(new TextSpan(2, 5))); 222Assert.False(span1.Equals(span2)); 223Assert.False(span1.Equals(span3)); 224Assert.False(span2.Equals(span3)); 239Assert.False(span1.OverlapsWith(span2)); 240Assert.False(span2.OverlapsWith(span1)); 251Assert.False(span1.OverlapsWith(span2)); 252Assert.False(span2.OverlapsWith(span1)); 275Assert.False(span1.OverlapsWith(span2)); 276Assert.False(span2.OverlapsWith(span1)); 287Assert.False(span1.OverlapsWith(span2)); 288Assert.False(span2.OverlapsWith(span1)); 311Assert.False(span1.IntersectsWith(span2)); 312Assert.False(span2.IntersectsWith(span1));
Text\TextUtilitiesTests.cs (2)
28Assert.False(TextUtilities.IsAnyLineBreakCharacter('a')); 29Assert.False(TextUtilities.IsAnyLineBreakCharacter('b'));
VersionHelperTests.cs (46)
100Assert.False(VersionHelper.TryParseAssemblyVersion("1.234.56.7.*", allowWildcard: true, version: out version)); 102Assert.False(VersionHelper.TryParseAssemblyVersion("1.234.56.7.1", allowWildcard: true, version: out version)); 104Assert.False(VersionHelper.TryParseAssemblyVersion("*", allowWildcard: true, version: out version)); 106Assert.False(VersionHelper.TryParseAssemblyVersion("1.2. *", allowWildcard: true, version: out version)); 108Assert.False(VersionHelper.TryParseAssemblyVersion("1.2.* ", allowWildcard: true, version: out version)); 110Assert.False(VersionHelper.TryParseAssemblyVersion("1.*", allowWildcard: true, version: out version)); 112Assert.False(VersionHelper.TryParseAssemblyVersion("1.1.*.*", allowWildcard: true, version: out version)); 114Assert.False(VersionHelper.TryParseAssemblyVersion("", allowWildcard: true, version: out version)); 116Assert.False(VersionHelper.TryParseAssemblyVersion(" ", allowWildcard: true, version: out version)); 118Assert.False(VersionHelper.TryParseAssemblyVersion(null, allowWildcard: true, version: out version)); 120Assert.False(VersionHelper.TryParseAssemblyVersion("a", allowWildcard: true, version: out version)); 122Assert.False(VersionHelper.TryParseAssemblyVersion("********", allowWildcard: true, version: out version)); 124Assert.False(VersionHelper.TryParseAssemblyVersion("...", allowWildcard: true, version: out version)); 126Assert.False(VersionHelper.TryParseAssemblyVersion(".a.b.", allowWildcard: true, version: out version)); 128Assert.False(VersionHelper.TryParseAssemblyVersion(".0.1.", allowWildcard: true, version: out version)); 130Assert.False(VersionHelper.TryParseAssemblyVersion("65535.65535.65535.65535", allowWildcard: true, version: out version)); 132Assert.False(VersionHelper.TryParseAssemblyVersion("65535.65535.65535.65535", allowWildcard: false, version: out version)); 134Assert.False(VersionHelper.TryParseAssemblyVersion(" 1.2.3.4", allowWildcard: true, version: out version)); 136Assert.False(VersionHelper.TryParseAssemblyVersion("1 .2.3.4", allowWildcard: true, version: out version)); 138Assert.False(VersionHelper.TryParseAssemblyVersion("1.2.3.4 ", allowWildcard: true, version: out version)); 140Assert.False(VersionHelper.TryParseAssemblyVersion("1.2.3. 4", allowWildcard: true, version: out version)); 142Assert.False(VersionHelper.TryParseAssemblyVersion("1.2. 3.4", allowWildcard: true, version: out version)); 146Assert.False(VersionHelper.TryParseAssemblyVersion("\uFF11.\uFF10.\uFF10.\uFF10", allowWildcard: true, version: out version)); 155Assert.False(VersionHelper.TryParse("", out version)); 157Assert.False(VersionHelper.TryParse(null, out version)); 159Assert.False(VersionHelper.TryParse("a", out version)); 161Assert.False(VersionHelper.TryParse("********", out version)); 163Assert.False(VersionHelper.TryParse("...", out version)); 165Assert.False(VersionHelper.TryParse(".a.b.", out version)); 167Assert.False(VersionHelper.TryParse(".1.2.", out version)); 169Assert.False(VersionHelper.TryParse("1.234.56.7.8", out version)); 171Assert.False(VersionHelper.TryParse("*", out version)); 173Assert.False(VersionHelper.TryParse("-1.2.3.4", out version)); 177Assert.False(VersionHelper.TryParse("\uFF11.\uFF10.\uFF10.\uFF10", out version)); 186Assert.False(VersionHelper.TryParse("1.2. 3", out version)); 188Assert.False(VersionHelper.TryParse("1.2.3 ", out version)); 190Assert.False(VersionHelper.TryParse("1.a", out version)); 192Assert.False(VersionHelper.TryParse("1.2.a.b", out version)); 194Assert.False(VersionHelper.TryParse("1.-2.3.4", out version)); 196Assert.False(VersionHelper.TryParse("1..1.2", out version)); 198Assert.False(VersionHelper.TryParse("1.1.65536", out version)); 200Assert.False(VersionHelper.TryParse("1.1.1.10000000", out version)); 202Assert.False(VersionHelper.TryParse("1.1.18446744073709551617999999999999999999999999900001.1", out version)); 204Assert.False(VersionHelper.TryParse("1.1.18446744073709551617999999999999999999999999900001garbage.1", out version)); 206Assert.False(VersionHelper.TryParse("1.1.18446744073709551617999999999999999999999999900001.23garbage", out version)); 208Assert.False(VersionHelper.TryParse("65536.2.65536.1", out version));
Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests (46)
CommandLineIVTTests.vb (2)
577Assert.False(compiler.Arguments.ReportInternalsVisibleToAttributes) 590Assert.False(compiler.Arguments.ReportInternalsVisibleToAttributes)
CommandLineTests.vb (44)
829Assert.False(args.InteractiveMode) 834Assert.False(args.InteractiveMode) 842Assert.False(args.InteractiveMode) 854Assert.False(args.InteractiveMode) 1193Assert.False(resource.IsPublic) 1201Assert.False(resource.IsPublic) 1209Assert.False(resource.IsPublic) 1222Assert.False(resource.IsPublic) 1230Assert.False(resource.IsPublic) 1310Assert.False(resource.IsPublic) 1424Assert.False(parsedArgs.DisplayVersion) 2665Assert.False(outWriter.ToString().Contains("warning Warning03")) 2797Assert.False(outWriter.ToString().Contains("Warning01")) 2798Assert.False(outWriter.ToString().Contains("Warning03")) 3029Assert.False(parsedArgs.EmitPdb) 3034Assert.False(parsedArgs.EmitPdb) 3049Assert.False(parsedArgs.EmitPdb) 3094Assert.False(parsedArgs.EmitPdb) 3114Assert.False(parsedArgs.EmitPdb) 4546Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics) 4552Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics) 4590Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics) 4611Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics) 4617Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics) 4623Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics) 4630Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics) 4637Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics) 4847Assert.False(parsedArgs.CompilationOptions.CheckOverflow) 4851Assert.False(parsedArgs.CompilationOptions.CheckOverflow) 5383Assert.False(parsedArgs.EmitOptions.HighEntropyVirtualAddressSpace) 5385Assert.False(parsedArgs.EmitOptions.HighEntropyVirtualAddressSpace) 5388Assert.False(parsedArgs.EmitOptions.HighEntropyVirtualAddressSpace) 5391Assert.False(parsedArgs.EmitOptions.HighEntropyVirtualAddressSpace) 8931Assert.False(args2.ReportAnalyzer) 8963Assert.False(ParsedArgs.SkipAnalyzers) 8979Assert.False(ParsedArgs.SkipAnalyzers) 8987Assert.False(ParsedArgs.SkipAnalyzers) 9240Assert.False(args.CompilationOptions.PublicSign) 9243Assert.False(args.CompilationOptions.PublicSign) 9426Assert.False(File.Exists(dll)) 9429Assert.False(File.Exists(refDll)) 9482Assert.False(File.Exists(pdb)) 9719Assert.False(comp.SignUsingBuilder) 10702Assert.[False](hostOutputRan)
Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests (12)
VisualBasicSyntaxFactsServiceTests.vb (12)
45Assert.False(IsMethodLevelMember(" 93Assert.False(IsMethodLevelMember(" 128Assert.False(IsMethodLevelMember(" 146Assert.False(IsMethodLevelMember(" 164Assert.False(IsMethodLevelMember(" 189Assert.False(IsMethodLevelMember(" 203Assert.False(IsMethodLevelMember(" 211Assert.False(IsMethodLevelMember(" 472Assert.False(IsQueryKeyword(WrapInMethod(" 481Assert.False(IsQueryKeyword(WrapInMethod(" 490Assert.False(IsQueryKeyword(WrapInMethod(" 498Assert.False(IsQueryKeyword(WrapInMethod("
Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (13)
RpcTests.cs (7)
141Assert.False(call1.IsCompleted); 148Assert.False(call2.IsCompleted); 154Assert.False(call2.IsCompleted); 171Assert.False(call1.IsCompleted); 178Assert.False(call2.IsCompleted); 184Assert.False(call1.IsCompleted); 242Assert.False(cancellationToken.CanBeCanceled);
VisualStudioMSBuildWorkspaceTests.cs (6)
323Assert.False(File.Exists(p1.OutputFilePath)); 1906Assert.False(options.PreprocessorSymbolNames.Contains("EnableMyAttribute")); 2084Assert.False(File.Exists(document.FilePath)); 2188Assert.False(workspace.CanApplyChange(ApplyChangesKind.AddAdditionalDocument)); 2198Assert.False(workspace.CanApplyChange(ApplyChangesKind.RemoveAdditionalDocument)); 2918Assert.False(projFileText.Contains(@"<Analyzer Include=""..\Analyzers\MyAnalyzer.dll"));
Microsoft.CodeAnalysis.Workspaces.UnitTests (223)
CodeCleanup\CodeCleanupTests.cs (1)
315Assert.False(newSemanticModel.IsSpeculativeSemanticModel);
CommandLineProject\CommandLineProjectWorkspaceTests.cs (1)
46Assert.False(tree.ContainsDiagnostics);
EditorConfigParsing\EditorConfigFileParserTests.cs (3)
63Assert.False(parseResults.TryGetSectionForLanguage(Language.CSharp, out _)); 142Assert.False(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\CSharp\Program.cs", out _)); 143Assert.False(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\VisualBasic\Program.vb", out _));
EditorConfigParsing\SectionParserTests.cs (7)
80Assert.False(section.SupportsLanguage(language)); 93Assert.False(section.SupportsLanguage(language)); 104Assert.False(section.SupportsLanguage(language, matchKind: SectionMatch.ExactLanguageMatchWithOthers)); 113Assert.False(section.SupportsLanguage(language, matchKind: SectionMatch.AnyLanguageMatch)); 122Assert.False(section.SupportsLanguage(language, matchKind: SectionMatch.SupersetFilePatternMatch)); 153Assert.False(section.SupportsLanguage(language, matchKind: SectionMatch.FilePatternMatch)); 211Assert.False(section.SupportsFilePath(codefilePath, matchKind: SectionMatch.FilePatternMatch));
FindAllDeclarationsTests.cs (1)
666Assert.False(foundDeclarations.Any(decl => decl == null));
Formatter\FormatterTests.cs (26)
148Assert.False(formattingOptions.Spacing.HasFlag(SpacePlacement.AfterControlFlowStatementKeyword)); 149Assert.False(formattingOptions.Spacing.HasFlag(SpacePlacement.AfterSemicolonsInForStatement)); 150Assert.False(formattingOptions.Spacing.HasFlag(SpacePlacement.AfterColonInBaseTypeDeclaration)); 151Assert.False(formattingOptions.Spacing.HasFlag(SpacePlacement.BeforeColonInBaseTypeDeclaration)); 152Assert.False(formattingOptions.Spacing.HasFlag(SpacePlacement.AfterComma)); 174Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeMembersInObjectInitializers)); 175Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeMembersInAnonymousTypes)); 176Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeElse)); 177Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeCatch)); 178Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeFinally)); 179Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeOpenBraceInTypes)); 180Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeOpenBraceInAnonymousTypes)); 181Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers)); 182Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeOpenBraceInProperties)); 183Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeOpenBraceInMethods)); 184Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeOpenBraceInAccessors)); 185Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeOpenBraceInAnonymousMethods)); 186Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeOpenBraceInLambdaExpressionBody)); 187Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BeforeOpenBraceInControlBlocks)); 188Assert.False(formattingOptions.NewLines.HasFlag(NewLinePlacement.BetweenQueryExpressionClauses)); 193Assert.False(formattingOptions.Indentation.HasFlag(IndentationPlacement.BlockContents)); 194Assert.False(formattingOptions.Indentation.HasFlag(IndentationPlacement.SwitchCaseContents)); 195Assert.False(formattingOptions.Indentation.HasFlag(IndentationPlacement.SwitchCaseContentsWhenBlock)); 196Assert.False(formattingOptions.Indentation.HasFlag(IndentationPlacement.SwitchSection)); 198Assert.False(formattingOptions.WrappingPreserveSingleLine); 199Assert.False(formattingOptions.WrappingKeepStatementsOnSingleLine);
ObjectSerializationTests.cs (2)
432Assert.False(reader.ReadBoolean()); 499Assert.False((bool)reader.ReadScalarValue());
Options\CodeStyleOptionTests.cs (1)
96Assert.False(deserialized.Value);
Options\OptionKeyTests.cs (9)
146Assert.False(option1.Equals(option2)); 147Assert.False(option2.Equals(option1)); 148Assert.False(FormattingOptions.UseTabs.Equals(option3)); 149Assert.False(option3.Equals(FormattingOptions.UseTabs)); 159Assert.False(option1.Equals(option2)); 160Assert.False(option2.Equals(option1)); 161Assert.False(CSharpFormattingOptions.SpacingAfterMethodDeclarationName.Equals(option3)); 162Assert.False(option3.Equals(CSharpFormattingOptions.SpacingAfterMethodDeclarationName)); 183Assert.False(FormattingOptions2.SmartIndent.Definition.IsEditorConfigOption);
SemanticModelReuse\SemanticModelReuseTests.cs (29)
43Assert.False(model.IsSpeculativeSemanticModel); 56Assert.False(model1.IsSpeculativeSemanticModel); 57Assert.False(model2.IsSpeculativeSemanticModel); 70Assert.False(model1.IsSpeculativeSemanticModel); 71Assert.False(model2.IsSpeculativeSemanticModel); 89Assert.False(model1.IsSpeculativeSemanticModel); 106Assert.False(model1.IsSpeculativeSemanticModel); 112Assert.False(model2.IsSpeculativeSemanticModel); 129Assert.False(model1.IsSpeculativeSemanticModel); 152Assert.False(model1.IsSpeculativeSemanticModel); 175Assert.False(model1.IsSpeculativeSemanticModel); 198Assert.False(model1.IsSpeculativeSemanticModel); 222Assert.False(model1.IsSpeculativeSemanticModel); 249Assert.False(model1.IsSpeculativeSemanticModel); 255Assert.False(model2.IsSpeculativeSemanticModel); 272Assert.False(model.IsSpeculativeSemanticModel); 291Assert.False(model1.IsSpeculativeSemanticModel); 292Assert.False(model2.IsSpeculativeSemanticModel); 311Assert.False(model1.IsSpeculativeSemanticModel); 312Assert.False(model2.IsSpeculativeSemanticModel); 336Assert.False(model1.IsSpeculativeSemanticModel); 365Assert.False(model1.IsSpeculativeSemanticModel); 378Assert.False(model2.IsSpeculativeSemanticModel); 407Assert.False(model1.IsSpeculativeSemanticModel); 450Assert.False(model1.IsSpeculativeSemanticModel); 497Assert.False(model1.IsSpeculativeSemanticModel); 543Assert.False(model1.IsSpeculativeSemanticModel); 576Assert.False(model1.IsSpeculativeSemanticModel); 589Assert.False(model2.IsSpeculativeSemanticModel);
Simplifier\SimplifierTests.cs (6)
129Assert.False(simplifierOptions.QualifyFieldAccess.Value); 130Assert.False(simplifierOptions.QualifyPropertyAccess.Value); 131Assert.False(simplifierOptions.QualifyMethodAccess.Value); 132Assert.False(simplifierOptions.QualifyEventAccess.Value); 133Assert.False(simplifierOptions.PreferPredefinedTypeKeywordInMemberAccess.Value); 134Assert.False(simplifierOptions.PreferPredefinedTypeKeywordInDeclaration.Value);
SolutionTests\ProjectIdTests.cs (4)
34Assert.False(id1.Equals(id2)); 35Assert.False(id1 == id2); 36Assert.False(id1.GetHashCode() == id2.GetHashCode()); 37Assert.False(id1.Checksum == id2.Checksum);
SolutionTests\SolutionTests.cs (36)
470Assert.False(root1.IsIncrementallyIdenticalTo(root2)); 558Assert.False(root1.IsIncrementallyIdenticalTo(root2)); 614Assert.False(root1.IsIncrementallyIdenticalTo(root2)); 641Assert.False(root1.IsIncrementallyIdenticalTo(root2)); 700Assert.False(root1.IsIncrementallyIdenticalTo(root2)); 724Assert.False(root1.IsIncrementallyIdenticalTo(root2)); 745Assert.False(root1.IsIncrementallyIdenticalTo(root2)); 800Assert.False(root1.IsIncrementallyIdenticalTo(root2)); 1489Assert.False(project.CompilationOutputInfo.HasEffectiveGeneratedFilesOutputDirectory); 1799Assert.False(oldTree.GetRoot().IsIncrementallyIdenticalTo(newTree.GetRoot())); 1869Assert.False(oldTree.GetRoot().IsIncrementallyIdenticalTo(newTree.GetRoot())); 1888Assert.False(oldTree.GetRoot().IsIncrementallyIdenticalTo(newTree.GetRoot())); 2328Assert.False(projectOptions!.Value.ConfigOptionsWithoutFallback.TryGetValue("optionB", out var value2)); 2339Assert.False(sourcePathOptions.ConfigOptionsWithoutFallback.TryGetValue("optionB", out var value4)); 2404Assert.False(document.State.Attributes.IsGenerated); 2484Assert.False(document2.State.Attributes.IsGenerated); 2523Assert.False(document2.State.Attributes.IsGenerated); 2562Assert.False(project.HasDocuments); 3093Assert.False(project.HasDocuments); 3096Assert.False(sol2.ProjectIds.Any()); 3119Assert.False(sol2.ContainsProject(pid)); 3144Assert.False(sol2.ContainsProject(pid)); 3172Assert.False(document.TryGetSyntaxRoot(out _)); 3228Assert.False(tree2.TryGetText(out _)); 4049Assert.False(await project.HasSuccessfullyLoadedAsync(CancellationToken.None)); 4110Assert.False(await project2.HasSuccessfullyLoadedAsync(CancellationToken.None)); 4480Assert.False(doc1Root.IsEquivalentTo(doc2Root)); 4494Assert.False(frozenDoc1Root.DescendantNodes().Any(n => n.RawKind == StructDeclaration)); 4508Assert.False(frozenDoc1Root.DescendantNodes().Any(n => n.RawKind == ClassDeclaration)); 4519Assert.False(await csBrokenProject.HasSuccessfullyLoadedAsync(CancellationToken.None)); 4766Assert.False(provider.TryGetDiagnosticValue(syntaxTreeAfterAddingEditorConfig, "CA1234", CancellationToken.None, out _)); 4831Assert.False(originalProvider.TryGetGlobalDiagnosticValue("CA1234", default, out _)); 4847Assert.False(finalProvider.TryGetGlobalDiagnosticValue("CA1234", default, out _)); 4914Assert.False(document.TryGetSyntaxTree(out _)); 4918Assert.False(document.TryGetSemanticModel(out _)); 5248Assert.False(compilation1.References.Any(r => r is CompilationReference));
SolutionTests\SolutionWithSourceGeneratorTests.cs (7)
579Assert.False(project.TryGetCompilation(out _)); 705Assert.False(workspace.IsDocumentOpen(generatedDocument.Identity.DocumentId)); 726Assert.False(generatorRan); 739Assert.False(generatorRan); 766Assert.False(generatorRan); 829Assert.False(generatorRan); 858Assert.False(noTreesPassed!.Value);
SymbolKeyTests.cs (5)
191Assert.False(symbols.Any(s => s is IFieldSymbol { MetadataName: "" })); 219Assert.False(symbols.Any(s => s is IFieldSymbol { MetadataName: "" })); 247Assert.False(symbols.Any(s => s is IFieldSymbol { MetadataName: "" })); 859Assert.False(firstReusedModel.IsSpeculativeSemanticModel); 906Assert.False(firstReusedModel.IsSpeculativeSemanticModel);
SyntaxPathTests.cs (6)
34Assert.False(path.TryResolve(SyntaxFactory.ParseExpression("Goo()"), out SyntaxNode _)); 54Assert.False(path.TryResolve(root2, out SyntaxNode _)); 64Assert.False(path.TryResolve(root2, out SyntaxNode _)); 267Assert.False(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode _)); 299Assert.False(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode _)); 300Assert.False(path3.TryResolve(tree, CancellationToken.None, out SyntaxNode _));
UtilityTest\CancellationSeriesTests.cs (6)
27Assert.False(token.IsCancellationRequested); 37Assert.False(token1.IsCancellationRequested); 42Assert.False(token2.IsCancellationRequested); 47Assert.False(token3.IsCancellationRequested); 94Assert.False(token.IsCancellationRequested); 109Assert.False(token.IsCancellationRequested);
UtilityTest\DictionaryExtensionsTests.cs (2)
35Assert.False(dictionary.ContainsKey(2)); 36Assert.False(dictionary.ContainsKey(3));
UtilityTest\FormattingRangeHelperTests.cs (1)
31Assert.False(FormattingRangeHelper.AreTwoTokensOnSameLine(token1, token2));
UtilityTest\ImmutableDictionaryExtensionsTests.cs (6)
19Assert.False(empty.KeysEqual(empty.Add(1, 1))); 20Assert.False(empty.Add(1, 1).KeysEqual(empty)); 26Assert.False(empty.Add(2, 0).Add(3, 0).KeysEqual(empty.Add(1, 1).Add(2, 1))); 36Assert.False(emptyIgnoreCase.Add("A", 1).KeysEqual(emptyOrdinal.Add("a", 1))); 37Assert.False(emptyOrdinal.Add("A", 1).KeysEqual(emptyIgnoreCase.Add("a", 1))); 38Assert.False(emptyOrdinal.Add("A", 1).KeysEqual(emptyOrdinal.Add("a", 1)));
UtilityTest\IntervalTreeTests.cs (2)
217Assert.False(HasIntervalThatIntersectsWith(tree, -1)); 221Assert.False(HasIntervalThatIntersectsWith(tree, 3));
UtilityTest\NameGeneratorTests.cs (3)
21Assert.False(a.EndsWith("..txt", StringComparison.Ordinal)); 26Assert.False(b.EndsWith("..txt", StringComparison.Ordinal)); 31Assert.False(c.EndsWith("..txt", StringComparison.Ordinal));
UtilityTest\ReferenceHolderTests.cs (2)
101Assert.False(x.Equals(y)); 102Assert.False(y.Equals(x));
UtilityTest\SpecializedTasksTests.cs (24)
57Assert.False(whenAll.IsCompletedSuccessfully); 66Assert.False(whenAll.IsCompleted); 121Assert.False(executedTransform); 139Assert.False(task.IsCompleted); 169Assert.False(task.IsCompleted); 174Assert.False(executedTransform); 198Assert.False(executedTransform); 226Assert.False(task.IsCompleted); 231Assert.False(executedTransform); 258Assert.False(executedTransform); 286Assert.False(task.IsCompleted); 295Assert.False(executedTransform); 322Assert.False(executedTransform); 353Assert.False(task.IsCompleted); 359Assert.False(executedTransform); 381Assert.False(executedTransform); 403Assert.False(executedTransform); 428Assert.False(task.IsCompleted); 433Assert.False(executedTransform); 458Assert.False(executedTransform); 483Assert.False(executedTransform); 511Assert.False(task.IsCompleted); 517Assert.False(executedTransform); 551Assert.False(task.IsCompleted);
UtilityTest\SpellCheckerTests.cs (12)
15Assert.False(WordSimilarityChecker.AreSimilar("variabledeclaratorsyntax", "variabledeclaratorsyntaxextensions")); 18Assert.False(WordSimilarityChecker.AreSimilar("expressionsyntax", "expressionsyntaxextensions")); 21Assert.False(WordSimilarityChecker.AreSimilar("expressionsyntax", "expressionsyntaxgeneratorvisitor")); 28Assert.False(WordSimilarityChecker.AreSimilar("propertyblocksyntax", "ipropertysymbol")); 29Assert.False(WordSimilarityChecker.AreSimilar("propertyblocksyntax", "ipropertysymbolextensions")); 30Assert.False(WordSimilarityChecker.AreSimilar("propertyblocksyntax", "typeblocksyntaxextensions")); 32Assert.False(WordSimilarityChecker.AreSimilar("fielddeclarationsyntax", "declarationinfo")); 33Assert.False(WordSimilarityChecker.AreSimilar("fielddeclarationsyntax", "declarationcomputer")); 34Assert.False(WordSimilarityChecker.AreSimilar("fielddeclarationsyntax", "filelinepositionspan")); 36Assert.False(WordSimilarityChecker.AreSimilar("variabledeclaratorsyntax", "visualbasicdeclarationcomputer")); 37Assert.False(WordSimilarityChecker.AreSimilar("variabledeclaratorsyntax", "ilineseparatorservice")); 39Assert.False(WordSimilarityChecker.AreSimilar("expressionsyntax", "awaitexpressioninfo"));
WorkspaceServiceTests\GlobalOptionServiceTests.cs (4)
150Assert.False(optionSet.GetOption(optionvalid, "CS")); 160Assert.False(optionSet.GetOption(option)); 214Assert.False(optionSet.GetOption(option)); 226Assert.False(optionSet.GetOption(optionFalse));
WorkspaceServiceTests\ReferenceCountedDisposableTests.cs (6)
31Assert.False(target.IsDisposed); 71Assert.False(target.IsDisposed); 84Assert.False(target.IsDisposed); 87Assert.False(target.IsDisposed); 110Assert.False(target.IsDisposed); 117Assert.False(target.IsDisposed);
WorkspaceTests\AdhocWorkspaceTests.cs (10)
227Assert.False(doc.TryGetText(out var currentText)); 240Assert.False(doc.TryGetText(out currentText)); 261Assert.False(doc.TryGetText(out var currentText)); 274Assert.False(doc.TryGetText(out currentText)); 300Assert.False(doc.TryGetText(out var currentText)); 313Assert.False(doc.TryGetText(out currentText)); 334Assert.False(doc.TryGetText(out var currentText)); 335Assert.False(doc.TryGetTextVersion(out var currentVersion)); 351Assert.False(newDoc.TryGetText(out currentText)); 363Assert.False(newDoc.TryGetText(out currentText));
XxHash128Tests.cs (1)
53Assert.False(XxHash128.TryHash(input, destination.AsSpan(0, destination.Length - 1), out int bytesWritten, test.Seed));
Microsoft.Data.Analysis.Tests (31)
DataFrameTests.BinaryOperations.cs (18)
130Assert.False(verify.Any()); 139Assert.False(verify.Any()); 142Assert.False(verify.Any()); 268Assert.False(newCol.All()); 270Assert.False(newCol.All()); 294Assert.False(newCol.All()); 297Assert.False(newCol.All()); 338Assert.False(newCol.All()); 453Assert.False(res.ElementwiseNotEquals(ints).All()); 454Assert.False(res.ElementwiseGreaterThan(ints).All()); 455Assert.False(res.ElementwiseLessThan(ints).All()); 462Assert.False(inPlace.ElementwiseNotEquals(ints).All()); 463Assert.False(inPlace.ElementwiseGreaterThan(ints).All()); 464Assert.False(inPlace.ElementwiseLessThan(ints).All()); 466Assert.False(inPlace.ElementwiseEquals(res).All()); 468Assert.False(inPlace.ElementwiseLessThanOrEqual(res).All()); 471Assert.False(inPlace.ElementwiseLessThan(res).All()); 489Assert.False(reverseInPlace.ElementwiseEquals(reverse).All());
DataFrameTests.Computations.cs (1)
61Assert.False(all);
PrimitiveDataFrameColumnTests.cs (5)
99Assert.False(dataFrameColumn1.IsValid(10)); 119Assert.False(intColumn.IsValid(i)); 167Assert.False(intColumn.IsValid(i)); 192Assert.False(intColumn.IsValid(i)); 257Assert.False(intColumn.IsValid(7));
test\Microsoft.ML.TestFramework\GlobalBase.cs (2)
89Assert.False(_ignoreOne); 94Assert.False(_ignoreOne);
TextFieldParserTests.cs (5)
117Assert.False(parser.HasFieldsEnclosedInQuotes); 125Assert.False(parser.TrimWhiteSpace); 137Assert.False(parser.EndOfData); 151Assert.False(parser.EndOfData); 162Assert.False(parser.EndOfData);
Microsoft.DotNet.Arcade.Sdk.Tests (5)
ValidateLicenseTests.cs (5)
13Assert.False(ValidateLicense.LinesEqual(new[] { "a" }, new[] { "b" })); 14Assert.False(ValidateLicense.LinesEqual(new[] { "a" }, new[] { "A" })); 15Assert.False(ValidateLicense.LinesEqual(new[] { "a" }, new[] { "a", "b" })); 16Assert.False(ValidateLicense.LinesEqual(new[] { "a" }, new[] { "a", "*ignore-line*" })); 17Assert.False(ValidateLicense.LinesEqual(new[] { "*ignore-line*" }, new[] { "a" }));
Microsoft.DotNet.Build.Tasks.Feed.Tests (1)
PublishToSymbolServerTest.cs (1)
35Assert.False(Directory.Exists(path));
Microsoft.DotNet.Build.Tasks.Workloads.Tests (1)
CreateVisualStudioWorkloadSetTests.cs (1)
60Assert.False(MsiUtils.HasTable(msi.ItemSpec, "Upgrade"));
Microsoft.DotNet.Open.Api.Tools.Tests (3)
OpenApiAddURLTests.cs (1)
446Assert.False(File.Exists(jsonFile));
OpenApiRemoveTests.cs (2)
56Assert.False(File.Exists(Path.Combine(_tempDir.Root, nswagJsonFile))); 186Assert.False(File.Exists(Path.Combine(_tempDir.Root, nswagJsonFile)));
Microsoft.DotNet.XUnitAssert.Tests (5)
BooleanAssertsTests.cs (2)
12 Assert.False(false); 18 var ex = Record.Exception(() => Assert.False(true));
MultipleAssertsTests.cs (3)
37 () => Assert.False(false) 47 () => Assert.False(true) 60 () => Assert.False(true)
Microsoft.DotNet.XUnitExtensions.Tests (1)
ConditionalAttributeTests.cs (1)
100Assert.False(s_conditionalFactFalseExecuted);
Microsoft.Extensions.AI.Abstractions.Tests (57)
AdditionalPropertiesDictionaryTests.cs (4)
81Assert.False(d.TryGetValue("key2", out value)); 89Assert.False(d.TryGetValue("key", out T2? value)); 99Assert.False(d.ContainsKey("key")); 104Assert.False(d.TryAdd("key", "value2"));
ChatCompletion\ChatFinishReasonTests.cs (6)
32Assert.False(new ChatFinishReason("abc") != new ChatFinishReason("ABC")); 34Assert.False(new ChatFinishReason("abc").Equals(new ChatFinishReason("def"))); 35Assert.False(new ChatFinishReason("abc").Equals((object)new ChatFinishReason("def"))); 36Assert.False(new ChatFinishReason("abc").Equals(null)); 37Assert.False(new ChatFinishReason("abc").Equals("abc")); 38Assert.False(new ChatFinishReason("abc") == new ChatFinishReason("def"));
ChatCompletion\ChatRoleTests.cs (6)
31Assert.False(new ChatRole("abc") != new ChatRole("ABC")); 33Assert.False(new ChatRole("abc").Equals(new ChatRole("def"))); 34Assert.False(new ChatRole("abc").Equals((object)new ChatRole("def"))); 35Assert.False(new ChatRole("abc").Equals(null)); 36Assert.False(new ChatRole("abc").Equals("abc")); 37Assert.False(new ChatRole("abc") == new ChatRole("def"));
ChatCompletion\ChatToolModeTests.cs (10)
24Assert.False(ChatToolMode.Auto.Equals(ChatToolMode.RequireAny)); 25Assert.False(ChatToolMode.Auto.Equals(new RequiredChatToolMode(null))); 26Assert.False(ChatToolMode.Auto.Equals(new RequiredChatToolMode("func"))); 31Assert.False(ChatToolMode.None.Equals(ChatToolMode.RequireAny)); 32Assert.False(ChatToolMode.None.Equals(new RequiredChatToolMode(null))); 33Assert.False(ChatToolMode.None.Equals(new RequiredChatToolMode("func"))); 38Assert.False(ChatToolMode.RequireAny.Equals(ChatToolMode.Auto)); 39Assert.False(ChatToolMode.RequireAny.Equals(new RequiredChatToolMode("func"))); 48Assert.False(new RequiredChatToolMode("func1").Equals(new RequiredChatToolMode("func2"))); 51Assert.False(new RequiredChatToolMode("func1").Equals(new RequiredChatToolMode("FUNC1")));
ChatCompletion\DelegatingChatClientTests.cs (2)
46Assert.False(resultTask.IsCompleted); 87Assert.False(await enumerator.MoveNextAsync());
Contents\DataContentTests.cs (1)
243Assert.False(content.HasTopLevelMediaType(prefix));
Contents\UriContentTests.cs (1)
128Assert.False(content.HasTopLevelMediaType(prefix));
Embeddings\DelegatingEmbeddingGeneratorTests.cs (1)
45Assert.False(resultTask.IsCompleted);
Embeddings\GeneratedEmbeddingsTests.cs (5)
39Assert.False(((ICollection<Embedding<float>>)instance).IsReadOnly); 42Assert.False(instance.Contains(new Embedding<float>(new float[] { 1, 2, 3 }))); 43Assert.False(instance.Contains(null!)); 78Assert.False(generatedEmbeddings.Contains(null!)); 170Assert.False(embeddings.Remove(e1));
Functions\AIFunctionArgumentsTests.cs (9)
81Assert.False(args.ContainsKey("KEY1")); 94Assert.False(args.TryGetValue("key3", out value)); 116Assert.False(args.IsReadOnly); 120Assert.False(args.ContainsKey("KEY1")); 130Assert.False(args.TryGetValue("key3", out value)); 150Assert.False(args.ContainsKey("key1")); 226Assert.False(args.ContainsKey("key3")); 304Assert.False(args.ContainsKey("key3")); 307Assert.False(originalDict.ContainsKey("key4"));
Functions\DelegatingAIFunctionTests.cs (1)
84Assert.False(innerInvoked);
Image\DelegatingImageGeneratorTests.cs (2)
45Assert.False(resultTask.IsCompleted); 118Assert.False(inner.DisposeInvoked);
Image\ImageGeneratorTests.cs (1)
81Assert.False(generator.DisposeInvoked);
SpeechToText\DelegatingSpeechToTextClientTests.cs (2)
47Assert.False(resultTask.IsCompleted); 88Assert.False(await enumerator.MoveNextAsync());
SpeechToText\SpeechToTextResponseUpdateKindTests.cs (4)
33Assert.False(kind1 != kind2); 36Assert.False(kind1.Equals(kind3)); 37Assert.False(kind1.Equals((object)kind3)); 38Assert.False(kind1 == kind3);
Utilities\AIJsonUtilitiesTests.cs (2)
79Assert.False(options.IncludeSchemaKeyword); 471Assert.False(options.IsReadOnly);
Microsoft.Extensions.AI.Evaluation.Integration.Tests (19)
ResultsTests.cs (19)
179Assert.False(result.ContainsDiagnostics()); 203Assert.False(metricA.Interpretation!.Failed); 208Assert.False(metricD.Interpretation!.Failed); 210Assert.False(result.ContainsDiagnostics()); 266Assert.False(result.ContainsDiagnostics()); 318Assert.False(metricD.Interpretation!.Failed); 320Assert.False(metricE.Interpretation!.Failed); 334Assert.False(result.ContainsDiagnostics()); 370Assert.False(result.ContainsDiagnostics()); 398Assert.False(metricA.Interpretation!.Failed); 406Assert.False(metricE.Interpretation!.Failed); 408Assert.False(metricF.Interpretation!.Failed); 410Assert.False(metricG.Interpretation!.Failed); 413Assert.False(result.ContainsDiagnostics()); 574Assert.False(metric1.Interpretation!.Failed); 576Assert.False(metric2.Interpretation!.Failed); 578Assert.False(metric3.Interpretation!.Failed); 580Assert.False(metric4.Interpretation!.Failed); 582Assert.False(metric5.Interpretation!.Failed);
Microsoft.Extensions.AI.Evaluation.NLP.Tests (5)
BLEUEvaluatorTests.cs (1)
28Assert.False(metric.Interpretation.Failed);
F1EvaluatorTests.cs (1)
28Assert.False(metric.Interpretation.Failed);
GLEUEvaluatorTests.cs (1)
28Assert.False(metric.Interpretation.Failed);
NGramTests.cs (1)
35Assert.False(a.Equals(c));
RationalNumberTests.cs (1)
51Assert.False(a.Equals(c));
Microsoft.Extensions.AI.Evaluation.Tests (12)
IntentResolutionRatingTests.cs (6)
38Assert.False(rating.IsInconclusive); 70Assert.False(rating.IsInconclusive); 102Assert.False(rating.IsInconclusive); 128Assert.False(rating.IsInconclusive); 238Assert.False(rating.IsInconclusive); 267Assert.False(rating.IsInconclusive);
RelevanceTruthAndCompletenessRatingTests.cs (6)
49Assert.False(rating.IsInconclusive); 85Assert.False(rating.IsInconclusive); 124Assert.False(rating.IsInconclusive); 154Assert.False(rating.IsInconclusive); 282Assert.False(rating.IsInconclusive); 321Assert.False(rating.IsInconclusive);
Microsoft.Extensions.AI.Integration.Tests (4)
ChatClientIntegrationTests.cs (1)
1036Assert.False(response.Result);
ImageGeneratorIntegrationTests.cs (3)
51Assert.False(dataContent.Data.IsEmpty); 75Assert.False(dataContent.Data.IsEmpty); 102Assert.False(dataContent.Data.IsEmpty);
Microsoft.Extensions.AI.OllamaSharp.Integration.Tests (1)
OllamaSharpChatClientIntegrationTests.cs (1)
86Assert.False(didCallIrrelevantTool);
Microsoft.Extensions.AI.OpenAI.Tests (1)
OpenAIConversionTests.cs (1)
1066Assert.False(openAIResponse.ParallelToolCallsEnabled);
Microsoft.Extensions.AI.Tests (23)
ChatCompletion\ConfigureOptionsChatClientTests.cs (1)
87Assert.False(await e.MoveNextAsync());
ChatCompletion\DependencyInjectionPatterns.cs (2)
127Assert.False(sd.IsKeyedService); 173Assert.False(sd.IsKeyedService);
ChatCompletion\DistributedCachingChatClientTest.cs (8)
29Assert.False(cachingClient.CoalesceStreamingUpdates); 154Assert.False(result1.IsCompleted); 155Assert.False(result2.IsCompleted); 225Assert.False(result1.IsCompleted); 459Assert.False(result1Assertion.IsCompleted); 460Assert.False(result2Assertion.IsCompleted); 535Assert.False(result1Assertion.IsCompleted); 874Assert.False(await actualEnumerator.MoveNextAsync());
ChatCompletion\FunctionInvocationContextTests.cs (1)
23Assert.False(ctx.Terminate);
ChatCompletion\FunctionInvokingChatClientTests.cs (4)
37Assert.False(client.AllowConcurrentInvocation); 38Assert.False(client.IncludeDetailedErrors); 51Assert.False(client.AllowConcurrentInvocation); 55Assert.False(client.IncludeDetailedErrors);
Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (3)
160Assert.False(result1.IsCompleted); 161Assert.False(result2.IsCompleted); 229Assert.False(result1.IsCompleted);
Functions\AIFunctionFactoryTest.cs (1)
278Assert.False(options.ExcludeResultSchema);
Image\ImageGeneratorDependencyInjectionPatterns.cs (1)
127Assert.False(sd.IsKeyedService);
SpeechToText\ConfigureOptionsSpeechToTextClientTests.cs (1)
90Assert.False(await e.MoveNextAsync());
SpeechToText\SpeechToTextClientDependencyInjectionPatterns.cs (1)
127Assert.False(sd.IsKeyedService);
Microsoft.Extensions.ApiDescription.Client.Tests (11)
CSharpIdentifierTest.cs (1)
42Assert.False(result);
GetCurrentOpenApiReferenceTest.cs (1)
42Assert.False(task.Log.HasLoggedErrors);
GetOpenApiReferenceMetadataTest.cs (9)
56Assert.False(task.Log.HasLoggedErrors); 116Assert.False(task.Log.HasLoggedErrors); 176Assert.False(task.Log.HasLoggedErrors); 236Assert.False(task.Log.HasLoggedErrors); 291Assert.False(result); 337Assert.False(result); 389Assert.False(task.Log.HasLoggedErrors); 453Assert.False(task.Log.HasLoggedErrors); 551Assert.False(task.Log.HasLoggedErrors);
Microsoft.Extensions.ApiDescription.Tool.Tests (10)
GetDocumentTests.cs (10)
154Assert.False(File.Exists(Path.Combine(outputPath.FullName, "Sample.json"))); 155Assert.False(File.Exists(Path.Combine(outputPath.FullName, "Sample_internal.json"))); 156Assert.False(File.Exists(Path.Combine(outputPath.FullName, "Sample_invalid.json"))); 184Assert.False(File.Exists(Path.Combine(outputPath.FullName, "Sample.json"))); 185Assert.False(File.Exists(Path.Combine(outputPath.FullName, "Sample_internal.json"))); 211Assert.False(File.Exists(Path.Combine(outputPath.FullName, $"{fileName}.json"))); 212Assert.False(File.Exists(Path.Combine(outputPath.FullName, "Sample.json"))); 213Assert.False(File.Exists(Path.Combine(outputPath.FullName, "Sample_internal.json"))); 235Assert.False(File.Exists(Path.Combine(outputPath.FullName, ".json"))); 236Assert.False(File.Exists(Path.Combine(outputPath.FullName, "_internal.json")));
Microsoft.Extensions.AsyncState.Tests (7)
AsyncContextTests.cs (2)
92Assert.False(context1.TryGet(out _)); 155Assert.False(context1.TryGet(out var context));
AsyncStateTokenTests.cs (5)
18Assert.False(t1.Equals(string.Empty)); 20Assert.False(t1 != t2); 29Assert.False(t1.Equals(t2)); 31Assert.False(t1.Equals((object)t2)); 32Assert.False(t1 == t2);
Microsoft.Extensions.Caching.Hybrid.Tests (9)
BufferReleaseTests.cs (3)
77Assert.False(cacheItem.TryReserveBuffer(out _)); 236Assert.False(cacheItem.TryReserveBuffer(out _)); // released now 289Assert.False(obj.TryGetValue(NullLogger.Instance, out _));
DistributedCacheTests.cs (3)
201Assert.False(cache.TryGet(key, writer)); 327Assert.False(payload.IsSingleSegment); 331Assert.False(MemoryMarshal.TryGetArray(payload.First, out _));
RedisTests.cs (1)
70Assert.False(await redis.GetDatabase().KeyExistsAsync(key));
TagSetTests.cs (1)
15Assert.False(tags.IsArray);
TypeTests.cs (1)
38Assert.False((bool)typeof(ImmutableTypeCache<>).MakeGenericType(type)
Microsoft.Extensions.Compliance.Abstractions.Tests (6)
Classification\DataClassificationSetTests.cs (1)
30Assert.False(dc1.Equals(null));
Classification\DataClassificationTests.cs (5)
21Assert.False(dc != new DataClassification(TaxonomyName, Value)); 24Assert.False(dc == new DataClassification(TaxonomyName + "x", Value)); 27Assert.False(dc == new DataClassification(TaxonomyName, Value + 1)); 30Assert.False(dc.Equals(new object())); 36Assert.False(dc.Equals(null));
Microsoft.Extensions.Compliance.Testing.Tests (5)
RedactionFakesEventCollectorTests.cs (5)
41Assert.False(first.Equals(third)); 42Assert.False(first.Equals(@object)); 47Assert.False(first == fourth); 62Assert.False(first.Equals(third)); 63Assert.False(first.Equals(@object));
Microsoft.Extensions.Diagnostics.HealthChecks.Tests (23)
DefaultHealthCheckServiceTest.cs (2)
458Assert.False(healthCheck.SyncOrAsyncDisposable.IsDisposed); 589Assert.False(hangs);
HealthCheckPublisherHostedServiceTest.cs (21)
56Assert.False(service.IsTimerRunning); 57Assert.False(service.IsStopping); 62Assert.False(service.IsTimerRunning); 85Assert.False(service.IsStopping); 90Assert.False(service.IsTimerRunning); 130Assert.False(service.IsStopping); 135Assert.False(service.IsTimerRunning); 166Assert.False(service.IsTimerRunning); 176Assert.False(service.IsTimerRunning); 208Assert.False(service.IsStopping); 216Assert.False(service.IsTimerRunning); 363Assert.False(running.IsCompleted); 376Assert.False(service.IsStopping); 381Assert.False(service.IsTimerRunning); 430Assert.False(service.IsStopping); 441Assert.False(service.IsTimerRunning); 476Assert.False(service.IsStopping); 481Assert.False(service.IsTimerRunning); 650Assert.False(service.IsTimerRunning); 687Assert.False(service.IsTimerRunning); 731Assert.False(service.IsTimerRunning);
Microsoft.Extensions.Diagnostics.Probes.Tests (10)
KubernetesProbesExtensionsTests.cs (6)
50Assert.False(livenessConfig.FilterChecks(startupRegistration)); 51Assert.False(livenessConfig.FilterChecks(readinessRegistration)); 55Assert.False(startupConfig.FilterChecks!(livenessRegistration)); 57Assert.False(startupConfig.FilterChecks(readinessRegistration)); 61Assert.False(readinessConfig.FilterChecks!(livenessRegistration)); 62Assert.False(readinessConfig.FilterChecks(startupRegistration));
TcpEndpointProbesServiceTests.cs (4)
40Assert.False(IsTcpOpened(port)); 54Assert.False(IsTcpOpened(port)); 58Assert.False(IsTcpOpened(port)); 94Assert.False(IsTcpOpened(port));
Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (5)
ByteArrayEqualityComparerTests.cs (4)
22Assert.False(_comparer.Equals(x, null)); 23Assert.False(_comparer.Equals(null, x)); 31Assert.False(_comparer.Equals(x, y)); 39Assert.False(_comparer.Equals(x, y));
ResourceMonitoringOptionsTests.cs (1)
22Assert.False(options.UseLinuxCalculationV2);
Microsoft.Extensions.Diagnostics.Testing.Tests (9)
Logging\FakeLoggerTests.cs (3)
161Assert.False(logger.IsEnabled(LogLevel.Debug)); 166Assert.False(logger.IsEnabled((LogLevel)42)); 170Assert.False(logger.LatestRecord.LevelEnabled);
Metrics\MetricCollectorTests.cs (6)
252Assert.False(wait.IsCompleted); 255Assert.False(wait.IsCompleted); 260Assert.False(wait.IsFaulted); 267Assert.False(wait.IsFaulted); 313Assert.False(wait.IsCompleted); 317Assert.False(wait.IsCompleted);
Microsoft.Extensions.FileProviders.Embedded.Tests (23)
EmbeddedFileProviderTests.cs (14)
33Assert.False(fileInfo.Exists); 53Assert.False(fileInfo.IsDirectory); 69Assert.False(fileInfo.Exists); 83Assert.False(fileInfo.Exists); 119Assert.False(fileInfo.IsDirectory); 157Assert.False(fileInfo.IsDirectory); 195Assert.False(fileInfo.IsDirectory); 216Assert.False(provider.GetDirectoryContents("file").Exists); 217Assert.False(provider.GetDirectoryContents("file/").Exists); 218Assert.False(provider.GetDirectoryContents("file.txt").Exists); 219Assert.False(provider.GetDirectoryContents("file/txt").Exists); 250Assert.False(files.Exists); 265Assert.False(token.ActiveChangeCallbacks); 266Assert.False(token.HasChanged);
ManifestEmbeddedFileProviderTests.cs (9)
30Assert.False(jqueryValidate.IsDirectory); 37Assert.False(jqueryMin.IsDirectory); 44Assert.False(siteCss.IsDirectory); 67Assert.False(jqueryValidate.IsDirectory); 74Assert.False(jqueryMin.IsDirectory); 81Assert.False(siteCss.IsDirectory); 166Assert.False(jqueryValidate.IsDirectory); 189Assert.False(jqueryValidate.IsDirectory); 440Assert.False(jqueryValidate.IsDirectory);
Microsoft.Extensions.Hosting.Testing.Tests (2)
FakeHostTests.cs (2)
90Assert.False(receivedToken.IsCancellationRequested); 150Assert.False(receivedToken.IsCancellationRequested);
Microsoft.Extensions.Http.Diagnostics.Tests (7)
Latency\HttpClientLatencyTelemetryExtensionsTest.cs (1)
85Assert.False(options.EnableDetailedLatencyBreakdown);
Latency\Internal\HttpLatencyTelemetryHandlerTest.cs (1)
98Assert.False(listener.Enabled);
Latency\Internal\HttpRequestLatencyListenerTest.cs (5)
53Assert.False(es.IsEnabled()); 58Assert.False(esSockets.IsEnabled()); 63Assert.False(esHttp.IsEnabled()); 68Assert.False(esNameRes.IsEnabled()); 86Assert.False(es.IsEnabled());
Microsoft.Extensions.Http.Polly.Tests (1)
PolicyHttpMessageHandlerTest.cs (1)
409Assert.False(hangs);
Microsoft.Extensions.Http.Resilience.Tests (7)
Hedging\HttpClientHedgingResiliencePredicatesTests.cs (3)
23Assert.False(HttpClientHedgingResiliencePredicates.IsTransientHttpException(new InvalidOperationException())); 32Assert.False(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new InvalidOperationException()))); 33Assert.False(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromResult<HttpResponseMessage>(null)));
Hedging\HttpStandardHedgingResilienceOptionsCustomValidatorTests.cs (1)
74Assert.False(validationResult.Failed);
Polly\HttpRetryStrategyOptionsExtensionsTests.cs (2)
64Assert.False(await options.ShouldHandle(CreatePredicateArguments(response))); 77Assert.False(await options.ShouldHandle(CreatePredicateArguments(null, context)));
Resilience\HttpStandardResilienceOptionsCustomValidatorTests.cs (1)
75Assert.False(validationResult.Failed);
Microsoft.Extensions.SecretManager.Tools.Tests (1)
InitCommandTest.cs (1)
43Assert.False(string.IsNullOrWhiteSpace(idResolver.Resolve(null, null)));
Microsoft.Extensions.Telemetry.Abstractions.Tests (13)
Latency\CheckpointTests.cs (5)
30Assert.False(c1.Equals(c3)); 31Assert.False(c1.Equals(c4)); 32Assert.False(c1.Equals(null)); 34Assert.False(c1 != c2); 35Assert.False(c1 == c3);
Latency\MeasureTests.cs (4)
31Assert.False(m1.Equals(m3)); 32Assert.False(m1.Equals(m4)); 33Assert.False(m1.Equals(null)); 35Assert.False(m1 != m2);
Logging\LogPropertiesAttributeTests.cs (3)
14Assert.False(lpa.SkipNullProperties); 24Assert.False(lpa.OmitReferenceName); 34Assert.False(lpa.Transitive);
Logging\TagProviderAttributeTests.cs (1)
17Assert.False(attr.OmitReferenceName);
Microsoft.Extensions.Telemetry.Tests (37)
Enrichment\ApplicationEnricherExtensionsTests.cs (5)
64Assert.False(options.ApplicationName); 65Assert.False(options.EnvironmentName); 66Assert.False(options.BuildVersion); 67Assert.False(options.DeploymentRing); 91Assert.False(options.EnvironmentName);
Enrichment\ApplicationLogEnricherTests.cs (4)
88Assert.False(enrichedState.ContainsKey(ApplicationEnricherTags.ApplicationName)); 97Assert.False(enrichedState.ContainsKey(ApplicationEnricherTags.EnvironmentName)); 106Assert.False(enrichedState.ContainsKey(ApplicationEnricherTags.BuildVersion)); 115Assert.False(enrichedState.ContainsKey(ApplicationEnricherTags.DeploymentRing));
Enrichment\ProcessEnricherExtensionsTests.cs (3)
65Assert.False(options.ProcessId); 66Assert.False(options.ThreadId); 89Assert.False(options.ThreadId);
Enrichment\ProcessLogEnricherTests.cs (3)
38Assert.False(options.ThreadId); 92Assert.False(enrichedState.ContainsKey(ProcessEnricherTagNames.ProcessId)); 93Assert.False(enrichedState.ContainsKey(ProcessEnricherTagNames.ThreadId));
Http\HttpParserTests.cs (2)
30Assert.False(success); 47Assert.False(success);
Latency\Internal\LatencyContextRegistrySetTests.cs (1)
79Assert.False(registry.IsRegistered(notRegsitered));
Latency\Internal\LatencyContextTests.cs (9)
27Assert.False(latencyContext.IsRunning); 35Assert.False(latencyContext.IsDisposed); 49Assert.False(latencyContext.IsRunning); 54Assert.False(latencyContext.IsRunning); 66Assert.False(latencyContext.IsDisposed); 94Assert.False(((LatencyContext)context).IsRunning); 176Assert.False(((LatencyContext)context).IsRunning); 230Assert.False(((LatencyContext)context).IsRunning); 255Assert.False(((LatencyContext)context).IsRunning);
Latency\LatencyConsoleOptionsTests.cs (3)
22Assert.False(o.OutputCheckpoints); 23Assert.False(o.OutputTags); 24Assert.False(o.OutputMeasures);
Latency\LatencyContextExtensionTests.cs (2)
113Assert.False(l.ThrowOnUnregisteredNames); 117Assert.False(o.ThrowOnUnregisteredNames);
Logging\JustInTimeRedactorTests.cs (1)
50Assert.False(r.TryFormat(d, out int _, string.Empty.AsSpan(), CultureInfo.InvariantCulture));
Logging\LoggerEnrichmentOptionsTests.cs (2)
18Assert.False(o.CaptureStackTraces); 19Assert.False(o.UseFileInfoForStackTraces);
Sampling\RandomProbabilisticSamplerTests.cs (1)
73Assert.False(actualDecision);
Sampling\TraceBasedSamplerTests.cs (1)
72Assert.False(shouldSample);
Microsoft.Extensions.TimeProvider.Testing.Tests (13)
FakeTimeProviderTests.cs (10)
308Assert.False(delay.IsFaulted); 309Assert.False(delay.IsCanceled); 319Assert.False(delay.IsCompleted); 340Assert.False(cancellationTokenSource.Token.IsCancellationRequested); 384Assert.False(t.IsFaulted); 385Assert.False(t.IsCanceled); 404Assert.False(t.IsFaulted); 405Assert.False(t.IsCanceled); 423Assert.False(t.IsCanceled); 576Assert.False(result.IsCompleted);
TimerTests.cs (3)
167Assert.False(t.Change(TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(1))); 178Assert.False(t.Change(TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(1))); 353Assert.False(triggers[j]);
Microsoft.Extensions.Validation.Tests (5)
RuntimeValidatableParameterInfoResolverTests.cs (3)
20Assert.False(result); 56Assert.False(result); 129Assert.False(result);
ValidatableInfoResolverTests.cs (2)
31Assert.False(result); 77Assert.False(result);
Microsoft.Gen.ContextualOptions.Generated.Tests (1)
ContextualOptionsTests.cs (1)
60Assert.False(typeof(NonPublicStruct).IsPublic);
Microsoft.Gen.ContextualOptions.Unit.Tests (5)
EmitterTests.cs (1)
124Assert.False(hasNamespace);
ParserTests.cs (3)
65Assert.False(result.Single().ShouldEmit); 80Assert.False(result.Single().ShouldEmit); 95Assert.False(result.Single().ShouldEmit);
SyntaxContextReceiverTests.cs (1)
54Assert.False(sut.TryGetTypeDeclarations(comp, out _));
Microsoft.Gen.Logging.Unit.Tests (3)
LogParserUtilitiesTests.cs (2)
74Assert.False(result); 122Assert.False(result);
ParserUtilitiesTests.cs (1)
75Assert.False(result);
Microsoft.Gen.MetadataExtractor.Unit.Tests (1)
GeneratorTests.cs (1)
134Assert.False(File.Exists(Path.Combine(Path.GetTempPath(), ReportFilename)));
Microsoft.Gen.MetricsReports.Unit.Tests (1)
GeneratorTests.cs (1)
94Assert.False(File.Exists(Path.Combine(Path.GetTempPath(), ReportFilename)));
Microsoft.JSInterop.Tests (20)
Infrastructure\DotNetDispatcherTest.cs (8)
142Assert.False(resultDto2Ref.TryGetProperty(nameof(TestDTO.StringVal), out _)); 143Assert.False(resultDto2Ref.TryGetProperty(nameof(TestDTO.IntVal), out _)); 334Assert.False(task.IsCompletedSuccessfully); 397Assert.False(task.IsCompletedSuccessfully); 727Assert.False(jsRuntime.LastCompletionResult.Success); // Fails 749Assert.False(jsRuntime.LastCompletionResult.Success); // Fails 769Assert.False(jsRuntime.LastCompletionResult.Success); // Fails 785Assert.False(jsRuntime.LastCompletionResult.Success); // Fails
JSRuntimeExtensionsTest.cs (2)
123Assert.False(cts.CanBeCanceled); 167Assert.False(cts.CanBeCanceled);
JSRuntimeTest.cs (10)
112Assert.False(unrelatedTask.IsCompleted); 113Assert.False(task.IsCompleted); 122Assert.False(unrelatedTask.IsCompleted); 187Assert.False(unrelatedTask.IsCompleted); 188Assert.False(task.IsCompleted); 198Assert.False(unrelatedTask.IsCompleted); 215Assert.False(unrelatedTask.IsCompleted); 216Assert.False(task.IsCompleted); 225Assert.False(unrelatedTask.IsCompleted); 312Assert.False(call.Success);
Microsoft.ML.AutoML.Tests (46)
ColumnInferenceTests.cs (2)
36Assert.False(col.Source.Length > 1 || col.Source[0].Min != col.Source[0].Max); 71Assert.False(result.TextLoaderOptions.HasHeader);
GetNextPipelineTests.cs (1)
89Assert.False(topStage1TrainerNames.Except(stage2TrainerNames).Any());
MetricsAgentsTests.cs (20)
37Assert.False(IsPerfectModel(metrics, BinaryClassificationMetric.Accuracy)); 38Assert.False(IsPerfectModel(metrics, BinaryClassificationMetric.AreaUnderRocCurve)); 39Assert.False(IsPerfectModel(metrics, BinaryClassificationMetric.AreaUnderPrecisionRecallCurve)); 40Assert.False(IsPerfectModel(metrics, BinaryClassificationMetric.F1Score)); 41Assert.False(IsPerfectModel(metrics, BinaryClassificationMetric.NegativePrecision)); 42Assert.False(IsPerfectModel(metrics, BinaryClassificationMetric.NegativeRecall)); 43Assert.False(IsPerfectModel(metrics, BinaryClassificationMetric.PositivePrecision)); 44Assert.False(IsPerfectModel(metrics, BinaryClassificationMetric.PositiveRecall)); 76Assert.False(IsPerfectModel(metrics, MulticlassClassificationMetric.MacroAccuracy)); 77Assert.False(IsPerfectModel(metrics, MulticlassClassificationMetric.MicroAccuracy)); 78Assert.False(IsPerfectModel(metrics, MulticlassClassificationMetric.LogLoss)); 79Assert.False(IsPerfectModel(metrics, MulticlassClassificationMetric.LogLossReduction)); 80Assert.False(IsPerfectModel(metrics, MulticlassClassificationMetric.TopKAccuracy)); 108Assert.False(IsPerfectModel(metrics, RegressionMetric.MeanAbsoluteError)); 109Assert.False(IsPerfectModel(metrics, RegressionMetric.MeanSquaredError)); 110Assert.False(IsPerfectModel(metrics, RegressionMetric.RootMeanSquaredError)); 111Assert.False(IsPerfectModel(metrics, RegressionMetric.RSquared)); 146Assert.False(IsPerfectModel(metrics, RankingMetric.Dcg, 3)); 147Assert.False(IsPerfectModel(metrics, RankingMetric.Ndcg, 3)); 156Assert.False(IsPerfectModel(metrics, RankingMetric.Dcg, 3)); //REVIEW: No true Perfect model
SweeperTests.cs (23)
184Assert.False(value1.Equals(value2)); 187Assert.False(value1.Equals((object)value2)); 191Assert.False(value1.Equals(new FloatParameterValue(nameof(value1), 1.0f))); 192Assert.False(value1.Equals((IParameterValue)null)); 193Assert.False(value1.Equals((object)null)); 194Assert.False(value1.Equals(new object())); 207Assert.False(value1.Equals(value2)); 210Assert.False(value1.Equals((object)value2)); 214Assert.False(value1.Equals(new LongParameterValue(nameof(value1), 1))); 215Assert.False(value1.Equals((IParameterValue)null)); 216Assert.False(value1.Equals((object)null)); 217Assert.False(value1.Equals(new object())); 230Assert.False(value1.Equals(value2)); 233Assert.False(value1.Equals((object)value2)); 237Assert.False(value1.Equals(new LongParameterValue(nameof(value1), 1))); 238Assert.False(value1.Equals((IParameterValue)null)); 239Assert.False(value1.Equals((object)null)); 240Assert.False(value1.Equals(new object())); 254Assert.False(parameterSet.Equals(null)); 259Assert.False(parameterSet.Equals(parameterSetNewHash)); 264Assert.False(parameterSet.Equals(parameterSetMoreValues)); 269Assert.False(parameterSet.Equals(parameterSetDifferentName)); 274Assert.False(parameterSet.Equals(parameterSetDifferentValue));
Microsoft.ML.Core.Tests (72)
UnitTests\TestEarlyStoppingCriteria.cs (21)
39Assert.False(shouldStop); 43Assert.False(shouldStop); 44Assert.False(isBestCandidate); 48Assert.False(isBestCandidate); 64Assert.False(shouldStop); 69Assert.False(shouldStop); 72Assert.False(isBestCandidate); 89Assert.False(shouldStop); 96Assert.False(shouldStop); 103Assert.False(isBestCandidate); 104Assert.False(shouldStop); 108Assert.False(isBestCandidate); 125Assert.False(shouldStop); 132Assert.False(shouldStop); 139Assert.False(isBestCandidate); 140Assert.False(shouldStop); 144Assert.False(isBestCandidate); 162Assert.False(shouldStop); 169Assert.False(isBestCandidate); 170Assert.False(shouldStop); 175Assert.False(isBestCandidate);
UnitTests\TestEntryPoints.cs (16)
391Assert.False(EntryPointUtils.IsValueWithinRange(range, 4.9)); 395Assert.False(EntryPointUtils.IsValueWithinRange(range, 5.0)); 396Assert.False(EntryPointUtils.IsValueWithinRange(range, 4.9)); 399Assert.False(EntryPointUtils.IsValueWithinRange(range, 5.1)); 404Assert.False(EntryPointUtils.IsValueWithinRange(range, 5.1)); 405Assert.False(EntryPointUtils.IsValueWithinRange(range, 5.0)); 409Assert.False(EntryPointUtils.IsValueWithinRange(range, -1.1)); 410Assert.False(EntryPointUtils.IsValueWithinRange(range, 1.1)); 5010Assert.False(b); 5240Assert.False(b); 5397Assert.False(b); 5601Assert.False(b); 5806Assert.False(b); 6116Assert.False(b); 6296Assert.False(b); 6468Assert.False(b);
UnitTests\TestLruCache.cs (1)
69Assert.False(success);
UnitTests\TestUtilities.cs (33)
41Assert.False(Utils.IsMonotonicallyIncreasing(x)); 68Assert.False(Utils.IsMonotonicallyIncreasing(x)); 75Assert.False(Utils.IsMonotonicallyIncreasing(x)); 102Assert.False(Utils.IsMonotonicallyIncreasing(x)); 109Assert.False(Utils.IsMonotonicallyIncreasing(x)); 125Assert.False(Utils.IsIncreasing(1, x, 10)); 127Assert.False(Utils.IsIncreasing(0, x, 9)); 139Assert.False(Utils.IsIncreasing(0, x, 10)); 146Assert.False(Utils.IsIncreasing(0, x, 10)); 171Assert.False(Utils.AreEqual(x, y)); 177Assert.False(Utils.AreEqual(x, y)); 183Assert.False(Utils.AreEqual(x, y)); 188Assert.False(Utils.AreEqual(xOfDifferentLength, y)); 191Assert.False(Utils.AreEqual(null, y)); 192Assert.False(Utils.AreEqual(x, null)); 207Assert.False(Utils.AreEqual(x, y)); 213Assert.False(Utils.AreEqual(x, y)); 219Assert.False(Utils.AreEqual(x, y)); 224Assert.False(Utils.AreEqual(xOfDifferentLength, y)); 227Assert.False(Utils.AreEqual(null, y)); 228Assert.False(Utils.AreEqual(x, null)); 243Assert.False(Utils.AreEqual(x, y)); 249Assert.False(Utils.AreEqual(x, y)); 255Assert.False(Utils.AreEqual(x, y)); 260Assert.False(Utils.AreEqual(xOfDifferentLength, y)); 263Assert.False(Utils.AreEqual(null, y)); 264Assert.False(Utils.AreEqual(x, null)); 279Assert.False(Utils.AreEqual(x, y)); 285Assert.False(Utils.AreEqual(x, y)); 291Assert.False(Utils.AreEqual(x, y)); 296Assert.False(Utils.AreEqual(xOfDifferentLength, y)); 299Assert.False(Utils.AreEqual(null, y)); 300Assert.False(Utils.AreEqual(x, null));
UnitTests\TestVBuffer.cs (1)
289Assert.False(a.IsDense);
Microsoft.ML.IntegrationTests (14)
Common.cs (4)
337Assert.False(float.IsNaN(array[i])); 338Assert.False(float.IsInfinity(array[i])); 352Assert.False(double.IsNaN(array[i])); 353Assert.False(double.IsInfinity(array[i]));
IntrospectiveTraining.cs (3)
61Assert.All(tree.CategoricalSplitFlags, flag => Assert.False(flag)); 105Assert.All(tree.CategoricalSplitFlags, flag => Assert.False(flag)); 196Assert.False(ldaDetails.ItemScoresPerTopic == null && ldaDetails.WordScoresPerTopic == null);
ModelFiles.cs (3)
299Assert.False(data.Schema["Features"].HasSlotNames()); 366Assert.False((loadedWithSchema as TransformerChain<ITransformer>).Any()); 372Assert.False((loadedWithLoader as TransformerChain<ITransformer>).Any());
Prediction.cs (4)
74Assert.False(pr.PredictedLabel); 75Assert.False(pr.Score > 0.7); 92Assert.False(pr.PredictedLabel); 136Assert.False((bool)field.GetValue(model));
Microsoft.ML.OnnxTransformerTest (5)
DnnImageFeaturizerTest.cs (1)
89Assert.False(true);
OnnxTransformTests.cs (4)
172Assert.False(true); 802Assert.False(File.Exists(onnxModel.ModelStream.Name)); 1011Assert.False(somethingWrong); 1041Assert.False(somethingWrong);
Microsoft.ML.Predictor.Tests (7)
TestParallelFasttreeInterface.cs (7)
34Assert.False(!_isCache); 105Assert.False(_isInitIteration); 113Assert.False(_isInitEnv); 121Assert.False(_isInitTreeLearner); 137Assert.False(_isInitTreeLearner); 138Assert.False(_isInitIteration); 147Assert.False(_isInitIteration);
Microsoft.ML.Sweeper.Tests (4)
TestSweeper.cs (4)
287Assert.False(task.IsCompleted); 472Assert.False(gridPoint[i][j]); 499Assert.False(gridPoint[i][j]); 531Assert.False(gridPoint[i][j]);
Microsoft.ML.TensorFlow.Tests (1)
TensorFlowEstimatorTests.cs (1)
94Assert.False(true);
Microsoft.ML.TestFramework (3)
DataPipe\TestDataPipeBase.cs (1)
45Assert.False(true);
GlobalBase.cs (2)
89Assert.False(_ignoreOne); 94Assert.False(_ignoreOne);
Microsoft.ML.Tests (23)
AnomalyDetectionTests.cs (6)
166Assert.False(results[i].PredictedLabel); 212Assert.False(results[1].PredictedLabel); 215Assert.False(results[2].PredictedLabel); 222Assert.False(results[4].PredictedLabel); 226Assert.False(results[5].PredictedLabel); 229Assert.False(results[6].PredictedLabel);
ImagesTests.cs (1)
1202Assert.False(prediction.ResizedImage == dataObjects[i].LoadedImage);
Scenarios\GetColumnTests.cs (1)
100Assert.False(true);
SvmLightTests.cs (2)
429Assert.False(curs.MoveNext()); 436Assert.False(curs.MoveNext());
TextLoaderTests.cs (2)
1199Assert.False(true); 1210Assert.False(true);
TrainerEstimators\OlsLinearRegressionTests.cs (1)
28Assert.False(model.Model.HasStatistics);
TrainerEstimators\SdcaTests.cs (2)
151Assert.False(sameScores); 210Assert.False(sameScores);
TrainerEstimators\TreeEstimators.cs (2)
651Assert.False(areEqual); 851Assert.False(row.CategoricalSplitFlags);
Transformers\CopyColumnEstimatorTests.cs (2)
66Assert.False(true); 86Assert.False(true);
Transformers\LineParserTests.cs (1)
48Assert.False(LineParser.ParseKeyThenNumbers(input, true).isSuccess);
Transformers\ValueMappingTests.cs (3)
381Assert.False(dColumn.IsKey); 384Assert.False(eColumn.IsKey); 387Assert.False(fColumn.IsKey);
Microsoft.ML.Tokenizers.Tests (4)
CodeGenTests.cs (3)
970Assert.False(codeGenTokenizer.AddPrefixSpace); 971Assert.False(codeGenTokenizer.AddBeginningOfSentence); 972Assert.False(codeGenTokenizer.AddEndOfSentence);
LlamaTests.cs (1)
374Assert.False(bpe.TreatWhitespaceAsSuffix);
Microsoft.Net.Http.Headers.Tests (47)
CacheControlHeaderValueTest.cs (1)
586Assert.False(CacheControlHeaderValue.TryParse(input, out var result));
ContentRangeHeaderValueTest.cs (1)
203Assert.False(ContentRangeHeaderValue.TryParse(input, out var result));
CookieHeaderValueTest.cs (2)
250Assert.False(CookieHeaderValue.TryParse(value, out var _)); 330Assert.False(result);
DateParserTest.cs (1)
30Assert.False(HeaderUtilities.TryParseDate(input, out var result));
EntityTagHeaderValueTest.cs (11)
100Assert.False(EntityTagHeaderValue.Any.Compare(null, useStrongComparison: true)); 101Assert.False(EntityTagHeaderValue.Any.Compare(null, useStrongComparison: false)); 123Assert.False(left.Compare(right, useStrongComparison: true)); 124Assert.False(right.Compare(left, useStrongComparison: true)); 163Assert.False(left.Compare(right, useStrongComparison: false)); 164Assert.False(right.Compare(left, useStrongComparison: false)); 262Assert.False(EntityTagHeaderValue.TryParseList(null, out var results)); 263Assert.False(EntityTagHeaderValue.TryParseList(new string[0], out results)); 264Assert.False(EntityTagHeaderValue.TryParseList(new string[] { "" }, out results)); 490Assert.False(EntityTagHeaderValue.TryParseStrictList(inputs, out var results)); 512Assert.False(EntityTagHeaderValue.TryParse(input, out var result));
HeaderUtilitiesTest.cs (4)
96Assert.False(HeaderUtilities.TryParseSeconds(new StringValues(headerValues), targetValue!, out value)); 186Assert.False(HeaderUtilities.TryParseNonNegativeInt64(valueString, out value)); 211Assert.False(HeaderUtilities.TryParseNonNegativeInt32(valueString, out value)); 409Assert.False(result);
MediaTypeHeaderValueTest.cs (15)
147Assert.False(mediaType0.IsReadOnly); 176Assert.False(mediaType0.IsReadOnly); 181Assert.False(mediaType0.Parameters.IsReadOnly); 191Assert.False(pair0.IsReadOnly); 208Assert.False(mediaType2.IsReadOnly); 215Assert.False(pair2.IsReadOnly); 535Assert.False(MediaTypeHeaderValue.TryParseList(null, out var results)); 536Assert.False(MediaTypeHeaderValue.TryParseList(new string[0], out results)); 537Assert.False(MediaTypeHeaderValue.TryParseList(new string[] { "" }, out results)); 679Assert.False(MediaTypeHeaderValue.TryParseStrictList(inputs, out var results)); 721Assert.False(matches); 773Assert.False(result); 846Assert.False(isSubset); 890Assert.False(result); 939Assert.False(MediaTypeHeaderValue.TryParse(input, out var result));
NameValueHeaderValueTest.cs (4)
82Assert.False(pair0.IsReadOnly); 115Assert.False(pair0.IsReadOnly); 566Assert.False(NameValueHeaderValue.TryParseStrictList(inputs, out var results)); 669Assert.False(NameValueHeaderValue.TryParse(input, out var result));
RangeConditionHeaderValueTest.cs (1)
149Assert.False(RangeConditionHeaderValue.TryParse(input, out var result));
RangeHeaderValueTest.cs (1)
171Assert.False(RangeHeaderValue.TryParse(input, out var result));
RangeItemHeaderValueTest.cs (1)
125Assert.False(RangeHeaderValue.TryParse("byte=" + input, out result));
SetCookieHeaderValueTest.cs (3)
395Assert.False(SetCookieHeaderValue.TryParse(value, out var _)); 487Assert.False(result); 498Assert.False(result);
StringWithQualityHeaderValueTest.cs (2)
462Assert.False(StringWithQualityHeaderValue.TryParseStrictList(inputs, out var results)); 481Assert.False(StringWithQualityHeaderValue.TryParse(input, out var result));
Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (18)
CodeModel\FileCodeFunctionTests.cs (3)
122Assert.False(testObject.CanOverride); 178Assert.False(testObject.IsOverloaded); 186Assert.False(testObject.IsShared);
CodeModel\FileCodeVariableTests.cs (2)
145Assert.False(testObject.IsConstant); 161Assert.False(testObject.IsShared);
PersistentStorage\AbstractPersistentStorageTests.cs (6)
121Assert.False(await storage.WriteStreamAsync(project, streamName, EncodeString(""))); 122Assert.False(await storage.WriteStreamAsync(document, streamName, EncodeString(""))); 336Assert.False(await storage.ChecksumMatchesAsync("TestReadChecksumReturnsNullWhenNeverWritten", s_checksum1)); 392Assert.False(await storage.ChecksumMatchesAsync(streamName1, s_checksum1)); 431Assert.False(await storage.ChecksumMatchesAsync(streamName1, s_checksum1)); 843Assert.False(location?.StartsWith("/") ?? false);
ProjectSystemShim\CPS\CSharpCompilerOptionsTests.cs (2)
54Assert.False(options.SpecificDiagnosticOptions.ContainsKey("CS1111")); 137Assert.False(projectContext.LastDesignTimeBuildSucceeded);
ProjectSystemShim\CPS\CSharpReferencesTests.cs (4)
82Assert.False(GetProject3ProjectReferences().Any(pr => pr.ProjectId == project1.Id)); 83Assert.False(GetProject3ProjectReferences().Any(pr => pr.ProjectId == project2.Id)); 84Assert.False(GetProject3MetadataReferences().Any(mr => mr.FilePath == metadaRefFilePath)); 149Assert.False(AnalyzersContainsAnalyzer());
ProjectSystemShim\LegacyProject\CSharpCompilerOptionsTests.cs (1)
100Assert.False(options.SpecificDiagnosticOptions.ContainsKey("CS1111"));
Mvc.Analyzers.Test (24)
CodeAnalysisExtensionsTest.cs (10)
484Assert.False(classHasAttribute); 485Assert.False(methodHasAttribute); 486Assert.False(propertyHasAttribute); 537Assert.False(hasAttributeWithoutInherit); 633Assert.False(hasAttributeWithoutInherit); 698Assert.False(hasAttributeWithoutInherit); 722Assert.False(isAssignableFrom); 743Assert.False(isAssignableFrom); 791Assert.False(isAssignableFromDerived); // Inverse shouldn't be true 847Assert.False(isAssignableFromDerived); // Inverse shouldn't be true
TopLevelParameterNameAnalyzerTest.cs (14)
245Assert.False(result); 263Assert.False(result); 281Assert.False(result); 302Assert.False(result); 327p => Assert.False(TopLevelParameterNameAnalyzer.IsProblematicParameter(symbolCache, p)), 328p => Assert.False(TopLevelParameterNameAnalyzer.IsProblematicParameter(symbolCache, p)), 329p => Assert.False(TopLevelParameterNameAnalyzer.IsProblematicParameter(symbolCache, p)), 330p => Assert.False(TopLevelParameterNameAnalyzer.IsProblematicParameter(symbolCache, p)), 331p => Assert.False(TopLevelParameterNameAnalyzer.IsProblematicParameter(symbolCache, p))); 349Assert.False(result); 367Assert.False(result); 386Assert.False(result); 403Assert.False(result); 537Assert.False(result);
Mvc.Api.Analyzers.Test (26)
ActualApiResponseMetadataFactoryTest.cs (3)
289Assert.False(metadata.IsDefaultResponse); 330Assert.False(metadata.IsDefaultResponse); 357Assert.False(metadata.IsDefaultResponse);
ApiControllerFactsTest.cs (4)
43Assert.False(result); 59Assert.False(result); 75Assert.False(result); 91Assert.False(result);
DeclaredApiResponseMetadataTest.cs (3)
91Assert.False(matches); 136Assert.False(matches); 150Assert.False(matches);
MvcFactsTest.cs (2)
74Assert.False(isController); 159Assert.False(isControllerAction);
SymbolApiConventionMatcherTest.cs (14)
41Assert.False(result); 55Assert.False(result); 69Assert.False(result); 83Assert.False(result); 139Assert.False(result); 153Assert.False(result); 167Assert.False(result); 181Assert.False(result); 195Assert.False(result); 209Assert.False(result); 237Assert.False(result); 263Assert.False(result); 329Assert.False(result); 345Assert.False(result);
Roslyn.Test.PdbUtilities (1)
Reader\MockSymUnmanagedReader.cs (1)
393Assert.False(source.IsDefault);
Roslyn.VisualStudio.Next.UnitTests (9)
Options\VisualStudioOptionStorageTests.cs (2)
135Assert.False(configName.StartsWith(OptionDefinition.CSharpConfigNamePrefix, StringComparison.OrdinalIgnoreCase)); 136Assert.False(configName.StartsWith(OptionDefinition.VisualBasicConfigNamePrefix, StringComparison.OrdinalIgnoreCase));
Options\VisualStudioSettingsOptionPersisterTests.cs (1)
228Assert.False(result.HasValue);
Remote\SnapshotSerializationTests.cs (1)
598Assert.False(string.IsNullOrEmpty(xmlDocComment));
Services\ServiceHubServicesTests_ExtensionMessageHandler.cs (3)
500Assert.False(handlerWasCalled2); 605Assert.False(handlerWasCalled); 611Assert.False(handlerWasCalled);
Services\SolutionAssetCacheTests.cs (1)
105Assert.False(gotChecksum2);
UnifiedSettings\TestModel\Input.cs (1)
30Assert.False(option is IPerLanguageValuedOption && languageName is null);
Shared.Tests (47)
Data.Validation\LengthAttributeTests.cs (14)
39Assert.False(Validator.TryValidateObject(options, context, results, true)); 53Assert.False(Validator.TryValidateObject(options, context, results, true)); 60Assert.False(Validator.TryValidateObject(options, context, results, true)); 95Assert.False(Validator.TryValidateObject(options, context, results, true)); 109Assert.False(Validator.TryValidateObject(options, context, results, true)); 117Assert.False(Validator.TryValidateObject(options, context, results, true)); 168Assert.False(Validator.TryValidateObject(options, context, results, true)); 186Assert.False(Validator.TryValidateObject(options, context, results, true)); 222Assert.False(Validator.TryValidateObject(options, context, results, true)); 234Assert.False(Validator.TryValidateObject(options, context, results, true)); 275Assert.False(Validator.TryValidateObject(options, context, results, true)); 293Assert.False(Validator.TryValidateObject(options, context, results, true)); 393Assert.False(Validator.TryValidateObject(options, context, results, true)); 413Assert.False(Validator.TryValidateObject(options, context, results, true));
Data.Validation\TimeSpanAttributeTests.cs (10)
37Assert.False(Validator.TryValidateObject(options, context, results, true)); 44Assert.False(Validator.TryValidateObject(options, context, results, true)); 62Assert.False(Validator.TryValidateObject(options, context, results, true)); 102Assert.False(Validator.TryValidateObject(options, context, results, true)); 109Assert.False(Validator.TryValidateObject(options, context, results, true)); 123Assert.False(Validator.TryValidateObject(options, context, results, true)); 130Assert.False(Validator.TryValidateObject(options, context, results, true)); 165Assert.False(Validator.TryValidateObject(options, context, results, true)); 172Assert.False(Validator.TryValidateObject(options, context, results, true)); 190Assert.False(Validator.TryValidateObject(options, context, results, true));
Debugger\DebuggerTest.cs (2)
30Assert.False(debugger.IsAttached); 43Assert.False(debugger.IsAttached);
EmptyCollections\EmptyReadonlyDictionaryTests.cs (8)
26Assert.False(instance.ContainsKey(5)); 27Assert.False(instance.TryGetValue(5, out _)); 38Assert.False(dict.Remove(1)); 39Assert.False(dict.Contains(new KeyValuePair<int, string>(1, "One"))); 40Assert.False(dict.ContainsKey(1)); 44Assert.False(dict.TryGetValue(1, out string? value)); 61Assert.False(coll.Remove(new KeyValuePair<int, string>(1, "One"))); 62Assert.False(coll.Contains(new KeyValuePair<int, string>(1, "One")));
EmptyCollections\EmptyReadOnlyListTests.cs (2)
58Assert.False(coll.Remove(1)); 59Assert.False(coll.Contains(1));
JsonSchemaExporter\JsonSchemaExporterConfigurationTests.cs (1)
17Assert.False(configuration.TreatNullObliviousAsNonNullable);
JsonSchemaExporter\JsonSchemaExporterTests.cs (1)
127Assert.False(schema is JsonObject jObj && jObj.ContainsKey("type"));
Memoization\MemoizeTests.cs (2)
170Assert.False(Args(0).Equals(null)); 228Assert.False(Args(0, 0).Equals(null));
Pools\PoolTests.cs (2)
260Assert.False(o.Busy); 275Assert.False(o.Busy);
RentedSpan\RentedSpanTest.cs (3)
14Assert.False(rental1.Rented); 18Assert.False(rental2.Rented); 22Assert.False(rental3.Rented);
StringSplit\StringRangeTests.cs (2)
21Assert.False(ss.Equals(new object())); 22Assert.False(ss.Equals(new StringRange(1, 3)));
Sockets.FunctionalTests (12)
src\Servers\Kestrel\test\FunctionalTests\ConnectionMiddlewareTests.cs (1)
77Assert.False(mockDuplexPipe.WasCompleted);
src\Servers\Kestrel\test\FunctionalTests\Http2\ShutdownTests.cs (2)
143Assert.False(requestTask.IsCompleted); 195Assert.False(requestTask.IsCompleted);
src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (5)
289Assert.False(loggedHigherThanDebug); 340Assert.False(loggedHigherThanDebug); 399Assert.False(loggedHigherThanDebug); 461Assert.False(appErrorLogged.Task.IsCompleted); 519Assert.False(loggedHigherThanDebug);
src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (4)
134Assert.False(headers.Contains(headerName)); 925Assert.False(requestAborted); 1010Assert.False(requestAborted); 1088Assert.False(requestAborted);
System.ServiceModel.Http.Tests (7)
Channels\HttpRequestMessagePropertyTest.cs (1)
21Assert.False(requestMsgProperty.SuppressEntityBody);
Channels\WebSocketTransportSettingsTest.cs (1)
26Assert.False(disablePayloadMasking);
ServiceModel\BasicHttpBindingTest.cs (3)
28Assert.False(binding.AllowCookies); 53Assert.False(binding.AllowCookies); 77Assert.False(binding.AllowCookies);
ServiceModel\BasicHttpsBindingTest.cs (2)
26Assert.False(binding.AllowCookies); 51Assert.False(binding.AllowCookies);
System.ServiceModel.Primitives.Tests (13)
Channels\MessageTest.cs (4)
42Assert.False(message.IsEmpty); 57Assert.False(message.IsEmpty); 92Assert.False(message.IsEmpty); 102Assert.False(message.IsEmpty);
Channels\UnderstoodHeadersTest.cs (2)
38if (String.Equals(mhi.Name, "AlphaHeader")) Assert.False(mhi.MustUnderstand); 39if (String.Equals(mhi.Name, "BravoHeader")) Assert.False(mhi.MustUnderstand);
IdentityModel\SecurityTokenSerializerTest.cs (3)
69Assert.False(sts.WriteTokenCoreCalled); 70Assert.False(sts.WriteKeyIdentifierCoreCalled); 71Assert.False(sts.WriteKeyIdentifierClauseCoreCalled);
Security\SecurityTokenRequirementTest.cs (1)
39Assert.False(tokenrequirement.TryGetProperty("invalidproperty", out string valueIsFalse));
ServiceModel\FaultExceptionTest.cs (2)
124Assert.False(string.IsNullOrEmpty(exception.Message)); 174Assert.False(string.IsNullOrEmpty(exception.Message));
ServiceModel\SynchronizedCollection.cs (1)
116Assert.False(coll.Remove(100000));
Templates.Blazor.Tests (1)
src\ProjectTemplates\Shared\Project.cs (1)
349Assert.False(profilesEnumerator.MoveNext());
Templates.Blazor.WebAssembly.Auth.Tests (2)
src\ProjectTemplates\Shared\Project.cs (1)
349Assert.False(profilesEnumerator.MoveNext());
src\Shared\E2ETesting\WaitAssert.cs (1)
47=> WaitAssertCore(driver, () => Assert.False(actual()));
Templates.Blazor.WebAssembly.Tests (2)
src\ProjectTemplates\Shared\Project.cs (1)
349Assert.False(profilesEnumerator.MoveNext());
src\Shared\E2ETesting\WaitAssert.cs (1)
47=> WaitAssertCore(driver, () => Assert.False(actual()));
Templates.Mvc.Tests (2)
src\ProjectTemplates\Shared\Project.cs (1)
349Assert.False(profilesEnumerator.MoveNext());
src\Shared\E2ETesting\WaitAssert.cs (1)
47=> WaitAssertCore(driver, () => Assert.False(actual()));
Templates.Tests (4)
ByteOrderMarkTest.cs (2)
68Assert.False(filesWithBOMCharactersPresent); 101Assert.False(nonBOMFilesPresent);
src\ProjectTemplates\Shared\Project.cs (1)
349Assert.False(profilesEnumerator.MoveNext());
src\Shared\E2ETesting\WaitAssert.cs (1)
47=> WaitAssertCore(driver, () => Assert.False(actual()));
VBCSCompiler.UnitTests (37)
AnalyzerConsistencyCheckerTests.cs (2)
159Assert.False(result); 230Assert.False(result);
BuildClientTests.cs (10)
146Assert.False(await tryConnectToNamedPipe((int)oneSec.TotalMilliseconds, cancellationToken: default)); 151Assert.False(connection.IsCompleted); 248Assert.False(Parse(optionPrefix + "shared:", "test.cs")); 249Assert.False(_hasShared); 259Assert.False(_hasShared); 269Assert.False(_hasShared); 285Assert.False(Parse(optionPrefix + "keepalive", "test.cs")); 288Assert.False(Parse(optionPrefix + "keepalive:", "test.cs")); 291Assert.False(Parse(optionPrefix + "keepalive:-100", "test.cs")); 294Assert.False(Parse(optionPrefix + "keepalive:100", "test.cs"));
BuildProtocolTest.cs (1)
40Assert.False(read.Utf8Output);
BuildServerConnectionTests.cs (1)
86Assert.False(ran);
ClientConnectionHandlerTests.cs (2)
109Assert.False(hitCompilation); 142Assert.False(hitCompilation);
CompilerServerTests.cs (8)
559Assert.False(File.Exists(Path.Combine(_tempDirectory.Path, "hello.exe"))); 589Assert.False(File.Exists(Path.Combine(_tempDirectory.Path, "hello.exe"))); 606Assert.False(File.Exists(Path.Combine(_tempDirectory.Path, "missingfile.exe"))); 624Assert.False(File.Exists(Path.Combine(_tempDirectory.Path, "hello.exe"))); 649Assert.False(File.Exists(Path.Combine(_tempDirectory.Path, "app.exe"))); 667Assert.False(File.Exists(Path.Combine(_tempDirectory.Path, "missingfile.exe"))); 696Assert.False(File.Exists(Path.Combine(_tempDirectory.Path, "hellovb.exe"))); 725Assert.False(File.Exists(Path.Combine(_tempDirectory.Path, "app.exe")));
NamedPipeClientConnectionHostTests.cs (3)
81Assert.False(namedPipeClientConnection.IsDisposed); 140Assert.False(stream.IsConnected); 154Assert.False(_host.IsListening);
VBCSCompilerServerTests.cs (10)
44Assert.False(task.IsFaulted); 214Assert.False(compileTask.IsCompleted); 224Assert.False(listener.KeepAliveHit); 263Assert.False(listener.KeepAliveHit); 383Assert.False(listener.KeepAliveHit); 403Assert.False(listener.KeepAliveHit); 423Assert.False(_shutdown); 431Assert.False(_shutdown); 453Assert.False(Parse("-invalid")); 454Assert.False(Parse("name"));