11822 references to False
Analyzer.Utilities.UnitTests (1)
Options\SymbolNamesWithValueOptionTests.cs (1)
294Assert.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)
265Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection));
src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (1)
100Assert.False(response.IsSuccessStatusCode);
src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (3)
183Assert.False(dataFrame.DataEndStream); 252Assert.False(dataFrame.DataEndStream); 297Assert.False(dataFrame.DataEndStream);
src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (1)
213Assert.False(response.IsSuccessStatusCode);
src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (2)
519Assert.False(response.Headers.TryGetValues("EmptyHeader", out var headerValues)); 806Assert.False(bytes0.IsEmpty);
src\Servers\IIS\IIS\test\IIS.Shared.FunctionalTests\StdOutRedirectionTests.cs (5)
46Assert.False(response.IsSuccessStatusCode); 70Assert.False(response.IsSuccessStatusCode); 100Assert.False(response.IsSuccessStatusCode); 127Assert.False(response.IsSuccessStatusCode); 153Assert.False(response.IsSuccessStatusCode);
IIS.LongTests (9)
src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (9)
179Assert.False(response.IsSuccessStatusCode); 215Assert.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)
179Assert.False(response.IsSuccessStatusCode); 215Assert.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)
179Assert.False(response.IsSuccessStatusCode); 215Assert.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)
307Assert.False(Directory.Exists(Path.Combine(deploymentResult.ContentRoot, "ShadowCopy", "0", "ShadowCopy"))); 337Assert.False(Directory.Exists(Path.Combine(deploymentResult.ContentRoot, "ShadowCopy", "0", "ShadowCopy")));
IIS.Tests (1)
HttpBodyControlFeatureTests.cs (1)
26Assert.False(bodyControl.AllowSynchronousIO);
IISExpress.FunctionalTests (16)
src\Servers\IIS\IIS\test\Common.FunctionalTests\GlobalVersionTests.cs (1)
100Assert.False(response.IsSuccessStatusCode);
src\Servers\IIS\IIS\test\Common.FunctionalTests\Http2Tests.cs (3)
183Assert.False(dataFrame.DataEndStream); 252Assert.False(dataFrame.DataEndStream); 297Assert.False(dataFrame.DataEndStream);
src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (1)
213Assert.False(response.IsSuccessStatusCode);
src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (2)
519Assert.False(response.Headers.TryGetValues("EmptyHeader", out var headerValues)); 806Assert.False(bytes0.IsEmpty);
src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (9)
179Assert.False(response.IsSuccessStatusCode); 215Assert.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 (2)
src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.cs (1)
1186Assert.False(ctx.Request.Headers.ContainsKey("Content-Length"));
src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.WebSockets.cs (1)
30Assert.False(upgradeFeature.IsUpgradableRequest);
InteractiveHost.UnitTests (3)
InteractiveHostDesktopTests.cs (3)
303Assert.False(await Execute("new System.Data.DataSet()")); 311Assert.False(await Execute("new System.Data.DataSet()")); 331Assert.False(await Execute("new System.Data.DataSet()"));
Interop.FunctionalTests (4)
Http3\Http3RequestTests.cs (1)
922Assert.False(request1Headers.ContainsKey("alt-used"));
Http3\Http3TlsTests.cs (2)
464Assert.False(ranConfigureKestrelAction); 465Assert.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)
165Assert.False(result.Response.Headers.ContainsKey(HeaderNames.WWWAuthenticate)); 290Assert.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)
401Assert.False(string.IsNullOrEmpty(entries["code_verifier"])); 439Assert.False(string.IsNullOrEmpty(queryParams["code_challenge"]));
GoogleTests.cs (7)
69Assert.False(queryParams.ContainsKey("access_type")); 70Assert.False(queryParams.ContainsKey("prompt")); 71Assert.False(queryParams.ContainsKey("approval_prompt")); 72Assert.False(queryParams.ContainsKey("login_hint")); 73Assert.False(queryParams.ContainsKey("include_granted_scopes")); 1040Assert.False(string.IsNullOrEmpty(entries["code_verifier"])); 1072Assert.False(string.IsNullOrEmpty(queryParams["code_challenge"]));
JwtBearerTests.cs (4)
140Assert.False(jwtHandler.MapInboundClaims); 141Assert.False(tokenHandler.MapInboundClaims); 149Assert.False(options.MapInboundClaims); 154Assert.False(jwtHandler.MapInboundClaims);
JwtBearerTests_Handler.cs (7)
130Assert.False(jwtHandler.MapInboundClaims); 131Assert.False(tokenHandler.MapInboundClaims); 139Assert.False(options.MapInboundClaims); 144Assert.False(jwtHandler.MapInboundClaims); 986Assert.False(jwtBearerOptions.RequireHttpsMetadata); 1092Assert.False(jwtBearerOptions.TokenValidationParameters.ValidateIssuer); 1093Assert.False(jwtBearerOptions.TokenValidationParameters.ValidateAudience);
MicrosoftAccountTests.cs (2)
307Assert.False(string.IsNullOrEmpty(entries["code_verifier"])); 339Assert.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)
389Assert.False(options.MapInboundClaims); 394Assert.False(jwtHandler.MapInboundClaims); 446Assert.False(options.RequireHttpsMetadata); 447Assert.False(options.GetClaimsFromUserInfoEndpoint); // Assert default values are respected 478Assert.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["user.is_authenticated"]); 85Assert.False((bool)measurement.Tags["user.is_authenticated"]); 86Assert.False(measurement.Tags.ContainsKey("aspnetcore.authorization.result")); 113Assert.False((bool)measurement.Tags["user.is_authenticated"]); 114Assert.False(measurement.Tags.ContainsKey("aspnetcore.authorization.policy")); 138Assert.False((bool)measurement.Tags["user.is_authenticated"]); 139Assert.False(measurement.Tags.ContainsKey("aspnetcore.authorization.policy")); 167Assert.False((bool)measurement.Tags["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 (37)
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 (3)
31Assert.False(result); 79Assert.False(result); 120Assert.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.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); 160Assert.False(firstRevalidationCall.CancellationToken.IsCancellationRequested); 213Assert.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 (89)
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);
ParameterViewTest.cs (4)
123Assert.False(didFind); 422Assert.False(hasRemovedDirectParameters); 443Assert.False(hasRemovedDirectParameters); 568Assert.False(hasRemovedDirectParameters);
PersistentState\ComponentApplicationStateTest.cs (3)
74Assert.False(applicationState.TryTakeFromJson<byte[]>("MyState", out var gone)); 166Assert.False(applicationState.TryTakeFromJson<byte[]>("MyState", out _)); 184Assert.False(applicationState.TryTakeFromJson<byte[]>("MyState", out _));
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); 193Assert.False(e2.IsSet); 452Assert.False(e2.IsSet); 541Assert.False(e2.IsSet); 634Assert.False(e2.IsSet); 723Assert.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)
172Assert.False(httpContext.Items.ContainsKey("3")); 455Assert.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 (59)
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 (45)
31Assert.False(HostHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 32Assert.False(string.IsNullOrEmpty(error)); 54Assert.False(DateTimeOffsetParser.Instance.TryParse(sv, out var result, out var error)); 55Assert.False(string.IsNullOrEmpty(error)); 62Assert.False(DateTimeOffsetParser.Instance.TryParse(sv, out var result, out var error)); 63Assert.False(string.IsNullOrEmpty(error)); 70Assert.False(DateTimeOffsetParser.Instance.TryParse(sv, out var result, out var error)); 71Assert.False(string.IsNullOrEmpty(error)); 102Assert.False(CookieHeaderValueListParser.Instance.TryParse(sv, out var result, out var error)); 104Assert.False(string.IsNullOrEmpty(error)); 111Assert.False(CookieHeaderValueListParser.Instance.TryParse(sv, out var result, out var error)); 113Assert.False(string.IsNullOrEmpty(error)); 130Assert.False(CacheControlHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 132Assert.False(string.IsNullOrEmpty(error)); 139Assert.False(CacheControlHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 141Assert.False(string.IsNullOrEmpty(error)); 158Assert.False(ContentDispositionHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 160Assert.False(string.IsNullOrEmpty(error)); 167Assert.False(ContentDispositionHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 169Assert.False(string.IsNullOrEmpty(error)); 186Assert.False(MediaTypeHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 188Assert.False(string.IsNullOrEmpty(error)); 195Assert.False(MediaTypeHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 197Assert.False(string.IsNullOrEmpty(error)); 215Assert.False(MediaTypeHeaderValueListParser.Instance.TryParse(sv, out var result, out var error)); 217Assert.False(string.IsNullOrEmpty(error)); 234Assert.False(EntityTagHeaderValueListParser.Instance.TryParse(sv, out var result, out var error)); 236Assert.False(string.IsNullOrEmpty(error)); 265Assert.False(StringWithQualityHeaderValueListParser.Instance.TryParse(sv, out var result, out var error)); 267Assert.False(string.IsNullOrEmpty(error)); 284Assert.False(UriParser.Instance.TryParse(sv, out var result, out var error)); 286Assert.False(string.IsNullOrEmpty(error)); 293Assert.False(UriParser.Instance.TryParse(sv, out var result, out var error)); 295Assert.False(string.IsNullOrEmpty(error)); 314Assert.False(RangeHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 316Assert.False(string.IsNullOrEmpty(error)); 323Assert.False(RangeHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 325Assert.False(string.IsNullOrEmpty(error)); 352Assert.False(RangeConditionHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 354Assert.False(string.IsNullOrEmpty(error)); 361Assert.False(RangeConditionHeaderValueParser.Instance.TryParse(sv, out var result, out var error)); 363Assert.False(string.IsNullOrEmpty(error)); 417Assert.False(IPAddressListParser.Instance.TryParse(sv, out var result, out var error)); 419Assert.False(string.IsNullOrEmpty(error)); 426Assert.False(IPAddressListParser.Instance.TryParse(sv, out var result, out var 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); 463Assert.False(context.MetricsTagsFeature.MetricsDisabled); 529Assert.False(startFired); 530Assert.False(stopFired); 564Assert.False(isEnabledStartFired); 565Assert.False(eventsFired); 602Assert.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)
1309Assert.False(filter.Executed); 1390Assert.False(service.StartCalled);
WebHostTests.AsyncDisposable.cs (3)
30Assert.False(provider.DisposeCalled); 31Assert.False(provider.DisposeAsyncCalled); 38Assert.False(provider.DisposeCalled);
WebHostTests.cs (20)
44Assert.False(serverAddressesFeature.Addresses.Any()); 45Assert.False(serverAddressesFeature.PreferHostingUrls); 64Assert.False(serverAddressFeature.PreferHostingUrls); 83Assert.False(serverAddressFeature.PreferHostingUrls); 103Assert.False(serverAddressFeature.PreferHostingUrls); 115Assert.False(serverAddressesFeature.PreferHostingUrls); 387Assert.False(singleton.Disposed); 388Assert.False(transient.Disposed); 392Assert.False(singleton.Disposed); 393Assert.False(transient.Disposed); 414Assert.False(applicationLifetime.ApplicationStarted.IsCancellationRequested); 415Assert.False(applicationLifetime2.ApplicationStarted.IsCancellationRequested); 473Assert.False(hostedServiceCalls2[0]); 559Assert.False(svc.StartCalled); 561Assert.False(svc.StopCalled); 563Assert.False(svc.StopCalled); 693Assert.False(hostedServiceCalls2[0]); 694Assert.False(started.All(s => s)); // Server doesn't start if hosted services throw 695Assert.False(started2.All(s => s)); 880Assert.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); 763Assert.False(invoked); 766Assert.False(httpContext.RequestAborted.IsCancellationRequested); 768Assert.False(httpContext.Response.HasStarted); 1590Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1675Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1759Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1789Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1819Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1849Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1876Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1916Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1944Assert.False(invoked); 1945Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1977Assert.False(invoked); 1978Assert.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)
1295Assert.False(TestSink.Writes.TryTake(out var _)); 1491Assert.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")); 189Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 1235Assert.False(context.Request.Headers.ContainsKey("X-Original-Prefix")); 1237Assert.False(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1279Assert.False(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1312Assert.False(context.Request.Headers.ContainsKey("X-Original-Prefix")); 1359Assert.False(context.Request.Headers.ContainsKey("X-Original-For")); 1360Assert.False(context.Request.Headers.ContainsKey("X-Original-Host")); 1361Assert.False(context.Request.Headers.ContainsKey("X-Original-Proto")); 1362Assert.False(context.Request.Headers.ContainsKey("X-Original-Prefix"));
IPNetworkTest.cs (2)
40Assert.False(network.Contains(IPAddress.Parse(addressText))); 133Assert.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 (145)
IdentityOptionsTest.cs (1)
29Assert.False(options.User.RequireUniqueEmail);
IdentityResultTest.cs (2)
12Assert.False(result.Succeeded); 20Assert.False(result.Succeeded);
Passkeys\DefaultPasskeyHandlerAssertionTest.cs (56)
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); 196Assert.False(result.Succeeded); 215Assert.False(result.Succeeded); 231Assert.False(result.Succeeded); 250Assert.False(result.Succeeded); 265Assert.False(result.Succeeded); 281Assert.False(result.Succeeded); 300Assert.False(result.Succeeded); 316Assert.False(result.Succeeded); 332Assert.False(result.Succeeded); 348Assert.False(result.Succeeded); 367Assert.False(result.Succeeded); 383Assert.False(result.Succeeded); 399Assert.False(result.Succeeded); 416Assert.False(result.Succeeded); 433Assert.False(result.Succeeded); 448Assert.False(result.Succeeded); 467Assert.False(result.Succeeded); 482Assert.False(result.Succeeded); 501Assert.False(result.Succeeded); 519Assert.False(result.Succeeded); 534Assert.False(result.Succeeded); 553Assert.False(result.Succeeded); 568Assert.False(result.Succeeded); 584Assert.False(result.Succeeded); 606Assert.False(result.Succeeded); 621Assert.False(result.Succeeded); 640Assert.False(result.Succeeded); 655Assert.False(result.Succeeded); 677Assert.False(result.Succeeded); 694Assert.False(result.Succeeded); 709Assert.False(result.Succeeded); 729Assert.False(result.Succeeded); 780Assert.False(result.Succeeded); 797Assert.False(result.Succeeded); 827Assert.False(result.Succeeded); 844Assert.False(result.Succeeded); 861Assert.False(result.Succeeded); 902Assert.False(result.Succeeded); 947Assert.False(result.Succeeded); 990Assert.False(result.Succeeded); 1013Assert.False(result.Succeeded); 1060Assert.False(result.Succeeded); 1083Assert.False(result.Succeeded); 1101Assert.False(result.Succeeded); 1119Assert.False(result.Succeeded); 1135Assert.False(result.Succeeded); 1168Assert.False(result.Succeeded);
Passkeys\DefaultPasskeyHandlerAttestationTest.cs (62)
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); 213Assert.False(result.Succeeded); 230Assert.False(result.Succeeded); 247Assert.False(result.Succeeded); 266Assert.False(result.Succeeded); 282Assert.False(result.Succeeded); 301Assert.False(result.Succeeded); 317Assert.False(result.Succeeded); 336Assert.False(result.Succeeded); 351Assert.False(result.Succeeded); 367Assert.False(result.Succeeded); 386Assert.False(result.Succeeded); 405Assert.False(result.Succeeded); 421Assert.False(result.Succeeded); 440Assert.False(result.Succeeded); 455Assert.False(result.Succeeded); 471Assert.False(result.Succeeded); 490Assert.False(result.Succeeded); 505Assert.False(result.Succeeded); 520Assert.False(result.Succeeded); 539Assert.False(result.Succeeded); 557Assert.False(result.Succeeded); 572Assert.False(result.Succeeded); 591Assert.False(result.Succeeded); 606Assert.False(result.Succeeded); 622Assert.False(result.Succeeded); 644Assert.False(result.Succeeded); 659Assert.False(result.Succeeded); 678Assert.False(result.Succeeded); 693Assert.False(result.Succeeded); 715Assert.False(result.Succeeded); 732Assert.False(result.Succeeded); 747Assert.False(result.Succeeded); 767Assert.False(result.Succeeded); 797Assert.False(result.Succeeded); 829Assert.False(result.Succeeded); 847Assert.False(result.Succeeded); 882Assert.False(result.Succeeded); 900Assert.False(result.Succeeded); 914Assert.False(result.Succeeded); 930Assert.False(result.Succeeded); 946Assert.False(result.Succeeded); 962Assert.False(result.Succeeded); 977Assert.False(result.Succeeded); 993Assert.False(result.Succeeded); 1009Assert.False(result.Succeeded); 1025Assert.False(result.Succeeded); 1040Assert.False(result.Succeeded); 1094Assert.False(result.Succeeded); 1108Assert.False(result.Succeeded); 1124Assert.False(result.Succeeded); 1141Assert.False(result.Succeeded); 1157Assert.False(result.Succeeded);
RoleManagerTest.cs (1)
54Assert.False(manager.SupportsQueryableRoles);
SignInManagerTest.cs (9)
57Assert.False(result.Succeeded); 87Assert.False(result.Succeeded); 309Assert.False(result.Succeeded); 473Assert.False(result.Succeeded); 951Assert.False(result.Succeeded); 952Assert.False(checkResult.Succeeded); 971Assert.False(result.Succeeded); 998Assert.False(result.Succeeded); 1025Assert.False(result.Succeeded);
UserManagerTest.cs (14)
750Assert.False(await manager.CheckPasswordAsync(null, "whatevs")); 757Assert.False(manager.SupportsQueryableUsers); 765Assert.False(manager.SupportsUserEmail); 777Assert.False(manager.SupportsUserPhoneNumber); 798Assert.False(manager.SupportsUserPassword); 813Assert.False(manager.SupportsUserSecurityStamp); 826Assert.False(manager.SupportsUserLogin); 837Assert.False(manager.SupportsUserClaim); 980Assert.False(manager.SupportsUserTwoFactor); 990Assert.False(manager.SupportsUserLockout); 1003Assert.False(manager.SupportsUserRole); 1017Assert.False(manager.SupportsUserAuthenticationTokens); 1028Assert.False(manager.SupportsUserAuthenticatorKey); 1038Assert.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)
62Assert.False(anyParameter.IsRequired); 2073Assert.False(description.IsRequired); 2094Assert.False(description.IsRequired); 2148Assert.False(description.IsRequired); 2167Assert.False(description.IsRequired);
EndpointMetadataApiDescriptionProviderTest.cs (13)
114Assert.False(apiParameterDescription.IsRequired); 786Assert.False(param.IsRequired); 818param => Assert.False(param.IsRequired), 820param => Assert.False(param.IsRequired)); 848param => Assert.False(param.IsRequired)); 868Assert.False(barParam.IsRequired); 907Assert.False(fooParam.IsRequired); 926Assert.False(nameParam.IsRequired); 1164Assert.False(bodyParameterDescription.IsRequired); 1255Assert.False(bodyParameterDescription.IsRequired); 1287Assert.False(bodyParameterDescription.IsRequired); 1344Assert.False(bodyParameterDescription.IsRequired); 1417Assert.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)
505Assert.False(isValid); 522Assert.False(isValid); 538Assert.False(isValid); 553Assert.False(isValid); 568Assert.False(isValid); 589Assert.False(isValid); 607Assert.False(isValid); 645Assert.False(isValid); 679Assert.False(isValid); 741Assert.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 (27)
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 (5)
31Assert.False(factory.GetTestAssembliesCalled); 33Assert.False(factory.CreateHostCalled); 48Assert.False(factory.GetTestAssembliesCalled); 51Assert.False(factory.CreateServerCalled); 52Assert.False(factory.CreateWebHostBuilderCalled);
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 (23)
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 (2)
277Assert.False(operation.RequestBody.Required); 330Assert.False(operation.RequestBody.Required);
Services\OpenApiGeneratorTests.cs (11)
125Assert.False(request.Required); 520Assert.False(barParam.Required); 534Assert.False(fooParam.Required); 702Assert.False(requestBody.Required); 736Assert.False(requestBody.Required); 752Assert.False(requestBody.Required); 784Assert.False(requestBody.Required); 843Assert.False(fromFileParam1.Required); 988param => Assert.False(param.Required), 990param => Assert.False(param.Required)); 1008param => Assert.False(param.Required));
Services\OpenApiSchemaService\OpenApiSchemaService.RequestBodySchemas.cs (2)
156Assert.False(GetRequestBodyForPath(document, "/non-required-poco").Required); 631Assert.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)
36Assert.False(feature.IsUpgradableRequest); 121Assert.False(httpContext.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 171Assert.False(httpContext.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 340Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 351Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 387Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 426Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 466Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 483Assert.False(decodedHeaders.ContainsKey(HeaderNames.Connection)); 502Assert.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)
94Assert.False(assertsExecuted); 140Assert.False(requestExecuted.Task.IsCompleted); 198Assert.False(applicationStoppingFired.Task.IsCompleted); 243Assert.False(applicationStoppingFired.Task.IsCompleted); 288Assert.False(applicationStoppingFired.Task.IsCompleted);
Microsoft.AspNetCore.Server.Kestrel.Core.Tests (174)
AddressBinderTests.cs (9)
45Assert.False(AddressBinder.TryCreateIPEndPoint( 61Assert.False(https); 72Assert.False(https); 83Assert.False(https); 93Assert.False(https); 104Assert.False(https); 115Assert.False(https); 126Assert.False(https); 137Assert.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)
201Assert.False(memoryPool.TryScheduleEviction(time)); 215Assert.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)
235Assert.False(host.Services.GetRequiredService<IHttpsConfigurationService>().IsInitialized);
KestrelConfigurationLoaderTests.cs (4)
131Assert.False(run1); 147Assert.False(run1); 196Assert.False(serverOptions.CodeBackedListenOptions[0].IsTls); 933Assert.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)
134Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 151Assert.False(context.Request.Headers.ContainsKey(HeaderNames.TransferEncoding)); 233Assert.False(readTask.IsCompleted); 394Assert.False(task.IsCompleted); 396Assert.False(task.Wait(50)); 456Assert.False(readTask.IsCompleted);
HttpContextBuilderTests.cs (4)
109Assert.False(task.IsCompleted); 111Assert.False(task.Wait(50)); 210Assert.False(readTask.IsCompleted); 260Assert.False(readTask.IsCompleted);
ResponseBodyTests.cs (1)
147Assert.False(zeroByteRead.IsCompleted);
ResponseFeatureTests.cs (2)
16Assert.False(responseInformation.HasStarted); 32Assert.False(responseInformation.HasStarted);
TestClientTests.cs (4)
142Assert.False(disposable.IsDisposed); 582Assert.False(ctx.Request.Headers.ContainsKey(HeaderNames.SecWebSocketProtocol)); 1030Assert.False(upgradeFeature.IsUpgradableRequest); 1035Assert.False(webSocketFeature.IsWebSocketRequest);
WebSocketClientTests.cs (1)
104Assert.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)
1347Assert.False(builder.Host.Properties.ContainsKey("Lowercase")); 1968Assert.False(newBuilder.Properties.TryGetValue(WebApplication.GlobalEndpointRouteBuilderKey, out _)); 2039Assert.False(response.IsSuccessStatusCode); 2145Assert.False(response.IsSuccessStatusCode); 2170Assert.False(response.IsSuccessStatusCode); 2504Assert.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.BuildCheck.UnitTests (97)
EditorConfig_Tests.cs (97)
127Assert.False(matcher.IsMatch("/aabc")); 128Assert.False(matcher.IsMatch("/ abc")); 129Assert.False(matcher.IsMatch("/cabc")); 157Assert.False(matcher.IsMatch("/abc.vb")); 178Assert.False(matcher.IsMatch("/aaa")); 179Assert.False(matcher.IsMatch("/???")); 180Assert.False(matcher.IsMatch("/abc")); 210Assert.False(matcher.IsMatch("/ab/c")); 211Assert.False(matcher.IsMatch("/ab\\\\c")); 221Assert.False(matcher.IsMatch("/ab/cd**efg*")); 222Assert.False(matcher.IsMatch("/*ab/cd*efg*")); 223Assert.False(matcher.IsMatch("/*ab/cd**ef/gh")); 234Assert.False(matcher.IsMatch("/aaaaaaaa")); 235Assert.False(matcher.IsMatch("/aa?cde?f")); 236Assert.False(matcher.IsMatch("/?a?cdexf")); 237Assert.False(matcher.IsMatch("/?axcde?f")); 248Assert.False(matcher.IsMatch("/abcdef")); 249Assert.False(matcher.IsMatch("/abc}{def")); 260Assert.False(matcher.IsMatch("/abcdef")); 261Assert.False(matcher.IsMatch("/abc\\,def")); 262Assert.False(matcher.IsMatch("/abc`def")); 278Assert.False(matcher.IsMatch("/abcxcs")); 279Assert.False(matcher.IsMatch("/abcxvb")); 280Assert.False(matcher.IsMatch("/abcxfs")); 281Assert.False(matcher.IsMatch("/subdir/abcxcs")); 282Assert.False(matcher.IsMatch("/subdir/abcxcb")); 283Assert.False(matcher.IsMatch("/subdir/abcxcs")); 304Assert.False(matcher.IsMatch("/subdir/test.cs")); 305Assert.False(matcher.IsMatch("/subdir/subdir/test.vb")); 306Assert.False(matcher.IsMatch("/test.vb")); 317Assert.False(matcher.IsMatch("/.")); 318Assert.False(matcher.IsMatch("/anything")); 329Assert.False(matcher.IsMatch("test.vb")); 330Assert.False(matcher.IsMatch("testxcs")); 360Assert.False(matcher.IsMatch("/test.fs")); 361Assert.False(matcher.IsMatch("/other.bbb")); 362Assert.False(matcher.IsMatch("/other.ccc")); 363Assert.False(matcher.IsMatch("/subdir/other.bbb")); 364Assert.False(matcher.IsMatch("/subdir/other.ccc")); 376Assert.False(matcher.IsMatch("/abcdef")); 377Assert.False(matcher.IsMatch("/ab--cd-ef")); 378Assert.False(matcher.IsMatch("/ab--cd--ef")); 391Assert.False(matcher.IsMatch("/abcs")); 392Assert.False(matcher.IsMatch("/abcd")); 393Assert.False(matcher.IsMatch("/vbcd")); 413Assert.False(matcher.IsMatch("/-1")); 414Assert.False(matcher.IsMatch("/-00000001")); 415Assert.False(matcher.IsMatch("/11")); 429Assert.False(matcher.IsMatch("/1")); 430Assert.False(matcher.IsMatch("/-11")); 431Assert.False(matcher.IsMatch("/--0")); 447Assert.False(matcher.IsMatch("/-11")); 448Assert.False(matcher.IsMatch("/11")); 449Assert.False(matcher.IsMatch("/--0")); 469Assert.False(matcher.IsMatch("/a-11b10")); 470Assert.False(matcher.IsMatch("/a-11b10")); 471Assert.False(matcher.IsMatch("/a-10b11")); 485Assert.False(matcher.IsMatch("/0")); 486Assert.False(matcher.IsMatch("/0.")); 487Assert.False(matcher.IsMatch("/0abc")); 491Assert.False(matcher.IsMatch("/0")); 492Assert.False(matcher.IsMatch("/0abc")); 509Assert.False(matcher.IsMatch("/abc.vs")); 518Assert.False(matcher.IsMatch("/abc.cs")); 519Assert.False(matcher.IsMatch("/abc.fs")); 522Assert.False(matcher.IsMatch("/abc.vxs")); 534Assert.False(matcher.IsMatch("/abc.vs")); 535Assert.False(matcher.IsMatch("/abc.xs")); 536Assert.False(matcher.IsMatch("/abc.vxs")); 548Assert.False(matcher.IsMatch("/yx")); 549Assert.False(matcher.IsMatch("/00x")); 558Assert.False(matcher.IsMatch("/0x")); 559Assert.False(matcher.IsMatch("/1x")); 560Assert.False(matcher.IsMatch("/9x")); 562Assert.False(matcher.IsMatch("/00x")); 576Assert.False(matcher.IsMatch("/yx")); 577Assert.False(matcher.IsMatch("/0ax")); 608Assert.False(matcher.IsMatch("/ab")); 609Assert.False(matcher.IsMatch("/[b")); 610Assert.False(matcher.IsMatch("/bc")); 611Assert.False(matcher.IsMatch("/ac")); 612Assert.False(matcher.IsMatch("/[c")); 625Assert.False(matcher.IsMatch("/bbd")); 626Assert.False(matcher.IsMatch("/-cd")); 627Assert.False(matcher.IsMatch("/bcd")); 640Assert.False(matcher.IsMatch("/bbd")); 641Assert.False(matcher.IsMatch("/-cd")); 642Assert.False(matcher.IsMatch("/bcd")); 654Assert.False(matcher.IsMatch("/acd")); 655Assert.False(matcher.IsMatch("/bcd")); 656Assert.False(matcher.IsMatch("/acd")); 669Assert.False(matcher.IsMatch("/dcd")); 670Assert.False(matcher.IsMatch("/\\\\cd")); 671Assert.False(matcher.IsMatch("/cd")); 682Assert.False(matcher.IsMatch("/ab[[cd")); 683Assert.False(matcher.IsMatch("/abc")); 684Assert.False(matcher.IsMatch("/abd"));
Microsoft.Build.CommandLine.UnitTests (28)
CommandLineSwitches_Tests.cs (28)
264Assert.False(multipleParametersAllowed); 269Assert.False(CommandLineSwitches.IsParameterizedSwitch(String.Empty, out parameterizedSwitch, out duplicateSwitchErrorMessage, out multipleParametersAllowed, out missingParametersErrorMessage, out unquoteParameters, out emptyParametersAllowed)); 272Assert.False(multipleParametersAllowed); 274Assert.False(unquoteParameters); 762Assert.False(switches.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.Version)); 763Assert.False(switches[CommandLineSwitches.ParameterlessSwitch.Version]); 805Assert.False(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target)); 814Assert.False(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Target, "/t:\"", "\"", false, true, false)); 827Assert.False(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Target, "/t:A,\"\";B", "A,\"\";B", true, true, false)); 848Assert.False(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Logger)); 908Assert.False(switchesLeft.HaveErrors()); 909Assert.False(switchesRight.HaveErrors()); 913Assert.False(switchesLeft.HaveErrors()); 914Assert.False(switchesRight.HaveErrors()); 919Assert.False(switchesRight.HaveErrors()); 924Assert.False(switchesRight.HaveErrors()); 943Assert.False(switchesLeft.HaveErrors()); 944Assert.False(switchesRight.HaveErrors()); 969Assert.False(switchesLeft.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.NoConsoleLogger)); 975Assert.False(switchesRight1.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.Help)); 993Assert.False(switchesRight2.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.Help)); 1006Assert.False(switchesLeft.HaveErrors()); 1017Assert.False(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target)); 1023Assert.False(switchesRight.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project)); 1210Assert.False(switches.HaveAnySwitchesBeenSet()); 1216Assert.False(switches.HaveAnySwitchesBeenSet()); 1241Assert.False(nodeReuse); 1567Assert.False(helpMessageLines[i].StartsWith(" "));
Microsoft.Build.Engine.OM.UnitTests (120)
Construction\ConstructionEditing_Tests.cs (2)
57Assert.False(project.HasUnsavedChanges); 3247Assert.False(string.IsNullOrEmpty(expectedItem));
Construction\ProjectItemElement_Tests.cs (2)
1011Assert.False(project.HasUnsavedChanges); 1031Assert.False(project.HasUnsavedChanges);
Construction\ProjectMetadataElement_Tests.cs (7)
238Assert.False(metadatum.ContainingProject.HasUnsavedChanges); 821Assert.False(metadata.ExpressedAsAttribute); 884Assert.False(metadata.ExpressedAsAttribute); 957Assert.False(metadata.ExpressedAsAttribute); 1000Assert.False(metadata.ExpressedAsAttribute); 1187Assert.False(metadata.ExpressedAsAttribute); 1234Assert.False(metadata.ExpressedAsAttribute);
Construction\ProjectOutputElement_Tests.cs (2)
28Assert.False(output.IsOutputProperty); 44Assert.False(output.IsOutputItem);
Construction\ProjectPropertyElement_Tests.cs (2)
180Assert.False(property.ContainingProject.HasUnsavedChanges); 207Assert.False(property.ContainingProject.HasUnsavedChanges);
Construction\ProjectRootElement_Tests.cs (2)
1303Assert.False(xml1.PreserveFormatting); 1307Assert.False(xml2.PreserveFormatting);
Construction\SolutionFile_Tests.cs (6)
609Assert.False(csharpProject.ProjectConfigurations["Debug|Win32"].IncludeInBuild); 618Assert.False(csharpProject.ProjectConfigurations["Release|Win32"].IncludeInBuild); 623Assert.False(vcProject.ProjectConfigurations["Debug|Any CPU"].IncludeInBuild); 632Assert.False(vcProject.ProjectConfigurations["Release|Any CPU"].IncludeInBuild); 697Assert.False(classLibrary1.ProjectConfigurations["Debug|Any CPU"].IncludeInBuild); 700Assert.False(classLibrary1.ProjectConfigurations["Release|Any CPU"].IncludeInBuild);
Definition\DefinitionEditing_Tests.cs (4)
570Assert.False(object.ReferenceEquals(item1, item2)); 1443Assert.False(result); // false as it was not in the regular items collection 1577Assert.False(project.IsDirty); 2487Assert.False(object.ReferenceEquals(item1, item2));
Definition\ProjectCollection_Tests.cs (14)
329Assert.False(ReferenceEquals(project1, collection.LoadProject("c:\\1"))); 355Assert.False(ReferenceEquals(project1.Xml, project2.Xml)); 1040Assert.False(collection.ContainsToolset("x")); 1052Assert.False(collection.RemoveToolset("nonexistent")); 1184Assert.False(dirtyRaised); 1343Assert.False(dirtyRaised); 1351Assert.False(dirtyRaised); 1356Assert.False(dirtyRaised); 1371Assert.False(dirtyRaised); 1377Assert.False(dirtyRaised); 1401Assert.False(dirtyRaised); 1412Assert.False(dirtyRaised); // "Dirtying the XML directly should not result in a ProjectChanged event." 1417Assert.False(dirtyRaised); 1421Assert.False(dirtyRaised);
Definition\ProjectItem_Tests.cs (7)
103Assert.False(item.Metadata.GetEnumerator().MoveNext()); 171Assert.False(Object.ReferenceEquals(m1, idm1)); 273Assert.False(item.Metadata.GetEnumerator().MoveNext()); 1934Assert.False(found); 1935Assert.False(project.IsDirty); 2220Assert.False(project.IsDirty); 2280Assert.False(project.IsDirty);
Definition\ProjectMetadata_Tests.cs (4)
57Assert.False(project.IsDirty); 95Assert.False(project.IsDirty); 99Assert.False(project.IsDirty); 449Assert.False(metadata.IsImported);
Definition\ProjectProperty_Tests.cs (10)
125Assert.False(project.IsDirty); 179Assert.False(project.GetProperty(varName).IsGlobalProperty); 180Assert.False(project.GetProperty(varName).IsReservedProperty); 181Assert.False(project.GetProperty(varName).IsImported); 194Assert.False(project.GetProperty("g").IsEnvironmentProperty); 196Assert.False(project.GetProperty("g").IsReservedProperty); 197Assert.False(project.GetProperty("g").IsImported); 210Assert.False(project.GetProperty("MSBuildProjectFile").IsEnvironmentProperty); 211Assert.False(project.GetProperty("MSBuildProjectFile").IsGlobalProperty); 213Assert.False(project.GetProperty("MSBuildProjectFile").IsImported);
Definition\ProtectImports_Tests.cs (3)
410Assert.False(item.HasMetadata(ProjectMetadataName)); // "Metadata was not removed from project." 579Assert.False(metadata.IsImported); // "IsImport property is set." 652Assert.False(metadata.IsImported); // "IsImport property is set."
Instance\ProjectInstance_Tests.cs (11)
89Assert.False(returned.Metadata.GetEnumerator().MoveNext()); 94Assert.False(item.Metadata.GetEnumerator().MoveNext()); 110Assert.False(returned.Metadata.GetEnumerator().MoveNext()); 115Assert.False(item.Metadata.GetEnumerator().MoveNext()); 193Assert.False(item.Metadata.GetEnumerator().MoveNext()); 225Assert.False(Object.ReferenceEquals(first, second)); 237Assert.False(Object.ReferenceEquals(first.GetProperty("p1"), second.GetProperty("p1"))); 330Assert.False(Object.ReferenceEquals(Helpers.MakeList(first.GetItems("i"))[0], Helpers.MakeList(second.GetItems("i"))[0])); 441Assert.False(projAInstanceItem.Metadata.Any()); 483Assert.False(projAInstanceItem.Metadata.Any()); 518Assert.False(projAInstanceItem.Metadata.Any());
Instance\ProjectItemInstance_Tests.cs (2)
79Assert.False(item.Metadata.GetEnumerator().MoveNext()); 448Assert.False(item.Metadata.GetEnumerator().MoveNext());
Instance\ProjectPropertyInstance_Tests.cs (1)
82Assert.False(property.IsImmutable);
ObjectModelRemoting\Helpers\ViewValidation.construction.cs (2)
454Assert.False(viewChild is ProjectElementContainer); 510Assert.False(realXml is ProjectElementContainer);
ObjectModelRemoting\Helpers\ViewValidation.cs (1)
117Assert.False(real is T);
ObjectModelRemoting\LinkedConstructionModify_Tests.cs (11)
230Assert.False(newOutputItem1.View.IsOutputProperty); 236Assert.False(newOutputItemWithConfig1.View.IsOutputProperty); 240Assert.False(newOutputProp1.View.IsOutputItem); 246Assert.False(newOutputPropWithConfig1.View.IsOutputItem); 284Assert.False(newTask.View.Parameters.ContainsKey(paramName.Ver(1))); 285Assert.False(newTask.Real.Parameters.ContainsKey(paramName.Ver(1))); 286Assert.False(newTask.View.Parameters.ContainsKey(paramName.Ver(5))); 287Assert.False(newTask.Real.Parameters.ContainsKey(paramName.Ver(5))); 327Assert.False(newOutputItem.View.IsOutputProperty); 332Assert.False(newOutputProp.View.IsOutputItem); 669Assert.False(item.View.HasMetadata);
ObjectModelRemoting\LinkedEvaluationModify_Tests.cs (18)
49Assert.False(File.Exists(savedPath)); 53Assert.False(realProj.IsDirty); 54Assert.False(viewProj.IsDirty); 77Assert.False(realProj.IsDirty); 78Assert.False(viewProj.IsDirty); 81Assert.False(viewProj.IsBuildEnabled); 82Assert.False(realProj.IsBuildEnabled); 88Assert.False(viewProj.SkipEvaluation); 89Assert.False(realProj.SkipEvaluation); 95Assert.False(viewProj.ThrowInsteadOfSplittingItemElement); 96Assert.False(realProj.ThrowInsteadOfSplittingItemElement); 236Assert.False(fooView.HasMetadata("xx")); 243Assert.False(fooView.RemoveMetadata("xxNone")); 245Assert.False(fooView.HasMetadata("xx")); 250Assert.False(fooView.HasMetadata("xxReal")); 257Assert.False(fooView.HasMetadata("xxReal")); 315Assert.False(pair.View.GlobalProperties.ContainsKey("gp1")); 316Assert.False(pair.View.GlobalProperties.ContainsKey("Configuration"));
ObjectModelRemoting\LinkedProjectCollection_Tests.cs (4)
104Assert.False(prj1Coll.Contains(proj1remote0)); 108Assert.False(prj2Coll.Contains(proj2remote0)); 109Assert.False(prj2Coll.Contains(proj2remote1)); 117Assert.False(prj2Coll.Contains(proj3remote1));
ObjectModelRemoting\LinkedSpecialCasesScenarios.cs (5)
99Assert.False(xmlPair.View.HasUnsavedChanges); 111Assert.False(sourceProject.HasUnsavedChanges); 153Assert.False(xmlPair.View.HasUnsavedChanges); 181Assert.False(externalSource && sourceProject.HasUnsavedChanges); 200Assert.False(externalSource && sourceProject.HasUnsavedChanges);
Microsoft.Build.Engine.UnitTests (278)
AssemblyNameEx_Tests.cs (30)
402Assert.False(extension.HasProcessorArchitectureInFusionName); 421Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 422Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName)); 447Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 448Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version)); 457Assert.False(assemblyNameToMatchVersion.PartialNameCompare(assemblyToCompare)); 458Assert.False(assemblyNameToMatchVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version)); 460Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 461Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version)); 491Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 492Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture)); 501Assert.False(assemblyNameToMatchCulture.PartialNameCompare(assemblyToCompare)); 502Assert.False(assemblyNameToMatchCulture.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture)); 504Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 505Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture)); 535Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 536Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken)); 545Assert.False(assemblyNameToMatchPublicToken.PartialNameCompare(assemblyToCompare)); 546Assert.False(assemblyNameToMatchPublicToken.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken)); 548Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 549Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken)); 578Assert.False(assemblyToCompare.PartialNameCompare(assemblyNameToNotMatch, PartialComparisonFlags.SimpleName, true)); 580Assert.False(assemblyToCompare.PartialNameCompare(assemblyMatchNoRetargetable)); 581Assert.False(assemblyToCompare.PartialNameCompare(assemblyMatchNoRetargetable, PartialComparisonFlags.SimpleName, true)); 584Assert.False(assemblyMatchNoRetargetable.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true)); 588Assert.False(assemblyNameToMatchRetargetable.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true)); 598Assert.False(match); 623Assert.False(AssemblyNameComparer.GenericComparer.Equals(a, d)); 625Assert.False(AssemblyNameComparer.GenericComparerConsiderRetargetable.Equals(a, b)); 627Assert.False(AssemblyNameComparer.GenericComparerConsiderRetargetable.Equals(a, d));
BackEnd\AssemblyTaskFactory_Tests.cs (10)
143Assert.False(_taskFactory.TaskNameCreatableByFactory("NotInAssembly", null, String.Empty, null, ElementLocation.Create(".", 1, 1))); 154Assert.False(_taskFactory.TaskNameCreatableByFactory(String.Empty, null, String.Empty, null, ElementLocation.Create(".", 1, 1))); 165Assert.False(_taskFactory.TaskNameCreatableByFactory(null, null, String.Empty, null, ElementLocation.Create(".", 1, 1))); 205Assert.False(_taskFactory.TaskNameCreatableByFactory("TaskToTestFactories", taskIdentityParameters, String.Empty, null, ElementLocation.Create(".", 1, 1))); 236Assert.False(foundNotExpectedParameter); 285Assert.False(createdTask is TaskHostTask); 316Assert.False(createdTask is TaskHostTask); 349Assert.False(createdTask is TaskHostTask); 382Assert.False(createdTask is TaskHostTask); 417Assert.False(createdTask is TaskHostTask);
BackEnd\BinaryTranslator_Tests.cs (1)
933Assert.False(deserializedValue.ContainsKey("FOO"));
BackEnd\BuildEventArgTransportSink_Tests.cs (4)
97Assert.False(transportSink.HaveLoggedBuildFinishedEvent); 98Assert.False(wentInHandler); // "Expected not to go into transport delegate" 117Assert.False(transportSink.HaveLoggedBuildStartedEvent); 119Assert.False(wentInHandler); // "Expected not to go into transport delegate"
BackEnd\BuildManager_Tests.cs (3)
1277Assert.False(submission1.IsCompleted); 2361Assert.False(Directory.Exists(innerBuildCacheDirectory)); // "Inner build cache directory still exists after inner build manager was disposed." 2368Assert.False(Directory.Exists(outerBuildCacheDirectory)); // "Outer build cache directory still exists after outer build manager was disposed."
BackEnd\BuildRequest_Tests.cs (2)
57Assert.False(request.IsConfigurationResolved); 63Assert.False(request3.IsConfigurationResolved);
BackEnd\BuildRequestConfiguration_Tests.cs (6)
111Assert.False(config2.WasGeneratedByNode); 115Assert.False(config3.WasGeneratedByNode); 312Assert.False(configuration.IsLoaded); 313Assert.False(configuration.IsCached); 314Assert.False(configuration.IsActivelyBuilding); 389Assert.False(configuration.IsCacheable);
BackEnd\BuildResult_Tests.cs (3)
250Assert.False(result.HasResultsForTarget("bar")); 290Assert.False(foundFoo); 296Assert.False(foundBar);
BackEnd\CacheSerialization_Tests.cs (3)
107Assert.False(result.ConfigCache.HasConfiguration(2)); 108Assert.False(result.ConfigCache.HasConfiguration(3)); 142Assert.False(buildResult.HasResultsForTarget("target3"));
BackEnd\ConfigurationMetadata_Tests.cs (2)
114Assert.False(metadata1.Equals(metadata3)); 119Assert.False(metadata1.Equals(metadata4));
BackEnd\EventSourceSink_Tests.cs (10)
156Assert.False(handlerHelper.EnteredEventHandler); 157Assert.False(handlerHelper.EnteredAnyEventHandler); 158Assert.False(handlerHelper.EnteredStatusEventHandler); 177Assert.False(ExceptionHandling.IsCriticalException(e)); 187Assert.False(ExceptionHandling.IsCriticalException(e)); 198Assert.False(ExceptionHandling.IsCriticalException(e)); 212Assert.False(ExceptionHandling.IsCriticalException(e)); 321Assert.False(testHandlers.EnteredStatusEventHandler); 1008Assert.False(_sourceForEvents.HaveLoggedBuildStartedEvent); 1014Assert.False(_sourceForEvents.HaveLoggedBuildFinishedEvent);
BackEnd\LoggingService_Tests.cs (5)
294Assert.False(_initializedService.RegisterLogger(consoleLogger)); 296Assert.False(_initializedService.RegisterLogger(regularILogger)); 441Assert.False(_initializedService.RegisterDistributedLogger(regularILogger, description)); 619Assert.False(_initializedService.RegisterDistributedLogger(regularILogger, description)); 642Assert.False(loggingService.OnlyLogCriticalEvents); // "Expected only log critical events to be false"
BackEnd\LoggingServicesLogMethod_Tests.cs (2)
184Assert.False(exception.HasBeenLogged); 1305Assert.False(Object.ReferenceEquals(actualEventArgs.Properties, properties));
BackEnd\MSBuild_Tests.cs (3)
999Assert.False(success); // "Build succeeded. See 'Standard Out' tab for details." 1563Assert.False(success); // "Build Succeeded. See 'Standard Out' tab for details." 1583Assert.False(success2); // "Build Succeeded. See 'Standard Out' tab for details."
BackEnd\NodeEndpointInProc_Tests.cs (2)
264Assert.False(_linkStatusTable.ContainsKey(endpoints.NodeEndpoint)); 265Assert.False(_linkStatusTable.ContainsKey(endpoints.ManagerEndpoint));
BackEnd\ResultsCache_Tests.cs (1)
188Assert.False(response.Results.HasResultsForTarget("testTarget"));
BackEnd\TargetBuilder_Tests.cs (19)
130Assert.False(result.HasResultsForTarget("Bar")); 154Assert.False(result.HasResultsForTarget("Skip")); 183Assert.False(result.HasResultsForTarget("Foo")); 184Assert.False(result.HasResultsForTarget("Skip")); 185Assert.False(result.HasResultsForTarget("Error")); 186Assert.False(result.HasResultsForTarget("Baz2")); 187Assert.False(result.HasResultsForTarget("Bar")); 188Assert.False(result.HasResultsForTarget("Baz")); 195Assert.False(resultsCache.GetResultForRequest(entry.Request).HasResultsForTarget("Baz2")); 777Assert.False(result.ResultsByTarget["Build"].AfterTargetsHaveFailed); 804Assert.False(result.ResultsByTarget["Build"].AfterTargetsHaveFailed); 834Assert.False(result.ResultsByTarget["Build"].AfterTargetsHaveFailed); 878Assert.False(result.ResultsByTarget["PostBuild"].AfterTargetsHaveFailed); 905Assert.False(result.ResultsByTarget["Build"].AfterTargetsHaveFailed); 932Assert.False(result.ResultsByTarget["Build;Me"].AfterTargetsHaveFailed); 964Assert.False(result.ResultsByTarget["Build"].AfterTargetsHaveFailed); 1250Assert.False(result.ResultsByTarget["Build"].AfterTargetsHaveFailed); 1349Assert.False(success); 1437Assert.False(resultsCache.GetResultForRequest(entry.Request).HasResultsForTarget("ProduceError2"));
BackEnd\TaskBuilder_Tests.cs (2)
471Assert.False(result); 495Assert.False(result);
BackEnd\TaskExecutionHost_Tests.cs (4)
170Assert.False(_host.SetTaskParameters(parameters)); 630Assert.False(executeValue); 942Assert.False(_host.GatherTaskOutputs("NonExistentOutput", ElementLocation.Create(".", 1, 1), true, "output")); 1460Assert.False(_parametersSetOnTask.ContainsKey(parameterName));
BackEnd\TaskHost_Tests.cs (2)
112Assert.False(object.ReferenceEquals(targetOutputItem, mockItemInCache)); 531Assert.False(_taskHost.IsRunningMultipleNodes); // "Expect IsRunningMultipleNodes to be false with 1 node"
BackEnd\TaskRegistry_Tests.cs (10)
1327Assert.False(parameterInfo.Output); 1328Assert.False(parameterInfo.Required); 1576Assert.False(((TaskPropertyInfo)registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.UsingTaskParameters["ParameterWithAllAttributesHardCoded"]).Output); 1591Assert.False(((TaskPropertyInfo)registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.UsingTaskParameters["ParameterWithAllAttributesHardCoded"]).Output); 1623Assert.False(((TaskPropertyInfo)registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.UsingTaskParameters["ParameterWithAllAttributesHardCoded"]).Required); 1638Assert.False(((TaskPropertyInfo)registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.UsingTaskParameters["ParameterWithAllAttributesHardCoded"]).Required); 1742Assert.False(inlineTaskRecord.TaskBodyEvaluated); 1780Assert.False(registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.TaskBodyEvaluated.Equals(body)); 1798Assert.False(registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.TaskBodyEvaluated.Equals(expandedBody)); 1824Assert.False(registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.TaskBodyEvaluated);
Collections\MSBuildNameIgnoreCaseComparer_Tests.cs (9)
26Assert.False(MSBuildNameIgnoreCaseComparer.Default.Equals("FOO", " FOO")); 27Assert.False(MSBuildNameIgnoreCaseComparer.Default.Equals("FOOA", "FOOB")); 28Assert.False(MSBuildNameIgnoreCaseComparer.Default.Equals("AFOO", "BFOO")); 29Assert.False(MSBuildNameIgnoreCaseComparer.Default.Equals("FOO", "FOO ")); 30Assert.False(MSBuildNameIgnoreCaseComparer.Default.Equals("a", "b")); 32Assert.False(MSBuildNameIgnoreCaseComparer.Default.Equals("x", null)); 33Assert.False(MSBuildNameIgnoreCaseComparer.Default.Equals(null, "x")); 64Assert.False(MSBuildNameIgnoreCaseComparer.Default.Equals("x", null)); 73Assert.False(MSBuildNameIgnoreCaseComparer.Default.Equals(null, "x"));
Collections\MultiDictionary_Tests.cs (4)
29Assert.False(dictionary.Remove("x", "y")); 85Assert.False(dictionary.Remove("z", "y1")); 86Assert.False(dictionary.Remove("x", "y1")); 87Assert.False(dictionary.Remove("y", "y2"));
Collections\OMcollections_tests.cs (3)
53Assert.False(properties.Remove("x")); 144Assert.False(items.Remove(item1)); 215Assert.False(readOnlyDictionary.ContainsKey("p2"));
Construction\ElementLocation_Tests.cs (3)
89Assert.False(location3.Equals(location1)); 90Assert.False(location4.Equals(location2)); 91Assert.False(location4.Equals(location6));
Construction\ProjectRootElement_Tests.cs (2)
55Assert.False(ProjectRootElement.IsEmptyXmlFile(path)); 79Assert.False(xml.XmlDocument.IsReadOnly);
Construction\SolutionFilter_Tests.cs (1)
210Assert.False(File.Exists("C:\\notAPath2\\MSBuild.Dev.sln"));
CopyOnWriteDictionary_Tests.cs (6)
81Assert.False(result); 83Assert.False(dictionary.ContainsKey(string.Empty)); 102Assert.False(Object.ReferenceEquals(k1, k2)); 183Assert.False(dictionary.HasSameBacking(clone)); 184Assert.False(clone2.HasSameBacking(clone)); 188Assert.False(dictionary.HasSameBacking(clone2));
Definition\ItemDefinitionGroup_Tests.cs (6)
110Assert.False(ItemContainsMetadata(p, "Compile", "a.cs", "Third", "3rd")); 437Assert.False(p.ItemDefinitions.ContainsKey("Compile")); 439Assert.False(ItemContainsMetadata(p, "Compile", "a.cs", "First", "1st")); 491Assert.False(p.ItemDefinitions.ContainsKey("Compile")); 493Assert.False(ItemContainsMetadata(p, "Compile", "a.cs", "First", "1st")); 547Assert.False(ItemContainsMetadata(p, "Compile", "a.cs", "First", "1st"));
EscapingUtilities_Tests.cs (7)
79Assert.False(EscapingUtilities.ContainsEscapedWildcards("NoStarOrQMark")); 80Assert.False(EscapingUtilities.ContainsEscapedWildcards("%")); 81Assert.False(EscapingUtilities.ContainsEscapedWildcards("%%")); 82Assert.False(EscapingUtilities.ContainsEscapedWildcards("%2")); 83Assert.False(EscapingUtilities.ContainsEscapedWildcards("%4")); 84Assert.False(EscapingUtilities.ContainsEscapedWildcards("%3A")); 85Assert.False(EscapingUtilities.ContainsEscapedWildcards("%2B"));
Evaluation\Evaluator_Tests.cs (7)
962Assert.False(imports[0].IsImported); 964Assert.False(imports[2].IsImported); 1050Assert.False(circularImportsAreRecorded); 3345Assert.False(project.GlobalProperties.ContainsKey("Foo")); 3357Assert.False(project.GlobalProperties.ContainsKey("Foo")); 4645Assert.False(result); 5265Assert.False(result);
Evaluation\ProjectRootElementCache_Tests.cs (1)
127Assert.False(Object.ReferenceEquals(xml0, xml2));
Evaluation\SimpleVersion_Tests.cs (9)
143Assert.False(version1 == version2); 144Assert.False(version1 >= version2); 145Assert.False(version1 > version2); 150Assert.False(version1 < version2); 154Assert.False(version1 > version2); 155Assert.False(version1 != version2); 159Assert.False(version1 < version2); 160Assert.False(version1 <= version2); 161Assert.False(version1 == version2);
Evaluation\UsedUninitializedProperties_Tests.cs (2)
20Assert.False(props.TryGetPropertyElementLocation("Hello", out IElementLocation? elementLocation)); 39Assert.False(props.TryGetPropertyElementLocation("Hello", out elementLocation));
FileLogger_Tests.cs (2)
340Assert.False(Directory.Exists(directory)); 341Assert.False(File.Exists(log));
FileMatcher_Tests.cs (1)
2610Assert.False(shouldBeRecursive); // "FileMatcher Regression: Match was not recursive when it should have been."
FileUtilities_Tests.cs (40)
229Assert.False(FileUtilities.EndsWithSlash(@"C:\foo")); 230Assert.False(FileUtilities.EndsWithSlash(@"C:")); 231Assert.False(FileUtilities.EndsWithSlash(@"foo")); 234Assert.False(FileUtilities.EndsWithSlash(String.Empty)); 287Assert.False(result); 368Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("rootxxx")); // "test 41" 369Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Rootxxx")); // "test 42" 370Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("xxxxxxx")); // "test 43" 372Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("filexxxx")); // "test 44" 373Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Filexxxx")); // "test 45" 374Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("idenxxxx")); // "test 46" 375Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Idenxxxx")); // "test 47" 376Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("xxxxxxxx")); // "test 48" 378Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("extenxxxx")); // "test 49" 379Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Extenxxxx")); // "test 50" 380Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("direcxxxx")); // "test 51" 381Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Direcxxxx")); // "test 52" 382Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("xxxxxxxxx")); // "test 53" 384Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("xxxxxxxxxx")); // "test 54" 386Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("relativexxx")); // "test 55" 387Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Relativexxx")); // "test 56" 388Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("createdxxxx")); // "test 57" 389Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Createdxxxx")); // "test 58" 390Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("xxxxxxxxxxx")); // "test 59" 392Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("recursivexxx")); // "test 60" 393Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Recursivexxx")); // "test 61" 394Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("accessedxxxx")); // "test 62" 395Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Accessedxxxx")); // "test 63" 396Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("modifiedxxxx")); // "test 64" 397Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("Modifiedxxxx")); // "test 65" 398Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier("xxxxxxxxxxxx")); // "test 66" 400Assert.False(FileUtilities.ItemSpecModifiers.IsItemSpecModifier(null)); // "test 67" 407Assert.False(FileUtilities.ItemSpecModifiers.IsDerivableItemSpecModifier("RecursiveDir")); 408Assert.False(FileUtilities.ItemSpecModifiers.IsDerivableItemSpecModifier("recursivedir")); 532Assert.False(FileUtilities.FileOrDirectoryExistsNoThrow("||")); 533Assert.False(FileUtilities.FileOrDirectoryExistsNoThrow(isWindows ? @"c:\doesnot_exist" : "/doesnot_exist")); 873Assert.False(FileUtilities.LooksLikeUnixFilePath(SystemSpecificAbsolutePath)); 874Assert.False(FileUtilities.LooksLikeUnixFilePath("/path/that/looks/unixy")); 875Assert.False(FileUtilities.LooksLikeUnixFilePath("/root")); 893Assert.False(FileUtilities.LooksLikeUnixFilePath("second/file.txt"));
Globbing\CompositeGlob_Tests.cs (2)
103Assert.False(compositeGlob.IsMatch(stringToMatch)); 146Assert.False(composite.IsMatch(""));
Globbing\MSBuildGlob_Tests.cs (14)
140Assert.False(glob.IsLegal); 141Assert.False(glob.TestOnlyNeedsRecursion); 150Assert.False(glob.IsMatch($"b/.../c/d.cs")); 192Assert.False(glob.IsMatch(((char)i).ToString())); 203Assert.False(glob.IsMatch(invalidFileChar.ToString())); 218Assert.False(glob.IsMatch("/")); 223Assert.False(glob.IsMatch("\\")); 226Assert.False(glob.IsMatch("/")); 245Assert.False(glob.IsMatch("acd")); 253Assert.False(glob.IsMatch("B")); 283Assert.False(glob.IsMatch(string.Empty)); 292Assert.False(glob.IsLegal); 312Assert.False(glob.IsMatch(stringToMatch)); 327Assert.False(glob.IsMatch(@"../x/d13/../x/d12/d23/../a.cs"));
Globbing\MSBuildGlobWithGaps_Tests.cs (1)
36Assert.False(glob.IsMatch("ab"));
Instance\HostServices_Tests.cs (2)
414Assert.False(hostServices.HasInProcessHostObject(project.FullPath)); 438Assert.False(hostServices.HasInProcessHostObject(project2.FullPath));
Instance\ProjectMetadataInstance_Internal_Tests.cs (1)
30Assert.False(Object.ReferenceEquals(metadata, clone));
Instance\ProjectPropertyInstance_Internal_Tests.cs (2)
30Assert.False(Object.ReferenceEquals(property, clone)); 58Assert.False(property.IsImmutable);
Instance\TaskItem_Tests.cs (1)
177Assert.False(object.ReferenceEquals(parent, clone)); // "The parent and the child should not be the same object"
Scanner_Tests.cs (4)
543Assert.False(lexer.Advance()); 548Assert.False(lexer.Advance()); 552Assert.False(lexer.Advance()); 563Assert.False(lexer.Advance());
TypeLoader_Tests.cs (8)
43Assert.False(TypeLoader.IsPartialTypeNameMatch("MyTasks.CscTask", "Csc")); // ==> no match 44Assert.False(TypeLoader.IsPartialTypeNameMatch("MyTasks.MyCsc", "Csc")); // ==> no match 45Assert.False(TypeLoader.IsPartialTypeNameMatch("MyTasks.ATask\\.Csc", "Csc")); // ==> no match 46Assert.False(TypeLoader.IsPartialTypeNameMatch("MyTasks.ATask\\\\\\.Csc", "Csc")); // ==> no match 52Assert.False(TypeLoader.IsPartialTypeNameMatch("Microsoft.Build.Tasks.Csc", "Vbc")); 189Assert.False(File.Exists(originalDllPath)); 205Assert.False(File.Exists(newDllPath)); 209Assert.False(Directory.Exists(tempDirectoryPath));
XmakeAttributes_Tests.cs (16)
19Assert.False(XMakeAttributes.IsSpecialTaskAttribute("NotAnAttribute")); 30Assert.False(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute("NotAnAttribute")); 31Assert.False(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute(XMakeAttributes.include)); 32Assert.False(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute(XMakeAttributes.continueOnError)); 33Assert.False(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute(XMakeAttributes.condition)); 34Assert.False(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute(XMakeAttributes.msbuildArchitecture)); 35Assert.False(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute(XMakeAttributes.msbuildRuntime)); 45Assert.False(XMakeAttributes.IsNonBatchingTargetAttribute("NotAnAttribute")); 65Assert.False(XMakeAttributes.RuntimeValuesMatch(XMakeAttributes.MSBuildRuntimeValues.currentRuntime, XMakeAttributes.MSBuildRuntimeValues.clr2)); 67Assert.False(XMakeAttributes.RuntimeValuesMatch(XMakeAttributes.MSBuildRuntimeValues.clr4, XMakeAttributes.MSBuildRuntimeValues.clr2)); 68Assert.False(XMakeAttributes.RuntimeValuesMatch(XMakeAttributes.MSBuildRuntimeValues.clr4, XMakeAttributes.MSBuildRuntimeValues.net)); 69Assert.False(XMakeAttributes.RuntimeValuesMatch(XMakeAttributes.MSBuildRuntimeValues.clr2, XMakeAttributes.MSBuildRuntimeValues.net)); 140Assert.False(XMakeAttributes.ArchitectureValuesMatch(XMakeAttributes.MSBuildArchitectureValues.currentArchitecture, notCurrentArchitecture)); 141Assert.False(XMakeAttributes.ArchitectureValuesMatch(XMakeAttributes.MSBuildArchitectureValues.x64, XMakeAttributes.MSBuildArchitectureValues.x86)); 163Assert.False(XMakeAttributes.TryMergeArchitectureValues(XMakeAttributes.MSBuildArchitectureValues.currentArchitecture, notCurrentArchitecture, out mergedArchitecture)); 164Assert.False(XMakeAttributes.TryMergeArchitectureValues(XMakeAttributes.MSBuildArchitectureValues.x64, XMakeAttributes.MSBuildArchitectureValues.x86, out mergedArchitecture));
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)
550Assert.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.Build.Tasks.UnitTests (203)
AssemblyNameEx_Tests.cs (30)
402Assert.False(extension.HasProcessorArchitectureInFusionName); 421Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 422Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName)); 447Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 448Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version)); 457Assert.False(assemblyNameToMatchVersion.PartialNameCompare(assemblyToCompare)); 458Assert.False(assemblyNameToMatchVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version)); 460Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 461Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version)); 491Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 492Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture)); 501Assert.False(assemblyNameToMatchCulture.PartialNameCompare(assemblyToCompare)); 502Assert.False(assemblyNameToMatchCulture.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture)); 504Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 505Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture)); 535Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 536Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken)); 545Assert.False(assemblyNameToMatchPublicToken.PartialNameCompare(assemblyToCompare)); 546Assert.False(assemblyNameToMatchPublicToken.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken)); 548Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare)); 549Assert.False(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken)); 578Assert.False(assemblyToCompare.PartialNameCompare(assemblyNameToNotMatch, PartialComparisonFlags.SimpleName, true)); 580Assert.False(assemblyToCompare.PartialNameCompare(assemblyMatchNoRetargetable)); 581Assert.False(assemblyToCompare.PartialNameCompare(assemblyMatchNoRetargetable, PartialComparisonFlags.SimpleName, true)); 584Assert.False(assemblyMatchNoRetargetable.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true)); 588Assert.False(assemblyNameToMatchRetargetable.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true)); 598Assert.False(match); 623Assert.False(AssemblyNameComparer.GenericComparer.Equals(a, d)); 625Assert.False(AssemblyNameComparer.GenericComparerConsiderRetargetable.Equals(a, b)); 627Assert.False(AssemblyNameComparer.GenericComparerConsiderRetargetable.Equals(a, d));
CombinePath_Tests.cs (1)
213Assert.False(t.Execute()); // "should have failed"
Copy_Tests.cs (27)
555Assert.False(t.Execute(m.CopyFile, !isUseSingleThreadedCopy)); 560Assert.False(FileUtilities.FileExistsNoThrow(destination)); 668Assert.False(t.Execute(m.CopyFile, !isUseSingleThreadedCopy)); 725Assert.False(t.Execute()); 860Assert.False(t.Execute()); 1238Assert.False(result); 1285Assert.False(result); 1332Assert.False(result); 1374Assert.False(result); 1501Assert.False(result); 1548Assert.False(result); 1611Assert.False(success); 1812Assert.False(NativeMethodsShared.IsUnixLike ? !success : success); 2144Assert.False(success); 2147Assert.False(File.Exists(outFile1)); 2193Assert.False(result); 2231Assert.False(result); 2232Assert.False(File.Exists(destinationFile)); 2257Assert.False(result); 2281Assert.False(result); 2303Assert.False(result); 2325Assert.False(result); 2352Assert.False(result); 2393Assert.False(t.UseHardlinksIfPossible); 2478Assert.False(result); 2507Assert.False(result); 2922Assert.False(result);
EscapingUtilities_Tests.cs (7)
79Assert.False(EscapingUtilities.ContainsEscapedWildcards("NoStarOrQMark")); 80Assert.False(EscapingUtilities.ContainsEscapedWildcards("%")); 81Assert.False(EscapingUtilities.ContainsEscapedWildcards("%%")); 82Assert.False(EscapingUtilities.ContainsEscapedWildcards("%2")); 83Assert.False(EscapingUtilities.ContainsEscapedWildcards("%4")); 84Assert.False(EscapingUtilities.ContainsEscapedWildcards("%3A")); 85Assert.False(EscapingUtilities.ContainsEscapedWildcards("%2B"));
Exec_Tests.cs (9)
150Assert.False(result); 169Assert.False(result); 246Assert.False(result); 629Assert.False(result); 642Assert.False(result); 761Assert.False(result); 811Assert.False(result); 824Assert.False(result); 885Assert.False(result);
FileStateTests.cs (3)
191Assert.False(state.FileExists); 412Assert.False(new FileState(file).FileExists); 413Assert.False(new FileState(file).DirectoryExists);
FindUnderPath_Tests.cs (2)
49Assert.False(success); 65Assert.False(success);
GetInstalledSDKLocations_Tests.cs (5)
203Assert.False(success); 221Assert.False(success); 240Assert.False(success); 302Assert.False(sdksAndVersions.ContainsValue("3.0")); 303Assert.False(sdksAndVersions.ContainsValue("4.0"));
GetSDKReference_Tests.cs (2)
764Assert.False(success); 787Assert.False(success);
Hash_Tests.cs (1)
41Assert.False(string.IsNullOrWhiteSpace(emptyItemHash));
MakeDir_Tests.cs (3)
92Assert.False(success); 191Assert.False(success); 252Assert.False(success);
Move_Tests.cs (24)
48Assert.False(File.Exists(sourceFile)); // "Expected the source file to be gone." 94Assert.False(File.Exists(sourceFile)); // "Expected the source file to be gone." 140Assert.False(t.Execute()); 142Assert.False(File.Exists(sourceFile)); // "Expected the source file to still not exist." 229Assert.False(t.Execute()); 283Assert.False(File.Exists(sourceFile)); // "Source file should be gone" 339Assert.False(File.Exists(sourceFile)); // "Source file should be gone" 393Assert.False(File.Exists(sourceFile)); // "Source file should be gone" 457Assert.False(success); 515Assert.False(result); 517Assert.False(File.Exists(file + "2")); 535Assert.False(move.Execute()); 551Assert.False(move.Execute()); 566Assert.False(move.Execute()); 581Assert.False(move.Execute()); 660Assert.False(success); 702Assert.False(File.Exists(sourceFile)); // "source gone" 764Assert.False(success); 767Assert.False(File.Exists(outFile1)); 805Assert.False(result); 834Assert.False(result); 852Assert.False(result); 870Assert.False(result); 888Assert.False(result);
MSBuild_Tests.cs (6)
696Assert.False(success); // "Build succeeded. See 'Standard Out' tab for details." 979Assert.False(msbuildTask.BuildInParallel); // "Iteration of 0 Expected BuildInParallel to be false" 1001Assert.False(msbuildTask.BuildInParallel); // "Iteration of 2 Expected BuildInParallel to be false" 1013Assert.False(msbuildTask.BuildInParallel); // "Iteration of 3 Expected BuildInParallel to be false" 1168Assert.False(success); // "Build Succeeded. See 'Standard Out' tab for details." 1185Assert.False(success); // "Build Succeeded. See 'Standard Out' tab for details."
NativeMethodsShared_Tests.cs (2)
105Assert.False(NativeMethodsShared.GetLastWriteDirectoryUtcTime(file, out directoryTime)); 150Assert.False(exceptionCaught); // "SetCurrentDirectory should not throw!"
PropertyParser_Tests.cs (2)
105Assert.False(PropertyParser.GetTable(null, "Properties", new[] { "=Debug" }, out _)); 114Assert.False(PropertyParser.GetTable(null, "Properties",
RemoveDuplicates_Tests.cs (3)
29Assert.False(t.HadAnyDuplicates); 118Assert.False(t.HadAnyDuplicates); 151Assert.False(t.HadAnyDuplicates);
ResolveNonMSBuildProjectOutput_Tests.cs (1)
352Assert.False(rvpo.VerifyProjectReferenceItems(taskItems, true /* treat problems as errors */));
ResolveSDKReference_Tests.cs (11)
668Assert.False(succeeded); 891Assert.False(succeeded); 1390Assert.False(succeeded); 1584Assert.False(succeeded); 2427Assert.False(succeeded); 2862Assert.False(succeeded); 2960Assert.False(succeeded); 3171Assert.False(succeeded); 3402Assert.False(succeeded); 3544Assert.False(succeeded); 3680Assert.False(succeeded);
ResourceHandling\GenerateResource_Tests.cs (26)
1341Assert.False(Utilities.FileUpdated(strFile, strTime)); // Was not updated 1780Assert.False(success); 1786Assert.False(File.Exists(resourcesFile1)); 1859Assert.False(success); 1865Assert.False(File.Exists(resourcesFile1)); 1942Assert.False(success); 2056Assert.False(success); 2109Assert.False(success); 2147Assert.False(result); 2151Assert.False(File.Exists(resourcesFile)); 2349Assert.False(success); 2359Assert.False(File.Exists(outputFile)); 2580Assert.False(success); 2789Assert.False(t.Execute()); 2843Assert.False(success); 2881Assert.False(success); 2886Assert.False(File.Exists(resourcesFile)); 2918Assert.False(success); 2923Assert.False(File.Exists(resourcesFile)); 2955Assert.False(success); 2960Assert.False(File.Exists(resourcesFile)); 2998Assert.False(success); 3004Assert.False(File.Exists(resourcesFile)); 3005Assert.False(File.Exists(csFile)); 3042Assert.False(success); // "Task should have failed." 3718Assert.False(t.Execute());
TelemetryTaskTests.cs (1)
69Assert.False(retVal);
Touch_Tests.cs (5)
222Assert.False(success); 270Assert.False(success); 291Assert.False(success); 330Assert.False(success); 355Assert.False(success);
WriteCodeFragment_Tests.cs (11)
36Assert.False(result); 52Assert.False(result); 68Assert.False(result); 213Assert.False(File.Exists(file)); 240Assert.False(File.Exists(file)); 258Assert.False(result); 276Assert.False(result); 483Assert.False(result); 631Assert.False(result); 654Assert.False(result); 677Assert.False(result);
WriteLinesToFile_Tests.cs (2)
41Assert.False(a.Execute()); 43Assert.False(File.Exists(a.File.ItemSpec));
XmlPeek_Tests.cs (6)
203Assert.False(p.Execute()); // "Test should've failed" 220Assert.False(p.Execute()); // "Test should've failed" 237Assert.False(p.Execute()); // "Test should've failed" 255Assert.False(p.Execute()); // "Test should've failed" 274Assert.False(executeResult); // "Execution should've failed" 310Assert.False(result); // "Only 3rd value should pass."
XslTransformation_Tests.cs (13)
194Assert.False(t.Execute()); // "The test should fail when there is missing Xsl params" 243Assert.False(t.Execute()); // "The test should fail when there is missing Xml params" 274Assert.False(t.Execute()); // "The test should fail when there is no params" 308Assert.False(t.Execute()); // "The test should fail when there are too many files" 342Assert.False(t.Execute()); // "The test should fail when there are too many files" 469Assert.False(result); // "Only 5th and 7th values should pass." 624Assert.False(t.Execute()); // "This test should've failed (no output)." 653Assert.False(t.Execute()); // "This test should've failed (bad xml)." 681Assert.False(t.Execute()); // "This test should've failed (bad xslt)." 739Assert.False(t.Execute()); // "This test should've failed (bad params1)." 772Assert.False(t.Execute()); // "This test should've failed (bad output)." 837Assert.False(t.Execute()); // "This test should've failed (xsl with error)." 1089Assert.False(t.Execute()); // "Test should have failed and not allowed the use of the document() function within the xslt file"
Microsoft.Build.UnitTests.Shared (3)
ObjectModelHelpers.cs (3)
904Assert.False(string.IsNullOrEmpty(fileRelativePath)); 1551Assert.False(result); 1986Assert.False(project.HasUnsavedChanges);
Microsoft.Build.Utilities.UnitTests (9)
EscapingUtilities_Tests.cs (7)
79Assert.False(EscapingUtilities.ContainsEscapedWildcards("NoStarOrQMark")); 80Assert.False(EscapingUtilities.ContainsEscapedWildcards("%")); 81Assert.False(EscapingUtilities.ContainsEscapedWildcards("%%")); 82Assert.False(EscapingUtilities.ContainsEscapedWildcards("%2")); 83Assert.False(EscapingUtilities.ContainsEscapedWildcards("%4")); 84Assert.False(EscapingUtilities.ContainsEscapedWildcards("%3A")); 85Assert.False(EscapingUtilities.ContainsEscapedWildcards("%2B"));
NativeMethodsShared_Tests.cs (2)
105Assert.False(NativeMethodsShared.GetLastWriteDirectoryUtcTime(file, out directoryTime)); 150Assert.False(exceptionCaught); // "SetCurrentDirectory should not throw!"
Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (126)
CommandLineTests.cs (125)
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); 1892Assert.False(parsedArgs.Errors.Any()); 1897Assert.False(parsedArgs.Errors.Any()); 1904Assert.False(parsedArgs.Errors.Any()); 1954Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 1955Assert.False(parsedArgs.EmitPdb); 1956Assert.False(parsedArgs.EmitPdbFile); 1961Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 1962Assert.False(parsedArgs.EmitPdb); 1963Assert.False(parsedArgs.EmitPdbFile); 1968Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 1982Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 1983Assert.False(parsedArgs.EmitPdb); 1984Assert.False(parsedArgs.EmitPdbFile); 1989Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 1995Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2002Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2008Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2015Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2022Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2028Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2034Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2040Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2041Assert.False(parsedArgs.EmitPdb); 2046Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2064Assert.False(parsedArgs.CompilationOptions.DebugPlusMode); 2065Assert.False(parsedArgs.EmitPdb); 2087Assert.False(parsedArgs.EmitPdbFile); 2092Assert.False(parsedArgs.EmitPdbFile); 2603Assert.False(parsedArgs.CompilationOptions.Deterministic); 2615Assert.False(parsedArgs.CompilationOptions.Deterministic); 4163Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4170Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4177Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4216Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4224Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4237Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4245Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4264Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4274Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4283Assert.False(parsedArgs.CompilationOptions.ReportSuppressedDiagnostics); 4512Assert.False(parsedArgs.Errors.Any()); 4516Assert.False(parsedArgs.Errors.Any()); 4565Assert.False(parsedArgs.Errors.Any()); 4803Assert.False(parsedArgs.Errors.Any()); 4806Assert.False(parsedArgs.Errors.Any()); 4809Assert.False(parsedArgs.Errors.Any()); 4810Assert.False(parsedArgs.EmitOptions.HighEntropyVirtualAddressSpace); 4821Assert.False(parsedArgs.Errors.Any()); 4822Assert.False(parsedArgs.EmitOptions.HighEntropyVirtualAddressSpace); 4834Assert.False(parsedArgs.CompilationOptions.CheckOverflow); 5569Assert.False(parsedArgs.CompilationOptions.AllowUnsafe); 5577Assert.False(parsedArgs.CompilationOptions.AllowUnsafe); 5607Assert.False((bool)parsedArgs.CompilationOptions.DelaySign); 5630Assert.False(parsedArgs.CompilationOptions.PublicSign); 5637Assert.False(parsedArgs.CompilationOptions.PublicSign); 7423Assert.False(((CSharpCompilation)comp).FeatureDisableLengthBasedSwitch); 8351Assert.False(parsedArgs.PrintFullPaths); 9420Assert.False(parsedArgs2.ReportAnalyzer); 9453Assert.False(parsedArgs.SkipAnalyzers); 9469Assert.False(parsedArgs.SkipAnalyzers); 9477Assert.False(parsedArgs.SkipAnalyzers); 10520Assert.False(hostOutputRan); 11864Assert.False(File.Exists(dll)); 11867Assert.False(File.Exists(refDll)); 11927Assert.False(File.Exists(pdb)); 12373Assert.False(options.Features.ContainsKey("InterceptorsNamespaces")); 14687Assert.False(globalOptions.TryGetValue("key2", out _)); 14688Assert.False(globalOptions.TryGetValue("key3", out _)); 14689Assert.False(globalOptions.TryGetValue("key4", out _)); 14690Assert.False(globalOptions.TryGetValue("key5", out _)); 14691Assert.False(globalOptions.TryGetValue("key6", out _)); 14692Assert.False(globalOptions.TryGetValue("key7", out _)); 14698Assert.False(classOptions.TryGetValue("key2", out _)); 14699Assert.False(classOptions.TryGetValue("key3", out _)); 14702Assert.False(classOptions.TryGetValue("key5", out _)); 14703Assert.False(classOptions.TryGetValue("key6", out _)); 14704Assert.False(classOptions.TryGetValue("key7", 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)
3998Assert.False(completionList.ItemsList.Any(c => c.DisplayText == "Goo()"));
Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (6)
98Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && e.ReturnsVoid)); 99Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && !e.ReturnsVoid)); 101Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property)); 111Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && e.ReturnsVoid)); 112Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && !e.ReturnsVoid)); 114Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property));
Formatting\Indentation\SmartIndenterEnterOnTokenTests.cs (1)
1455Assert.False(
NavigateTo\NavigateToSearcherTests.cs (1)
332Assert.False(searchGeneratedDocumentsAsyncCalled);
PdbSourceDocument\ImplementationAssemblyLookupServiceTests.cs (1)
56Assert.False(service.TryFindImplementationAssemblyPath(GetDllPath(packDir), out var implementationDll));
PdbSourceDocument\PdbSourceDocumentTests.cs (1)
1024Assert.False(result);
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)
415Assert.False(token.IsMissing); 416Assert.False(chars.IsDefaultOrEmpty); 466Assert.False(token.IsMissing); 467Assert.False(chars.IsDefaultOrEmpty);
EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (4)
332Assert.False(token.IsMissing); 333Assert.False(chars.IsDefaultOrEmpty); 344Assert.False(token.IsMissing); 345Assert.False(chars.IsDefaultOrEmpty);
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (216)
CodeGen\CodeGenAsyncTests.cs (2)
66Assert.False(options.EnableEditAndContinue); 75Assert.False(options.EnableEditAndContinue);
CodeGen\CodeGenAwaitForeachTests.cs (3)
1675Assert.False(internalInfo.NeedsDisposal); 3355Assert.False(internalInfo.NeedsDisposal); 5147Assert.False(internalInfo.NeedsDisposal);
CodeGen\CodeGenAwaitUsingTests.cs (17)
2303Assert.False(first.Equals(nulls1)); 2304Assert.False(first.Equals(nulls2)); 2305Assert.False(first.Equals(nulls3)); 2306Assert.False(first.Equals(nulls4)); 2308Assert.False(nulls1.Equals(first)); 2309Assert.False(nulls2.Equals(first)); 2310Assert.False(nulls3.Equals(first)); 2311Assert.False(nulls4.Equals(first)); 2319Assert.False(first.Equals(nullObj)); 2329Assert.False(first.Equals(second1)); 2330Assert.False(first.Equals(second2)); 2331Assert.False(first.Equals(second3)); 2332Assert.False(first.Equals(second4)); 2334Assert.False(second1.Equals(first)); 2335Assert.False(second2.Equals(first)); 2336Assert.False(second3.Equals(first)); 2337Assert.False(second4.Equals(first));
CodeGen\CodeGenDeconstructTests.cs (1)
5001Assert.False(nodes.Any(n => n.Kind() == SyntaxKind.SimpleAssignmentExpression));
CodeGen\CodeGenDynamicTests.cs (1)
603Assert.False(field.IsReadOnly);
CodeGen\CodeGenFunctionPointersTests.cs (6)
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));
CodeGen\CodeGenInterpolatedString.cs (2)
48Assert.False(string.IsNullOrEmpty(token.Text)); 49Assert.False(string.IsNullOrEmpty(token.ValueText));
CodeGen\CodeGenLocalFunctionTests.cs (3)
5777Assert.False(importData.SetLastError); 5778Assert.False(importData.ExactSpelling); 6171Assert.False(synthesizedParam.IsMetadataIn);
CodeGen\CodeGenOverridingAndHiding.cs (1)
4139Assert.False(parameter.IsParamsCollection);
CodeGen\CodeGenReadonlyStructTests.cs (18)
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);
CodeGen\CodeGenTupleEqualityTests.cs (1)
692Assert.False(model.GetConstantValue(tuple2).HasValue);
CodeGen\CodeGenTupleTest.cs (100)
495Assert.False(((NamedTypeSymbol)typeArg).IsSerializable); 850Assert.False(((NamedTypeSymbol)tooFewNames.Type).IsSerializable); 3355Assert.False(mTuple.IsImplicitlyDeclared); 3358Assert.False(mTuple.TupleData.UnderlyingDefinitionToMemberMap.Any()); 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); 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); 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)); 11262Assert.False(m2Item1.IsDefinition); 11270Assert.False(m2Tuple.IsDefinition); 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)); 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))); 11999Assert.False(m4h4.IsImplicitlyDeclared); 12228Assert.False(m5Item8.IsImplicitlyDeclared); 12617Assert.False(m8Item1.IsImplicitlyDeclared); 12778Assert.False(m1Tuple.Equals(m2Tuple)); 12779Assert.False(m1Tuple.Equals(m6Tuple)); 12780Assert.False(m6Tuple.Equals(m2Tuple)); 12847Assert.False(m2a2.IsImplicitlyDeclared); 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); 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); 28332Assert.False(namedType.IsTupleType); 28410Assert.All(fields, f => Assert.False(f.HasUseSiteError)); 28568Assert.False(field.IsTupleElement()); 28569Assert.False(field.IsDefaultTupleElement);
CodeGen\EventTests.cs (2)
719Assert.False((addMethod.ImplementationAttributes & System.Reflection.MethodImplAttributes.Synchronized) == 0); 722Assert.False((removeMethod.ImplementationAttributes & System.Reflection.MethodImplAttributes.Synchronized) == 0);
CodeGen\WinMdDelegateTests.cs (1)
264Assert.False(isWinRt(fieldSymbol));
Emit\CompilationEmitTests.cs (15)
161Assert.False(emitResult.Success); 2703Assert.False(libComp.GetDiagnostics().Any()); 2760Assert.False(exeComp.GetDiagnostics().Any()); 3378Assert.False(emitResult.Success); 3531Assert.False(peHeaders.IsExe); 3532Assert.False(peHeaders.CoffHeader.Characteristics.HasFlag(Characteristics.LargeAddressAware)); 3565Assert.False(peHeaders.IsExe); 3615Assert.False(peHeaders.IsExe); 3655Assert.False(peHeaders.IsDll); 3695Assert.False(peHeaders.IsDll); 4066Assert.False(peReader.IsAssembly); 4239Assert.False(result.Success); 5459Assert.False(result.Success); 5481Assert.False(result.Success); 5599Assert.False(emitResult.Success);
Emit\DeterministicTests.cs (1)
87Assert.False(resultDeterministic.Success);
Emit\EmitErrorTests.cs (1)
243Assert.False(result.Success);
Emit\EmitMetadataTests.cs (36)
364Assert.False(i3.Interfaces().Any()); 365Assert.False(i4.Interfaces().Any()); 367Assert.False(i6.Interfaces().Any()); 368Assert.False(i7.Interfaces().Any()); 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); 1106Assert.False(propertyQ.IsReadOnly); 1107Assert.False(propertyQ.IsWriteOnly); 1110Assert.False(propertyP.MustCallMethodsDirectly); 1111Assert.False(propertyQ.MustCallMethodsDirectly); 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); 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 (1)
4568Assert.False(modifier.IsOptional);
Emit\ResourceTests.cs (2)
780Assert.False(result.Success); 807Assert.False(result.Success);
Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (13)
Emit\EditAndContinue\EditAndContinueTests.cs (4)
12515Assert.False(result.Success); 12531Assert.False(result.Success); 12547Assert.False(result.Success); 12603Assert.False(result.Success);
Emit\LocalStateTracing\LocalStateTracingTests.cs (1)
519Assert.False(actualIL.Contains(TrackerTypeName + ".Log"));
Emit\NumericIntPtrTests.cs (3)
3539Assert.False(IsNoConversion(expectedConversions)); 10404Assert.False(type.IsNativeIntegerWrapperType); 11207Assert.False(symbol.IsNativeIntegerType);
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 (827)
Attributes\AttributeTests.cs (9)
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)); 10039Assert.False(emitResult2.Success); 10053Assert.False(emitResult3.Success);
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. 1790Assert.False(token.IsNil); //could the type ref be located? If not then the attribute's not there.
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 (7)
638Assert.False(hasClassLayout); 640Assert.False(badLayout); 646Assert.False(hasClassLayout); 655Assert.False(badLayout); 663Assert.False(badLayout); 668Assert.False(hasClassLayout); 670Assert.False(badLayout);
Attributes\AttributeTests_WellKnownAttributes.cs (13)
3433Assert.False(MetadataValidation.FindCustomAttribute(metadataReader, "DefaultCharSetAttribute").IsNil); 3465Assert.False(MetadataValidation.FindCustomAttribute(metadataReader, "DefaultCharSetAttribute").IsNil); 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);
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);
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 (27)
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); 1725Assert.False(importData.SetLastError); 1726Assert.False(importData.ExactSpelling); 1954Assert.False(cImpl.IsPartialDefinition); 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 (2)
101Assert.False(method.HasUnsupportedMetadata); 102Assert.False(method.HasUseSiteError);
RefStructInterfacesTests.cs (72)
223Assert.False(propertySymbol.HasUnscopedRefAttribute); 248Assert.False(propertySymbol.HasUnscopedRefAttribute); 274Assert.False(propertySymbol.HasUnscopedRefAttribute); 312Assert.False(propertySymbol.HasUnscopedRefAttribute); 352Assert.False(propertySymbol.HasUnscopedRefAttribute); 380Assert.False(propertySymbol.HasUnscopedRefAttribute); 470Assert.False(propertySymbol.HasUnscopedRefAttribute); 495Assert.False(propertySymbol.IsStatic); 522Assert.False(propertySymbol.HasUnscopedRefAttribute); 560Assert.False(propertySymbol.HasUnscopedRefAttribute); 600Assert.False(propertySymbol.HasUnscopedRefAttribute); 628Assert.False(propertySymbol.IsStatic); 629Assert.False(propertySymbol.HasUnscopedRefAttribute); 1121Assert.False(propertySymbol.HasUnscopedRefAttribute); 1177Assert.False(propertySymbol.HasUnscopedRefAttribute); 1223Assert.False(c1P.HasUnscopedRefAttribute); 1226Assert.False(c2P.HasUnscopedRefAttribute); 1229Assert.False(c3P.HasUnscopedRefAttribute); 1289Assert.False(propertySymbol.HasUnscopedRefAttribute); 1311Assert.False(propertySymbol.HasUnscopedRefAttribute); 1458Assert.False(propertySymbol.HasUnscopedRefAttribute); 1478Assert.False(propertySymbol.HasUnscopedRefAttribute); 1697Assert.False(propertySymbol.HasUnscopedRefAttribute); 1753Assert.False(propertySymbol.HasUnscopedRefAttribute); 1799Assert.False(c1P.HasUnscopedRefAttribute); 1802Assert.False(c2P.HasUnscopedRefAttribute); 1805Assert.False(c3P.HasUnscopedRefAttribute); 1865Assert.False(propertySymbol.HasUnscopedRefAttribute); 1887Assert.False(propertySymbol.HasUnscopedRefAttribute); 2034Assert.False(propertySymbol.HasUnscopedRefAttribute); 2054Assert.False(propertySymbol.HasUnscopedRefAttribute); 4401Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefLikeGenerics)); 4408Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefLikeGenerics)); 7579Assert.False(info.IsAsynchronous); 7769Assert.False(info.IsAsynchronous); 7989Assert.False(info.IsAsynchronous); 8179Assert.False(info.IsAsynchronous); 8372Assert.False(info.IsAsynchronous); 8447Assert.False(info.IsAsynchronous); 8651Assert.False(info.IsAsynchronous); 9022Assert.False(info.IsAsynchronous); 9226Assert.False(info.IsAsynchronous); 9319Assert.False(moveNextIsPublic); 9390Assert.False(info.IsAsynchronous); 9590Assert.False(info.IsAsynchronous); 9814Assert.False(info.IsAsynchronous); 10023Assert.False(info.IsAsynchronous); 10250Assert.False(info.IsAsynchronous); 10353Assert.False(info.IsAsynchronous); 10448Assert.False(info.IsAsynchronous); 10633Assert.False(info.IsAsynchronous); 10830Assert.False(info.IsAsynchronous); 11071Assert.False(info.IsAsynchronous); 11298Assert.False(info.IsAsynchronous); 11510Assert.False(info.IsAsynchronous); 11610Assert.False(info.IsAsynchronous); 11705Assert.False(info.IsAsynchronous); 15738Assert.False(info.IsAsynchronous); 17766Assert.False(info.IsAsynchronous); 17963Assert.False(info.IsAsynchronous); 18187Assert.False(info.IsAsynchronous); 18383Assert.False(info.IsAsynchronous); 18584Assert.False(info.IsAsynchronous); 18658Assert.False(info.IsAsynchronous); 18868Assert.False(info.IsAsynchronous); 19203Assert.False(info.IsAsynchronous); 19374Assert.False(info.IsAsynchronous); 19460Assert.False(moveNextIsPublic); 19531Assert.False(info.IsAsynchronous); 19699Assert.False(info.IsAsynchronous); 19867Assert.False(info.IsAsynchronous); 19972Assert.False(info.IsAsynchronous);
Semantics\CollectionExpressionTests.cs (33)
5101Assert.False(elementType.HasType); 14248Assert.False(conversion.IsCollectionExpression); 14253Assert.False(underlyingConversion.IsNullable); 14324Assert.False(conversion.IsCollectionExpression); 14329Assert.False(underlyingConversion.IsNullable); 14395Assert.False(conversion.IsValid); 14668Assert.False(conversion.IsIdentity); 14757Assert.False(conversion.IsIdentity); 14763Assert.False(underlyingConversion.IsNullable); 19403Assert.False(collectionType.HasCollectionBuilderAttribute(out _, out _)); 19407Assert.False(originalType.HasCollectionBuilderAttribute(out _, out _)); 28633Assert.False(conversion1.IsValid); 28677Assert.False(conversion1.IsValid); 28767Assert.False(conversion1.IsValid); 28810Assert.False(conversion1.IsValid); 28853Assert.False(conversion.IsValid); 28893Assert.False(conversion.IsValid); 28959Assert.False(conversion1.IsValid); 28979Assert.False(conversion4.IsValid); 29012Assert.False(conversion1.IsValid); 29032Assert.False(conversion4.IsValid); 29078Assert.False(conversion1.IsValid); 29081Assert.False(conversion2.IsValid); 29088Assert.False(conversion3.IsValid); 29095Assert.False(conversion4.IsValid); 29139Assert.False(conversion1.IsValid); 29142Assert.False(conversion2.IsValid); 29149Assert.False(conversion3.IsValid); 29156Assert.False(conversion4.IsValid); 29215Assert.False(conversion1.IsValid); 29263Assert.False(conversion2.IsValid); 29305Assert.False(conversion.IsValid); 30145Assert.False(elementType.HasType);
Semantics\ExtensionOperatorsTests.cs (8)
532Assert.False(method.IsExtensionMethod); 533Assert.False(method.HasSpecialName); 534Assert.False(method.HasRuntimeSpecialName); 535Assert.False(method.HasUnsupportedMetadata); 10464Assert.False(method.IsExtensionMethod); 10465Assert.False(method.HasSpecialName); 10466Assert.False(method.HasRuntimeSpecialName); 10467Assert.False(method.HasUnsupportedMetadata);
Semantics\ExtensionTests.cs (43)
61Assert.False(symbol.IsValueType); 62Assert.False(symbol.IsAnonymousType); 63Assert.False(symbol.IsTupleType); 64Assert.False(symbol.IsNativeIntegerType); 66Assert.False(symbol.IsRefLikeType); 67Assert.False(symbol.IsUnmanagedType); 68Assert.False(symbol.IsReadOnly); 69Assert.False(symbol.IsRecord); 73Assert.False(symbol.IsScriptClass); 74Assert.False(symbol.IsImplicitClass); 75Assert.False(symbol.IsComImport); 76Assert.False(symbol.IsFileLocal); 80Assert.False(symbol.MightContainExtensionMethods); 83Assert.False(symbol.IsSerializable); 90Assert.False(symbol.IsStatic); 91Assert.False(symbol.IsVirtual); 92Assert.False(symbol.IsOverride); 93Assert.False(symbol.IsAbstract); 95Assert.False(symbol.IsExtern); 96Assert.False(symbol.IsImplicitlyDeclared); 97Assert.False(symbol.CanBeReferencedByName); 160Assert.False(symbol.IsGenericType); 161Assert.False(symbol.IsUnboundGenericType); 246Assert.False(symbol.IsUnboundGenericType); 328Assert.False(symbol.TypeParameters.Single().IsReferenceType); 357Assert.False(symbol.IsGenericType); 2571Assert.False(symbol.IsExtension); 2587Assert.False(symbol.IsExtension); 2603Assert.False(symbol.IsExtension); 3161Assert.False(parameter.IsParams); 4991Assert.False(implementation.HasSpecialName); 4992Assert.False(implementation.HasRuntimeSpecialName); 6446Assert.False(implementation.HasSpecialName); 6447Assert.False(implementation.HasRuntimeSpecialName); 7920Assert.False(implementation.IsExtensionMethod); 7921Assert.False(implementation.HasSpecialName); 7922Assert.False(implementation.HasRuntimeSpecialName); 9426Assert.False(implementation.IsExtensionMethod); 9427Assert.False(implementation.HasSpecialName); 9428Assert.False(implementation.HasRuntimeSpecialName); 9715Assert.False(implementation.IsExtensionMethod); 9716Assert.False(implementation.HasSpecialName); 9717Assert.False(implementation.HasRuntimeSpecialName);
Semantics\ExtensionTests2.cs (5)
3492Assert.False(comp.GetTypeByMetadataName("E").GetTypeMembers().Single().IsExtension); 3538Assert.False(comp.GetTypeByMetadataName("E").GetTypeMembers().Single().IsExtension); 3582Assert.False(comp.GetTypeByMetadataName("E").GetTypeMembers().Single().IsExtension); 3626Assert.False(comp.GetTypeByMetadataName("E").GetTypeMembers().Single().IsExtension); 3675Assert.False(comp.GetTypeByMetadataName("E").GetTypeMembers().Single().IsExtension);
Semantics\InlineArrayTests.cs (5)
18196Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.InlineArrayTypes)); 18199Assert.False(vbComp.SupportsRuntimeCapability(RuntimeCapability.InlineArrayTypes)); 18595Assert.False(forEachInfo.IsAsynchronous); 18921Assert.False(forEachInfo.IsAsynchronous); 19258Assert.False(forEachInfo.IsAsynchronous);
Semantics\OutVarTests.cs (39)
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()); 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 (9)
4342Assert.False(parameter.IsParams); 4343Assert.False(parameter.IsParamsArray); 4344Assert.False(parameter.IsParamsCollection); 4348Assert.False(parameter.IsParams); 4349Assert.False(parameter.IsParamsArray); 4350Assert.False(parameter.IsParamsCollection); 9036Assert.False(module.FindTargetAttribute(p1.Handle, AttributeDescription.ScopedRefAttribute).HasValue); 9039Assert.False(expectUnscopedRefAttribute); 9044Assert.False(true);
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 (20)
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 (27)
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 _)); 30271Assert.False(compA.SupportsRuntimeCapability(RuntimeCapability.CovariantReturnsOfClasses));
Symbols\UserDefinedCompoundAssignmentOperatorsTests.cs (383)
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); 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); 7970Assert.False(m.IsStatic); 7971Assert.False(m.IsAbstract); 7973Assert.False(m.IsSealed); 7974Assert.False(m.IsOverride); 7976Assert.False(m.HasRuntimeSpecialName); 8015Assert.False(CompoundAssignmentOperatorHasCheckedForm(op)); 8048Assert.False(m.IsStatic); 8049Assert.False(m.IsAbstract); 8051Assert.False(m.IsSealed); 8052Assert.False(m.IsOverride); 8054Assert.False(m.HasRuntimeSpecialName); 8113Assert.False(m.IsStatic); 8114Assert.False(m.IsAbstract); 8116Assert.False(m.IsSealed); 8117Assert.False(m.IsOverride); 8119Assert.False(m.HasRuntimeSpecialName); 8224Assert.False(m.IsStatic); 8226Assert.False(m.IsVirtual); 8227Assert.False(m.IsSealed); 8228Assert.False(m.IsOverride); 8230Assert.False(m.HasRuntimeSpecialName); 8388Assert.False(m.IsStatic); 8390Assert.False(m.IsVirtual); 8391Assert.False(m.IsSealed); 8392Assert.False(m.IsOverride); 8394Assert.False(m.HasRuntimeSpecialName); 8474Assert.False(m.IsStatic); 8476Assert.False(m.IsVirtual); 8477Assert.False(m.IsSealed); 8478Assert.False(m.IsOverride); 8480Assert.False(m.HasRuntimeSpecialName); 8547Assert.False(m.IsStatic); 8548Assert.False(m.IsAbstract); 8549Assert.False(m.IsVirtual); 8550Assert.False(m.IsSealed); 8551Assert.False(m.IsOverride); 8552Assert.False(m.HasSpecialName); 8553Assert.False(m.HasRuntimeSpecialName); 8633Assert.False(m.IsStatic); 8634Assert.False(m.IsAbstract); 8635Assert.False(m.IsVirtual); 8636Assert.False(m.IsSealed); 8637Assert.False(m.IsOverride); 8638Assert.False(m.HasSpecialName); 8639Assert.False(m.HasRuntimeSpecialName); 8696Assert.False(m.IsStatic); 8697Assert.False(m.IsAbstract); 8698Assert.False(m.IsVirtual); 8699Assert.False(m.IsSealed); 8707Assert.False(m.IsOverride); 8709Assert.False(m.HasRuntimeSpecialName); 8765Assert.False(m.IsStatic); 8767Assert.False(m.IsVirtual); 8769Assert.False(m.IsOverride); 8770Assert.False(m.HasSpecialName); 8771Assert.False(m.HasRuntimeSpecialName); 9041Assert.False(m.IsStatic); 9042Assert.False(m.IsAbstract); 9044Assert.False(m.IsSealed); 9045Assert.False(m.IsOverride); 9047Assert.False(m.HasRuntimeSpecialName); 9087Assert.False(m.IsStatic); 9088Assert.False(m.IsAbstract); 9090Assert.False(m.IsSealed); 9091Assert.False(m.IsOverride); 9093Assert.False(m.HasRuntimeSpecialName); 9160Assert.False(m.IsStatic); 9161Assert.False(m.IsAbstract); 9162Assert.False(m.IsVirtual); 9163Assert.False(m.IsSealed); 9164Assert.False(m.IsOverride); 9165Assert.False(m.HasSpecialName); 9166Assert.False(m.HasRuntimeSpecialName); 9224Assert.False(m.IsStatic); 9225Assert.False(m.IsAbstract); 9226Assert.False(m.IsVirtual); 9227Assert.False(m.IsSealed); 9228Assert.False(m.IsOverride); 9229Assert.False(m.HasSpecialName); 9230Assert.False(m.HasRuntimeSpecialName); 9287Assert.False(m.IsStatic); 9288Assert.False(m.IsAbstract); 9289Assert.False(m.IsVirtual); 9290Assert.False(m.IsSealed); 9298Assert.False(m.IsOverride); 9300Assert.False(m.HasRuntimeSpecialName); 9573Assert.False(m.IsStatic); 9574Assert.False(m.IsAbstract); 9575Assert.False(m.IsVirtual); 9576Assert.False(m.IsSealed); 9579Assert.False(m.HasRuntimeSpecialName); 9622Assert.False(m.IsStatic); 9623Assert.False(m.IsAbstract); 9624Assert.False(m.IsVirtual); 9625Assert.False(m.IsSealed); 9628Assert.False(m.HasRuntimeSpecialName); 9680Assert.False(m.IsStatic); 9682Assert.False(m.IsVirtual); 9683Assert.False(m.IsSealed); 9686Assert.False(m.HasRuntimeSpecialName); 9739Assert.False(m.IsStatic); 9741Assert.False(m.IsVirtual); 9742Assert.False(m.IsSealed); 9745Assert.False(m.HasRuntimeSpecialName); 9786Assert.False(m.IsStatic); 9787Assert.False(m.IsAbstract); 9788Assert.False(m.IsVirtual); 9789Assert.False(m.IsSealed); 9792Assert.False(m.HasRuntimeSpecialName); 9822Assert.False(m.IsStatic); 9823Assert.False(m.IsAbstract); 9824Assert.False(m.IsVirtual); 9825Assert.False(m.IsSealed); 9828Assert.False(m.HasRuntimeSpecialName); 10015Assert.False(m.IsStatic); 10016Assert.False(m.IsAbstract); 10017Assert.False(m.IsVirtual); 10018Assert.False(m.IsSealed); 10019Assert.False(m.IsOverride); 10021Assert.False(m.HasRuntimeSpecialName); 10064Assert.False(m.IsStatic); 10065Assert.False(m.IsAbstract); 10066Assert.False(m.IsVirtual); 10067Assert.False(m.IsSealed); 10068Assert.False(m.IsOverride); 10070Assert.False(m.HasRuntimeSpecialName); 10121Assert.False(m.IsStatic); 10122Assert.False(m.IsAbstract); 10123Assert.False(m.IsVirtual); 10127Assert.False(m.HasRuntimeSpecialName); 10178Assert.False(m.IsStatic); 10179Assert.False(m.IsAbstract); 10180Assert.False(m.IsVirtual); 10184Assert.False(m.HasRuntimeSpecialName); 10757Assert.False(m.IsStatic); 10758Assert.False(m.IsAbstract); 10760Assert.False(m.IsSealed); 10761Assert.False(m.IsOverride); 10763Assert.False(m.HasRuntimeSpecialName); 10804Assert.False(m.IsStatic); 10805Assert.False(m.IsAbstract); 10807Assert.False(m.IsSealed); 10808Assert.False(m.IsOverride); 10810Assert.False(m.HasRuntimeSpecialName); 10858Assert.False(m.IsStatic); 10859Assert.False(m.IsAbstract); 10860Assert.False(m.IsVirtual); 10861Assert.False(m.IsSealed); 10862Assert.False(m.IsOverride); 10864Assert.False(m.HasRuntimeSpecialName); 10905Assert.False(m.IsStatic); 10906Assert.False(m.IsAbstract); 10907Assert.False(m.IsVirtual); 10908Assert.False(m.IsSealed); 10909Assert.False(m.IsOverride); 10911Assert.False(m.HasRuntimeSpecialName); 10959Assert.False(m.IsStatic); 10960Assert.False(m.IsAbstract); 10961Assert.False(m.IsVirtual); 10962Assert.False(m.IsSealed); 10963Assert.False(m.IsOverride); 10965Assert.False(m.HasRuntimeSpecialName); 11006Assert.False(m.IsStatic); 11007Assert.False(m.IsAbstract); 11008Assert.False(m.IsVirtual); 11009Assert.False(m.IsSealed); 11010Assert.False(m.IsOverride); 11012Assert.False(m.HasRuntimeSpecialName); 11128Assert.False(m.IsStatic); 11129Assert.False(m.IsAbstract); 11131Assert.False(m.IsSealed); 11132Assert.False(m.IsOverride); 11134Assert.False(m.HasRuntimeSpecialName); 11163Assert.False(m.IsStatic); 11164Assert.False(m.IsAbstract); 11166Assert.False(m.IsSealed); 11167Assert.False(m.IsOverride); 11169Assert.False(m.HasRuntimeSpecialName); 11203Assert.False(m.IsStatic); 11205Assert.False(m.IsVirtual); 11206Assert.False(m.IsSealed); 11207Assert.False(m.IsOverride); 11209Assert.False(m.HasRuntimeSpecialName); 11239Assert.False(m.IsStatic); 11241Assert.False(m.IsVirtual); 11242Assert.False(m.IsSealed); 11243Assert.False(m.IsOverride); 11245Assert.False(m.HasRuntimeSpecialName); 11280Assert.False(m.IsStatic); 11281Assert.False(m.IsAbstract); 11283Assert.False(m.IsSealed); 11284Assert.False(m.IsOverride); 11286Assert.False(m.HasRuntimeSpecialName); 11316Assert.False(m.IsStatic); 11317Assert.False(m.IsAbstract); 11319Assert.False(m.IsSealed); 11320Assert.False(m.IsOverride); 11322Assert.False(m.HasRuntimeSpecialName); 11357Assert.False(m.IsStatic); 11358Assert.False(m.IsAbstract); 11359Assert.False(m.IsVirtual); 11360Assert.False(m.IsSealed); 11361Assert.False(m.IsOverride); 11363Assert.False(m.HasRuntimeSpecialName); 11393Assert.False(m.IsStatic); 11394Assert.False(m.IsAbstract); 11395Assert.False(m.IsVirtual); 11396Assert.False(m.IsSealed); 11397Assert.False(m.IsOverride); 11399Assert.False(m.HasRuntimeSpecialName); 18443Assert.False(m.IsDeclaredReadOnly); 18474Assert.False(m.IsDeclaredReadOnly); 18565Assert.False(m.IsDeclaredReadOnly); 18592Assert.False(m.IsDeclaredReadOnly); 18694Assert.False(m.IsDeclaredReadOnly); 18719Assert.False(m.IsDeclaredReadOnly); 18828Assert.False(m.IsDeclaredReadOnly); 18860Assert.False(m.IsDeclaredReadOnly); 18934Assert.False(m.IsDeclaredReadOnly); 18935Assert.False(m.IsEffectivelyReadOnly); 18940Assert.False(m.IsDeclaredReadOnly); 18941Assert.False(m.IsEffectivelyReadOnly); 18946Assert.False(m.IsDeclaredReadOnly); 18947Assert.False(m.IsEffectivelyReadOnly); 18952Assert.False(m.IsDeclaredReadOnly); 18953Assert.False(m.IsEffectivelyReadOnly); 19009Assert.False(m.IsDeclaredReadOnly); 19010Assert.False(m.IsEffectivelyReadOnly); 19015Assert.False(m.IsDeclaredReadOnly); 19016Assert.False(m.IsEffectivelyReadOnly); 19021Assert.False(m.IsDeclaredReadOnly); 19022Assert.False(m.IsEffectivelyReadOnly); 19027Assert.False(m.IsDeclaredReadOnly); 19028Assert.False(m.IsEffectivelyReadOnly);
Microsoft.CodeAnalysis.CSharp.Features.UnitTests (6)
Diagnostics\Suppression\SuppressionTests.cs (3)
1136Assert.All(Regex.Split(expected, "\r?\n"), line => Assert.False(HasTrailingWhitespace(line))); 1169Assert.False(string.IsNullOrWhiteSpace(lines.First())); 1199Assert.False(string.IsNullOrWhiteSpace(lines[^2]));
EditAndContinue\BreakpointSpansTests.cs (1)
51Assert.False(hasBreakpoint);
EditAndContinue\SyntaxUtilitiesTests.cs (1)
204Assert.False(SyntaxUtilities.IsAsyncDeclaration(m3));
ExtractClass\ExtractClassTests.cs (1)
3141Assert.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 (6)
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 (1)
440Assert.False(state.GetVariable("x").IsReadOnly);
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (545)
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 (3)
1025Assert.False(anonymousMethod.IsStatic); 1026Assert.False(simpleLambda.IsStatic); 1027Assert.False(parenthesizedLambda.IsStatic);
Semantics\AwaitExpressionTests.cs (1)
264Assert.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 (4)
15716Assert.False(functionTypeStringNotNullable.Equals(functionTypeStringNullable, TypeCompareKind.ConsiderEverything)); 15717Assert.False(functionTypeNullA.Equals(functionTypeStringNullable, TypeCompareKind.AllIgnoreOptions)); 15718Assert.False(functionTypeStringNullable.Equals(functionTypeNullA, TypeCompareKind.AllIgnoreOptions)); 15720Assert.False(functionTypeNullA.Equals(functionTypeNullB, TypeCompareKind.ConsiderEverything));
Semantics\ExpressionBodiedMemberTests.cs (8)
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 (3)
357Assert.False(conversion.IsImplicit); 460Assert.False(conversion.IsImplicit); 510Assert.False(conversion.IsImplicit);
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\InitOnlyMemberTests.cs (12)
51Assert.False(publicProperty.GetMethod.IsInitOnly); 1463Assert.False(getter.IsInitOnly); 2524Assert.False(method.IsInitOnly); 3278Assert.False(property0.MustCallMethodsDirectly); 3375Assert.False(property1.HasUseSiteError); 3381Assert.False(property2.HasUseSiteError); 3582Assert.False(property0.HasUseSiteError); 3583Assert.False(property0.MustCallMethodsDirectly); 3637Assert.False(method.IsInitOnly); 3696Assert.False(method.IsInitOnly); 3820Assert.False(property0.HasUseSiteError); 4155Assert.False(method.IsInitOnly);
Semantics\InteractiveSemanticModelTests.cs (4)
169Assert.False(semanticInfo.IsCompileTimeConstant); 194Assert.False(semanticInfo.IsCompileTimeConstant); 220Assert.False(semanticInfo.IsCompileTimeConstant); 253Assert.False(semanticInfo.IsCompileTimeConstant);
Semantics\InterceptorsTests.cs (1)
7392Assert.False(locationSpecifier!.Equals(null));
Semantics\InterpolationTests.cs (1)
4617Assert.False(semanticInfo.ConstantValue.HasValue);
Semantics\LambdaDiscardParametersTests.cs (2)
571Assert.False(parameterSymbol1.IsDiscard); 575Assert.False(parameterSymbol2.IsDiscard);
Semantics\LambdaTests.cs (23)
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);
Semantics\LocalFunctionTests.cs (3)
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\NameOfTests.cs (1)
3063Assert.False(typeofType.IsDefinition);
Semantics\NativeIntegerTests.cs (30)
77Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 92Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 182Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 188Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 195Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.NumericIntPtr)); 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)); 1180Assert.False(type2.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 (56)
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)); 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, 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, 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, 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); 113189Assert.False(method1.Equals(method2, SymbolEqualityComparer.IncludeNullability.CompareKind)); 113190Assert.False(method2.Equals(method1, SymbolEqualityComparer.IncludeNullability.CompareKind)); 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)); 144375Assert.False(IsNullableAnalysisEnabled(comp, "C.M")); 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 (26)
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); 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 (1)
2918Assert.False(semanticInfo.ConstantValue.HasValue);
Semantics\ReadOnlyStructsTests.cs (8)
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); 1292Assert.False(((IMethodSymbol)reducedFrom).IsReadOnly);
Semantics\RecordStructTests.cs (20)
539Assert.False(type.IsRecord); 559Assert.False(type.IsRecord); 579Assert.False(type.IsRecord); 1839Assert.False(x.SetMethod!.IsInitOnly); 1843Assert.False(xBackingField.IsReadOnly); 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); 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 (3)
2238Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefFields)); 2254Assert.False(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefFields)); 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 (5)
16777Assert.False(comp.GetDiagnostics().Any()); 25169Assert.False(bSymbol.HasComplete(CompletionPart.MembersCompleted)); 25237Assert.False(aSymbol.HasComplete(CompletionPart.MembersCompleted)); 25240Assert.False(eSymbol.HasComplete(CompletionPart.MembersCompleted)); 25334Assert.False(bSymbol.HasComplete(CompletionPart.MembersCompleted));
Semantics\StructConstructorTests.cs (2)
3581Assert.False((bool)g1.Parameters[0].ExplicitDefaultValue); 3586Assert.False((bool)g2.Parameters[0].ExplicitDefaultValue);
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 (60)
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 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); 6185Assert.False(method.IsImplicitlyDeclared); 6461Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(globalStatement.Statement).IsEmpty); 6939Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(unit).IsEmpty); 7007Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(unit).IsEmpty); 7093Assert.False(mm.TestOnlyTryGetBoundNodesFromMap(node).IsEmpty); 7493Assert.False(entryPoint.ReturnsVoid); 7515Assert.False(entryPoint.ReturnsVoid); 7553Assert.False(entryPoint.ReturnsVoid); 7580Assert.False(entryPoint.ReturnsVoid); 7674Assert.False(entryPoint.ReturnsVoid); 7721Assert.False(entryPoint.ReturnsVoid); 7790Assert.False(entryPoint.ReturnsVoid); 7855Assert.False(entryPoint.ReturnsVoid); 7954Assert.False(entryPoint.ReturnsVoid); 7976Assert.False(entryPoint.ReturnsVoid); 8033Assert.False(entryPoint.ReturnsVoid); 8053Assert.False(entryPoint.ReturnsVoid); 9054Assert.False(entryPoint.CanBeReferencedByName); 9109Assert.False(entryPoint.CanBeReferencedByName); 9151Assert.False(entryPoint.CanBeReferencedByName);
Semantics\UnsafeTests.cs (27)
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\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 _)); 4173Assert.False(gen1Called); // Generator 1 did not re-run 4525Assert.False(initWasCalled); 4541Assert.False(stepRan); 4552Assert.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")); 1438Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1485Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1531Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1565Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1577Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1613Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1627Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1666Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1679Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1725Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1742Assert.False(runResult.TrackedSteps.ContainsKey("individualFileGlobalAliases_ForAttribute")); 1777Assert.False(runResult.TrackedSteps.ContainsKey("result_ForAttributeWithMetadataName")); 1790Assert.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"));
Utilities\ValueSetTests.cs (26)
359Assert.False(neg.Any(GreaterThan, double.MaxValue)); 367Assert.False(mi.Any(GreaterThan, 0.0)); 369Assert.False(mi.Any(GreaterThanOrEqual, 0.0)); 373Assert.False(i.Any(LessThan, 0.0)); 375Assert.False(i.Any(LessThanOrEqual, 0.0)); 388Assert.False(intersect.Any(Equal, "c")); 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));
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (2581)
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 (51)
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); 5412Assert.False(type.IsGenericType); 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 (24)
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); 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 (6)
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 (305)
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); 9207Assert.False((type as INamedTypeSymbol).IsUnboundGenericType); 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);
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 (15)
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()))); 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\CompilationCreationTests.cs (17)
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\CorTypes.cs (4)
97Assert.False(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 126Assert.False(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 172Assert.False(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 224Assert.False(msCorLibRef.KeepLookingForDeclaredSpecialTypes);
Symbols\CovariantReturnTests.cs (11)
264Assert.False(method.IsVirtual); 322Assert.False(setMethod.IsMetadataNewSlot(ignoreInterfaceImplementationChanges: true)); 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 (14)
149Assert.False(onMethod!.HasUnsupportedMetadata); 153Assert.False(onMethodReturn!.HasUnsupportedMetadata); 157Assert.False(onParameter!.HasUnsupportedMetadata); 163Assert.False(onField!.HasUnsupportedMetadata); 167Assert.False(onProperty!.HasUnsupportedMetadata); 171Assert.False(onPropertyGetter!.HasUnsupportedMetadata); 178Assert.False(onPropertySetter!.HasUnsupportedMetadata); 185Assert.False(onEvent!.HasUnsupportedMetadata); 189Assert.False(onEventAdder!.HasUnsupportedMetadata); 196Assert.False(onEventRemover!.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 (873)
2128Assert.False(result.IsAbstract); 2691Assert.False(accessor.IsAbstract); 2694Assert.False(accessor.IsSealed); 2696Assert.False(accessor.IsExtern); 2697Assert.False(accessor.IsAsync); 2698Assert.False(accessor.IsOverride); 5898Assert.False(p1.IsAbstract); 5899Assert.False(p3.IsAbstract); 5900Assert.False(p5.IsAbstract); 5901Assert.False(p7.IsAbstract); 6411Assert.False(accessor.IsAbstract); 6414Assert.False(accessor.IsSealed); 6416Assert.False(accessor.IsExtern); 6417Assert.False(accessor.IsAsync); 6418Assert.False(accessor.IsOverride); 9367Assert.False(m1.IsVirtual); 9369Assert.False(m1.IsSealed); 9371Assert.False(m1.IsExtern); 9372Assert.False(m1.IsAsync); 9373Assert.False(m1.IsOverride); 10904Assert.False(m1.IsAbstract); 10907Assert.False(m1.IsSealed); 10908Assert.False(m1.IsStatic); 10909Assert.False(m1.IsExtern); 10910Assert.False(m1.IsAsync); 10911Assert.False(m1.IsOverride); 12661Assert.False(m1.IsAbstract); 12664Assert.False(m1.IsSealed); 12665Assert.False(m1.IsStatic); 12666Assert.False(m1.IsExtern); 12667Assert.False(m1.IsAsync); 12668Assert.False(m1.IsOverride); 12749Assert.False(m1.IsAbstract); 12752Assert.False(m1.IsSealed); 12753Assert.False(m1.IsStatic); 12754Assert.False(m1.IsExtern); 12755Assert.False(m1.IsAsync); 12756Assert.False(m1.IsOverride); 12837Assert.False(m1.IsAbstract); 12840Assert.False(m1.IsSealed); 12841Assert.False(m1.IsStatic); 12842Assert.False(m1.IsExtern); 12843Assert.False(m1.IsAsync); 12844Assert.False(m1.IsOverride); 13132Assert.False(accessor.IsVirtual); 13134Assert.False(accessor.IsSealed); 13135Assert.False(accessor.IsStatic); 13136Assert.False(accessor.IsExtern); 13137Assert.False(accessor.IsAsync); 13138Assert.False(accessor.IsOverride); 13345Assert.False(accessor.IsAbstract); 13348Assert.False(accessor.IsSealed); 13349Assert.False(accessor.IsStatic); 13351Assert.False(accessor.IsAsync); 13352Assert.False(accessor.IsOverride); 13371Assert.False(accessor.IsVirtual); 13373Assert.False(accessor.IsSealed); 13374Assert.False(accessor.IsStatic); 13375Assert.False(accessor.IsExtern); 13376Assert.False(accessor.IsAsync); 13377Assert.False(accessor.IsOverride); 13396Assert.False(accessor.IsVirtual); 13398Assert.False(accessor.IsSealed); 13399Assert.False(accessor.IsStatic); 13400Assert.False(accessor.IsExtern); 13401Assert.False(accessor.IsAsync); 13402Assert.False(accessor.IsOverride); 13421Assert.False(accessor.IsVirtual); 13423Assert.False(accessor.IsSealed); 13424Assert.False(accessor.IsStatic); 13425Assert.False(accessor.IsExtern); 13426Assert.False(accessor.IsAsync); 13427Assert.False(accessor.IsOverride); 13446Assert.False(accessor.IsVirtual); 13448Assert.False(accessor.IsSealed); 13449Assert.False(accessor.IsStatic); 13450Assert.False(accessor.IsExtern); 13451Assert.False(accessor.IsAsync); 13452Assert.False(accessor.IsOverride); 13471Assert.False(accessor.IsVirtual); 13473Assert.False(accessor.IsSealed); 13474Assert.False(accessor.IsStatic); 13475Assert.False(accessor.IsExtern); 13476Assert.False(accessor.IsAsync); 13477Assert.False(accessor.IsOverride); 14012Assert.False(p1.IsVirtual); 14013Assert.False(p1.IsSealed); 14014Assert.False(p1.IsStatic); 14015Assert.False(p1.IsExtern); 14016Assert.False(p1.IsOverride); 14026Assert.False(accessor.IsVirtual); 14028Assert.False(accessor.IsSealed); 14029Assert.False(accessor.IsStatic); 14030Assert.False(accessor.IsExtern); 14031Assert.False(accessor.IsAsync); 14032Assert.False(accessor.IsOverride); 14099Assert.False(accessor.IsVirtual); 14101Assert.False(accessor.IsSealed); 14102Assert.False(accessor.IsStatic); 14103Assert.False(accessor.IsExtern); 14104Assert.False(accessor.IsAsync); 14105Assert.False(accessor.IsOverride); 14317Assert.False(accessor.IsAbstract); 14318Assert.False(accessor.IsVirtual); 14319Assert.False(accessor.IsMetadataVirtual()); 14320Assert.False(accessor.IsSealed); 14322Assert.False(accessor.IsExtern); 14323Assert.False(accessor.IsAsync); 14324Assert.False(accessor.IsOverride); 14636Assert.False(p1.IsAbstract); 14637Assert.False(p1.IsVirtual); 14638Assert.False(p1.IsSealed); 14639Assert.False(p1.IsStatic); 14640Assert.False(p1.IsExtern); 14641Assert.False(p1.IsOverride); 14666Assert.False(accessor.IsAbstract); 14667Assert.False(accessor.IsVirtual); 14668Assert.False(accessor.IsMetadataVirtual()); 14669Assert.False(accessor.IsSealed); 14670Assert.False(accessor.IsStatic); 14671Assert.False(accessor.IsExtern); 14672Assert.False(accessor.IsAsync); 14673Assert.False(accessor.IsOverride); 14741Assert.False(p1.IsVirtual); 14742Assert.False(p1.IsSealed); 14743Assert.False(p1.IsStatic); 14744Assert.False(p1.IsExtern); 14745Assert.False(p1.IsOverride); 14750Assert.False(p1get.IsVirtual); 14752Assert.False(p1get.IsSealed); 14753Assert.False(p1get.IsStatic); 14754Assert.False(p1get.IsExtern); 14755Assert.False(p1get.IsAsync); 14756Assert.False(p1get.IsOverride); 14763Assert.False(p2.IsAbstract); 14765Assert.False(p2.IsSealed); 14766Assert.False(p2.IsStatic); 14767Assert.False(p2.IsExtern); 14768Assert.False(p2.IsOverride); 14772Assert.False(p2get.IsAbstract); 14775Assert.False(p2get.IsSealed); 14776Assert.False(p2get.IsStatic); 14777Assert.False(p2get.IsExtern); 14778Assert.False(p2get.IsAsync); 14779Assert.False(p2get.IsOverride); 14785Assert.False(p3.IsAbstract); 14786Assert.False(p3.IsVirtual); 14788Assert.False(p3.IsStatic); 14789Assert.False(p3.IsExtern); 14790Assert.False(p3.IsOverride); 14798Assert.False(accessor.IsAbstract); 14799Assert.False(accessor.IsVirtual); 14800Assert.False(accessor.IsMetadataVirtual()); 14802Assert.False(accessor.IsStatic); 14803Assert.False(accessor.IsExtern); 14804Assert.False(accessor.IsAsync); 14805Assert.False(accessor.IsOverride); 14813Assert.False(p4.IsAbstract); 14814Assert.False(p4.IsVirtual); 14815Assert.False(p4.IsSealed); 14816Assert.False(p4.IsStatic); 14817Assert.False(p4.IsExtern); 14818Assert.False(p4.IsOverride); 14822Assert.False(p4get.IsAbstract); 14823Assert.False(p4get.IsVirtual); 14824Assert.False(p4get.IsMetadataVirtual()); 14825Assert.False(p4get.IsSealed); 14826Assert.False(p4get.IsStatic); 14827Assert.False(p4get.IsExtern); 14828Assert.False(p4get.IsAsync); 14829Assert.False(p4get.IsOverride); 15015Assert.False(p1.IsVirtual); 15016Assert.False(p1.IsSealed); 15017Assert.False(p1.IsStatic); 15018Assert.False(p1.IsExtern); 15019Assert.False(p1.IsOverride); 15026Assert.False(m1.IsVirtual); 15028Assert.False(m1.IsSealed); 15029Assert.False(m1.IsStatic); 15030Assert.False(m1.IsExtern); 15031Assert.False(m1.IsAsync); 15032Assert.False(m1.IsOverride); 16188Assert.False(p1.IsAbstract); 16189Assert.False(p1.IsVirtual); 16190Assert.False(p1.IsSealed); 16191Assert.False(p1.IsStatic); 16192Assert.False(p1.IsExtern); 16193Assert.False(p1.IsOverride); 16218Assert.False(accessor.IsAbstract); 16219Assert.False(accessor.IsVirtual); 16220Assert.False(accessor.IsMetadataVirtual()); 16221Assert.False(accessor.IsSealed); 16222Assert.False(accessor.IsStatic); 16223Assert.False(accessor.IsExtern); 16224Assert.False(accessor.IsAsync); 16225Assert.False(accessor.IsOverride); 16318Assert.False(p1.IsAbstract); 16319Assert.False(p1.IsVirtual); 16320Assert.False(p1.IsSealed); 16321Assert.False(p1.IsStatic); 16322Assert.False(p1.IsExtern); 16323Assert.False(p1.IsOverride); 16328Assert.False(p1get.IsAbstract); 16329Assert.False(p1get.IsVirtual); 16330Assert.False(p1get.IsMetadataVirtual()); 16331Assert.False(p1get.IsSealed); 16332Assert.False(p1get.IsStatic); 16333Assert.False(p1get.IsExtern); 16334Assert.False(p1get.IsAsync); 16335Assert.False(p1get.IsOverride); 16345Assert.False(p2.IsVirtual); 16347Assert.False(p2.IsStatic); 16348Assert.False(p2.IsExtern); 16349Assert.False(p2.IsOverride); 16355Assert.False(p2get.IsVirtual); 16358Assert.False(p2get.IsStatic); 16359Assert.False(p2get.IsExtern); 16360Assert.False(p2get.IsAsync); 16361Assert.False(p2get.IsOverride); 16370Assert.False(p3.IsAbstract); 16373Assert.False(p3.IsStatic); 16374Assert.False(p3.IsExtern); 16375Assert.False(p3.IsOverride); 16380Assert.False(p3set.IsAbstract); 16384Assert.False(p3set.IsStatic); 16385Assert.False(p3set.IsExtern); 16386Assert.False(p3set.IsAsync); 16387Assert.False(p3set.IsOverride); 16596Assert.False(p2.IsSealed); 16597Assert.False(p2.IsStatic); 16598Assert.False(p2.IsExtern); 16599Assert.False(p2.IsOverride); 16629Assert.False(accessor.IsSealed); 16630Assert.False(accessor.IsStatic); 16631Assert.False(accessor.IsExtern); 16632Assert.False(accessor.IsAsync); 16633Assert.False(accessor.IsOverride); 16784Assert.False(p1.IsAbstract); 16786Assert.False(p1.IsSealed); 16787Assert.False(p1.IsStatic); 16789Assert.False(p1.IsOverride); 16794Assert.False(p1get.IsAbstract); 16797Assert.False(p1get.IsSealed); 16798Assert.False(p1get.IsStatic); 16800Assert.False(p1get.IsAsync); 16801Assert.False(p1get.IsOverride); 16810Assert.False(p2.IsAbstract); 16812Assert.False(p2.IsSealed); 16813Assert.False(p2.IsStatic); 16815Assert.False(p2.IsOverride); 16820Assert.False(p2set.IsAbstract); 16823Assert.False(p2set.IsSealed); 16824Assert.False(p2set.IsStatic); 16826Assert.False(p2set.IsAsync); 16827Assert.False(p2set.IsOverride); 16838Assert.False(p3.IsAbstract); 16839Assert.False(p3.IsVirtual); 16840Assert.False(p3.IsSealed); 16843Assert.False(p3.IsOverride); 16852Assert.False(accessor.IsAbstract); 16853Assert.False(accessor.IsVirtual); 16854Assert.False(accessor.IsMetadataVirtual()); 16855Assert.False(accessor.IsSealed); 16858Assert.False(accessor.IsAsync); 16859Assert.False(accessor.IsOverride); 16869Assert.False(p4.IsAbstract); 16870Assert.False(p4.IsVirtual); 16871Assert.False(p4.IsSealed); 16872Assert.False(p4.IsStatic); 16874Assert.False(p4.IsOverride); 16879Assert.False(p4get.IsAbstract); 16880Assert.False(p4get.IsVirtual); 16881Assert.False(p4get.IsMetadataVirtual()); 16882Assert.False(p4get.IsSealed); 16883Assert.False(p4get.IsStatic); 16885Assert.False(p4get.IsAsync); 16886Assert.False(p4get.IsOverride); 16894Assert.False(p5.IsAbstract); 16895Assert.False(p5.IsVirtual); 16896Assert.False(p5.IsSealed); 16897Assert.False(p5.IsStatic); 16899Assert.False(p5.IsOverride); 16904Assert.False(p5set.IsAbstract); 16905Assert.False(p5set.IsVirtual); 16906Assert.False(p5set.IsMetadataVirtual()); 16907Assert.False(p5set.IsSealed); 16908Assert.False(p5set.IsStatic); 16910Assert.False(p5set.IsAsync); 16911Assert.False(p5set.IsOverride); 17028Assert.False(p1.IsVirtual); 17029Assert.False(p1.IsSealed); 17030Assert.False(p1.IsStatic); 17032Assert.False(p1.IsOverride); 17038Assert.False(p1get.IsVirtual); 17040Assert.False(p1get.IsSealed); 17041Assert.False(p1get.IsStatic); 17043Assert.False(p1get.IsAsync); 17044Assert.False(p1get.IsOverride); 17053Assert.False(p2.IsAbstract); 17055Assert.False(p2.IsSealed); 17056Assert.False(p2.IsStatic); 17058Assert.False(p2.IsOverride); 17063Assert.False(p2get.IsAbstract); 17066Assert.False(p2get.IsSealed); 17067Assert.False(p2get.IsStatic); 17069Assert.False(p2get.IsAsync); 17070Assert.False(p2get.IsOverride); 17078Assert.False(p3.IsAbstract); 17080Assert.False(p3.IsSealed); 17083Assert.False(p3.IsOverride); 17092Assert.False(accessor.IsAbstract); 17095Assert.False(accessor.IsSealed); 17098Assert.False(accessor.IsAsync); 17099Assert.False(accessor.IsOverride); 17107Assert.False(p4.IsAbstract); 17108Assert.False(p4.IsVirtual); 17109Assert.False(p4.IsSealed); 17110Assert.False(p4.IsStatic); 17112Assert.False(p4.IsOverride); 17121Assert.False(accessor.IsAbstract); 17122Assert.False(accessor.IsVirtual); 17123Assert.False(accessor.IsMetadataVirtual()); 17124Assert.False(accessor.IsSealed); 17125Assert.False(accessor.IsStatic); 17127Assert.False(accessor.IsAsync); 17128Assert.False(accessor.IsOverride); 17137Assert.False(p5.IsAbstract); 17138Assert.False(p5.IsVirtual); 17139Assert.False(p5.IsSealed); 17140Assert.False(p5.IsStatic); 17142Assert.False(p5.IsOverride); 17147Assert.False(p5get.IsAbstract); 17148Assert.False(p5get.IsVirtual); 17149Assert.False(p5get.IsMetadataVirtual()); 17150Assert.False(p5get.IsSealed); 17151Assert.False(p5get.IsStatic); 17153Assert.False(p5get.IsAsync); 17154Assert.False(p5get.IsOverride); 17277Assert.False(p1.IsVirtual); 17278Assert.False(p1.IsSealed); 17279Assert.False(p1.IsStatic); 17280Assert.False(p1.IsExtern); 17281Assert.False(p1.IsOverride); 17291Assert.False(accessor.IsVirtual); 17293Assert.False(accessor.IsSealed); 17294Assert.False(accessor.IsStatic); 17295Assert.False(accessor.IsExtern); 17296Assert.False(accessor.IsAsync); 17297Assert.False(accessor.IsOverride); 17308Assert.False(p2.IsVirtual); 17309Assert.False(p2.IsSealed); 17310Assert.False(p2.IsStatic); 17311Assert.False(p2.IsExtern); 17312Assert.False(p2.IsOverride); 17318Assert.False(p2get.IsVirtual); 17320Assert.False(p2get.IsSealed); 17321Assert.False(p2get.IsStatic); 17322Assert.False(p2get.IsExtern); 17323Assert.False(p2get.IsAsync); 17324Assert.False(p2get.IsOverride); 17332Assert.False(p3.IsAbstract); 17334Assert.False(p3.IsSealed); 17337Assert.False(p3.IsOverride); 17346Assert.False(accessor.IsAbstract); 17349Assert.False(accessor.IsSealed); 17352Assert.False(accessor.IsAsync); 17353Assert.False(accessor.IsOverride); 17363Assert.False(p4.IsVirtual); 17364Assert.False(p4.IsSealed); 17366Assert.False(p4.IsExtern); 17367Assert.False(p4.IsOverride); 17377Assert.False(accessor.IsVirtual); 17379Assert.False(accessor.IsSealed); 17381Assert.False(accessor.IsExtern); 17382Assert.False(accessor.IsAsync); 17383Assert.False(accessor.IsOverride); 17392Assert.False(p5.IsAbstract); 17393Assert.False(p5.IsVirtual); 17394Assert.False(p5.IsSealed); 17395Assert.False(p5.IsStatic); 17396Assert.False(p5.IsExtern); 17397Assert.False(p5.IsOverride); 17402Assert.False(p5get.IsAbstract); 17403Assert.False(p5get.IsVirtual); 17404Assert.False(p5get.IsMetadataVirtual()); 17405Assert.False(p5get.IsSealed); 17406Assert.False(p5get.IsStatic); 17407Assert.False(p5get.IsExtern); 17408Assert.False(p5get.IsAsync); 17409Assert.False(p5get.IsOverride); 17488Assert.False(p1.IsAbstract); 17490Assert.False(p1.IsSealed); 17491Assert.False(p1.IsStatic); 17492Assert.False(p1.IsExtern); 17493Assert.False(p1.IsOverride); 17499Assert.False(m1.IsAbstract); 17502Assert.False(m1.IsSealed); 17503Assert.False(m1.IsStatic); 17504Assert.False(m1.IsExtern); 17505Assert.False(m1.IsAsync); 17506Assert.False(m1.IsOverride); 17755Assert.False(p1.IsAbstract); 17757Assert.False(p1.IsSealed); 17758Assert.False(p1.IsStatic); 17759Assert.False(p1.IsExtern); 17760Assert.False(p1.IsOverride); 17777Assert.False(true); 17783Assert.False(accessor.IsAbstract); 17786Assert.False(accessor.IsSealed); 17787Assert.False(accessor.IsStatic); 17788Assert.False(accessor.IsExtern); 17789Assert.False(accessor.IsAsync); 17790Assert.False(accessor.IsOverride); 18345Assert.False(p1.IsSealed); 18346Assert.False(p1.IsStatic); 18347Assert.False(p1.IsExtern); 18348Assert.False(p1.IsOverride); 18383Assert.False(m1.IsSealed); 18384Assert.False(m1.IsStatic); 18385Assert.False(m1.IsExtern); 18386Assert.False(m1.IsAsync); 18387Assert.False(m1.IsOverride); 19869Assert.False(p1.IsAbstract); 19871Assert.False(p1.IsSealed); 19872Assert.False(p1.IsStatic); 19873Assert.False(p1.IsExtern); 19874Assert.False(p1.IsOverride); 19880Assert.False(m1.IsAbstract); 19883Assert.False(m1.IsSealed); 19884Assert.False(m1.IsStatic); 19885Assert.False(m1.IsExtern); 19886Assert.False(m1.IsAsync); 19887Assert.False(m1.IsOverride); 20538Assert.False(accessor.IsAbstract); 20539Assert.False(accessor.IsVirtual); 20540Assert.False(accessor.IsMetadataVirtual()); 20541Assert.False(accessor.IsSealed); 20543Assert.False(accessor.IsExtern); 20544Assert.False(accessor.IsAsync); 20545Assert.False(accessor.IsOverride); 21609Assert.False(accessor.IsVirtual); 21611Assert.False(accessor.IsSealed); 21612Assert.False(accessor.IsStatic); 21613Assert.False(accessor.IsExtern); 21614Assert.False(accessor.IsAsync); 21615Assert.False(accessor.IsOverride); 21822Assert.False(accessor.IsAbstract); 21825Assert.False(accessor.IsSealed); 21826Assert.False(accessor.IsStatic); 21828Assert.False(accessor.IsAsync); 21829Assert.False(accessor.IsOverride); 21848Assert.False(accessor.IsVirtual); 21850Assert.False(accessor.IsSealed); 21851Assert.False(accessor.IsStatic); 21852Assert.False(accessor.IsExtern); 21853Assert.False(accessor.IsAsync); 21854Assert.False(accessor.IsOverride); 21873Assert.False(accessor.IsVirtual); 21875Assert.False(accessor.IsSealed); 21876Assert.False(accessor.IsStatic); 21877Assert.False(accessor.IsExtern); 21878Assert.False(accessor.IsAsync); 21879Assert.False(accessor.IsOverride); 21898Assert.False(accessor.IsVirtual); 21900Assert.False(accessor.IsSealed); 21901Assert.False(accessor.IsStatic); 21902Assert.False(accessor.IsExtern); 21903Assert.False(accessor.IsAsync); 21904Assert.False(accessor.IsOverride); 21923Assert.False(accessor.IsVirtual); 21925Assert.False(accessor.IsSealed); 21926Assert.False(accessor.IsStatic); 21927Assert.False(accessor.IsExtern); 21928Assert.False(accessor.IsAsync); 21929Assert.False(accessor.IsOverride); 21948Assert.False(accessor.IsVirtual); 21950Assert.False(accessor.IsSealed); 21951Assert.False(accessor.IsStatic); 21952Assert.False(accessor.IsExtern); 21953Assert.False(accessor.IsAsync); 21954Assert.False(accessor.IsOverride); 26854Assert.False(accessor.IsVirtual); 26856Assert.False(accessor.IsSealed); 26857Assert.False(accessor.IsStatic); 26858Assert.False(accessor.IsExtern); 26859Assert.False(accessor.IsAsync); 26860Assert.False(accessor.IsOverride); 27069Assert.False(accessor.IsAbstract); 27072Assert.False(accessor.IsSealed); 27073Assert.False(accessor.IsStatic); 27075Assert.False(accessor.IsAsync); 27076Assert.False(accessor.IsOverride); 27096Assert.False(accessor.IsVirtual); 27098Assert.False(accessor.IsSealed); 27099Assert.False(accessor.IsStatic); 27100Assert.False(accessor.IsExtern); 27101Assert.False(accessor.IsAsync); 27102Assert.False(accessor.IsOverride); 27640Assert.False(p1.IsVirtual); 27641Assert.False(p1.IsSealed); 27642Assert.False(p1.IsStatic); 27643Assert.False(p1.IsExtern); 27644Assert.False(p1.IsOverride); 27654Assert.False(accessor.IsVirtual); 27656Assert.False(accessor.IsSealed); 27657Assert.False(accessor.IsStatic); 27658Assert.False(accessor.IsExtern); 27659Assert.False(accessor.IsAsync); 27660Assert.False(accessor.IsOverride); 27727Assert.False(accessor.IsVirtual); 27729Assert.False(accessor.IsSealed); 27730Assert.False(accessor.IsStatic); 27731Assert.False(accessor.IsExtern); 27732Assert.False(accessor.IsAsync); 27733Assert.False(accessor.IsOverride); 27827Assert.False(accessor.IsAbstract); 27828Assert.False(accessor.IsVirtual); 27829Assert.False(accessor.IsMetadataVirtual()); 27830Assert.False(accessor.IsSealed); 27832Assert.False(accessor.IsExtern); 27833Assert.False(accessor.IsAsync); 27834Assert.False(accessor.IsOverride); 27995Assert.False(accessor.IsVirtual); 27997Assert.False(accessor.IsSealed); 27999Assert.False(accessor.IsExtern); 28000Assert.False(accessor.IsAsync); 28001Assert.False(accessor.IsOverride); 28021Assert.False(accessor.IsAbstract); 28024Assert.False(accessor.IsSealed); 28026Assert.False(accessor.IsExtern); 28027Assert.False(accessor.IsAsync); 28028Assert.False(accessor.IsOverride); 28048Assert.False(accessor.IsAbstract); 28049Assert.False(accessor.IsVirtual); 28050Assert.False(accessor.IsMetadataVirtual()); 28051Assert.False(accessor.IsSealed); 28053Assert.False(accessor.IsExtern); 28054Assert.False(accessor.IsAsync); 28055Assert.False(accessor.IsOverride); 28142Assert.False(p1.IsAbstract); 28143Assert.False(p1.IsVirtual); 28144Assert.False(p1.IsSealed); 28145Assert.False(p1.IsStatic); 28146Assert.False(p1.IsExtern); 28147Assert.False(p1.IsOverride); 28156Assert.False(accessor.IsAbstract); 28157Assert.False(accessor.IsVirtual); 28158Assert.False(accessor.IsMetadataVirtual()); 28159Assert.False(accessor.IsSealed); 28160Assert.False(accessor.IsStatic); 28161Assert.False(accessor.IsExtern); 28162Assert.False(accessor.IsAsync); 28163Assert.False(accessor.IsOverride); 28239Assert.False(p1.IsVirtual); 28240Assert.False(p1.IsSealed); 28241Assert.False(p1.IsStatic); 28242Assert.False(p1.IsExtern); 28243Assert.False(p1.IsOverride); 28252Assert.False(accessor.IsVirtual); 28254Assert.False(accessor.IsSealed); 28255Assert.False(accessor.IsStatic); 28256Assert.False(accessor.IsExtern); 28257Assert.False(accessor.IsAsync); 28258Assert.False(accessor.IsOverride); 28265Assert.False(p2.IsAbstract); 28267Assert.False(p2.IsSealed); 28268Assert.False(p2.IsStatic); 28269Assert.False(p2.IsExtern); 28270Assert.False(p2.IsOverride); 28278Assert.False(accessor.IsAbstract); 28281Assert.False(accessor.IsSealed); 28282Assert.False(accessor.IsStatic); 28283Assert.False(accessor.IsExtern); 28284Assert.False(accessor.IsAsync); 28285Assert.False(accessor.IsOverride); 28292Assert.False(p3.IsAbstract); 28293Assert.False(p3.IsVirtual); 28295Assert.False(p3.IsStatic); 28296Assert.False(p3.IsExtern); 28297Assert.False(p3.IsOverride); 28305Assert.False(accessor.IsAbstract); 28306Assert.False(accessor.IsVirtual); 28307Assert.False(accessor.IsMetadataVirtual()); 28309Assert.False(accessor.IsStatic); 28310Assert.False(accessor.IsExtern); 28311Assert.False(accessor.IsAsync); 28312Assert.False(accessor.IsOverride); 28319Assert.False(p4.IsAbstract); 28320Assert.False(p4.IsVirtual); 28321Assert.False(p4.IsSealed); 28322Assert.False(p4.IsStatic); 28323Assert.False(p4.IsExtern); 28324Assert.False(p4.IsOverride); 28332Assert.False(accessor.IsAbstract); 28333Assert.False(accessor.IsVirtual); 28334Assert.False(accessor.IsMetadataVirtual()); 28335Assert.False(accessor.IsSealed); 28336Assert.False(accessor.IsStatic); 28337Assert.False(accessor.IsExtern); 28338Assert.False(accessor.IsAsync); 28339Assert.False(accessor.IsOverride); 28457Assert.False(p1.IsVirtual); 28458Assert.False(p1.IsSealed); 28459Assert.False(p1.IsStatic); 28460Assert.False(p1.IsExtern); 28461Assert.False(p1.IsOverride); 28468Assert.False(m1.IsVirtual); 28470Assert.False(m1.IsSealed); 28471Assert.False(m1.IsStatic); 28472Assert.False(m1.IsExtern); 28473Assert.False(m1.IsAsync); 28474Assert.False(m1.IsOverride); 29591Assert.False(p1.IsAbstract); 29592Assert.False(p1.IsVirtual); 29593Assert.False(p1.IsSealed); 29594Assert.False(p1.IsStatic); 29595Assert.False(p1.IsExtern); 29596Assert.False(p1.IsOverride); 29605Assert.False(accessor.IsAbstract); 29606Assert.False(accessor.IsVirtual); 29607Assert.False(accessor.IsMetadataVirtual()); 29608Assert.False(accessor.IsSealed); 29609Assert.False(accessor.IsStatic); 29610Assert.False(accessor.IsExtern); 29611Assert.False(accessor.IsAsync); 29612Assert.False(accessor.IsOverride); 29706Assert.False(p1.IsAbstract); 29707Assert.False(p1.IsVirtual); 29708Assert.False(p1.IsSealed); 29709Assert.False(p1.IsStatic); 29710Assert.False(p1.IsExtern); 29711Assert.False(p1.IsOverride); 29720Assert.False(accessor.IsAbstract); 29721Assert.False(accessor.IsVirtual); 29722Assert.False(accessor.IsMetadataVirtual()); 29723Assert.False(accessor.IsSealed); 29724Assert.False(accessor.IsStatic); 29725Assert.False(accessor.IsExtern); 29726Assert.False(accessor.IsAsync); 29727Assert.False(accessor.IsOverride); 29737Assert.False(p2.IsVirtual); 29739Assert.False(p2.IsStatic); 29740Assert.False(p2.IsExtern); 29741Assert.False(p2.IsOverride); 29751Assert.False(accessor.IsVirtual); 29754Assert.False(accessor.IsStatic); 29755Assert.False(accessor.IsExtern); 29756Assert.False(accessor.IsAsync); 29757Assert.False(accessor.IsOverride); 29766Assert.False(p3.IsAbstract); 29769Assert.False(p3.IsStatic); 29770Assert.False(p3.IsExtern); 29771Assert.False(p3.IsOverride); 29780Assert.False(accessor.IsAbstract); 29784Assert.False(accessor.IsStatic); 29785Assert.False(accessor.IsExtern); 29786Assert.False(accessor.IsAsync); 29787Assert.False(accessor.IsOverride); 30009Assert.False(p2.IsSealed); 30010Assert.False(p2.IsStatic); 30011Assert.False(p2.IsExtern); 30012Assert.False(p2.IsOverride); 30042Assert.False(accessor.IsSealed); 30043Assert.False(accessor.IsStatic); 30044Assert.False(accessor.IsExtern); 30045Assert.False(accessor.IsAsync); 30046Assert.False(accessor.IsOverride); 30119Assert.False(p1.IsAbstract); 30121Assert.False(p1.IsSealed); 30122Assert.False(p1.IsStatic); 30124Assert.False(p1.IsOverride); 30133Assert.False(accessor.IsAbstract); 30136Assert.False(accessor.IsSealed); 30137Assert.False(accessor.IsStatic); 30139Assert.False(accessor.IsAsync); 30140Assert.False(accessor.IsOverride); 30149Assert.False(p2.IsAbstract); 30151Assert.False(p2.IsSealed); 30152Assert.False(p2.IsStatic); 30154Assert.False(p2.IsOverride); 30163Assert.False(accessor.IsAbstract); 30166Assert.False(accessor.IsSealed); 30167Assert.False(accessor.IsStatic); 30169Assert.False(accessor.IsAsync); 30170Assert.False(accessor.IsOverride); 30179Assert.False(p3.IsAbstract); 30180Assert.False(p3.IsVirtual); 30181Assert.False(p3.IsSealed); 30184Assert.False(p3.IsOverride); 30193Assert.False(accessor.IsAbstract); 30194Assert.False(accessor.IsVirtual); 30195Assert.False(accessor.IsMetadataVirtual()); 30196Assert.False(accessor.IsSealed); 30199Assert.False(accessor.IsAsync); 30200Assert.False(accessor.IsOverride); 30208Assert.False(p4.IsAbstract); 30209Assert.False(p4.IsVirtual); 30210Assert.False(p4.IsSealed); 30211Assert.False(p4.IsStatic); 30213Assert.False(p4.IsOverride); 30222Assert.False(accessor.IsAbstract); 30223Assert.False(accessor.IsVirtual); 30224Assert.False(accessor.IsMetadataVirtual()); 30225Assert.False(accessor.IsSealed); 30226Assert.False(accessor.IsStatic); 30228Assert.False(accessor.IsAsync); 30229Assert.False(accessor.IsOverride); 30237Assert.False(p5.IsAbstract); 30238Assert.False(p5.IsVirtual); 30239Assert.False(p5.IsSealed); 30240Assert.False(p5.IsStatic); 30242Assert.False(p5.IsOverride); 30251Assert.False(accessor.IsAbstract); 30252Assert.False(accessor.IsVirtual); 30253Assert.False(accessor.IsMetadataVirtual()); 30254Assert.False(accessor.IsSealed); 30255Assert.False(accessor.IsStatic); 30257Assert.False(accessor.IsAsync); 30258Assert.False(accessor.IsOverride); 30450Assert.False(p1.IsVirtual); 30451Assert.False(p1.IsSealed); 30452Assert.False(p1.IsStatic); 30454Assert.False(p1.IsOverride); 30464Assert.False(accessor.IsVirtual); 30466Assert.False(accessor.IsSealed); 30467Assert.False(accessor.IsStatic); 30469Assert.False(accessor.IsAsync); 30470Assert.False(accessor.IsOverride); 30479Assert.False(p2.IsAbstract); 30481Assert.False(p2.IsSealed); 30482Assert.False(p2.IsStatic); 30484Assert.False(p2.IsOverride); 30493Assert.False(accessor.IsAbstract); 30496Assert.False(accessor.IsSealed); 30497Assert.False(accessor.IsStatic); 30499Assert.False(accessor.IsAsync); 30500Assert.False(accessor.IsOverride); 30509Assert.False(p3.IsAbstract); 30510Assert.False(p3.IsVirtual); 30511Assert.False(p3.IsSealed); 30514Assert.False(p3.IsOverride); 30523Assert.False(accessor.IsAbstract); 30524Assert.False(accessor.IsVirtual); 30525Assert.False(accessor.IsMetadataVirtual()); 30526Assert.False(accessor.IsSealed); 30529Assert.False(accessor.IsAsync); 30530Assert.False(accessor.IsOverride); 30538Assert.False(p4.IsAbstract); 30539Assert.False(p4.IsVirtual); 30540Assert.False(p4.IsSealed); 30541Assert.False(p4.IsStatic); 30543Assert.False(p4.IsOverride); 30552Assert.False(accessor.IsAbstract); 30553Assert.False(accessor.IsVirtual); 30554Assert.False(accessor.IsMetadataVirtual()); 30555Assert.False(accessor.IsSealed); 30556Assert.False(accessor.IsStatic); 30558Assert.False(accessor.IsAsync); 30559Assert.False(accessor.IsOverride); 30671Assert.False(p1.IsVirtual); 30672Assert.False(p1.IsSealed); 30673Assert.False(p1.IsStatic); 30674Assert.False(p1.IsExtern); 30675Assert.False(p1.IsOverride); 30685Assert.False(accessor.IsVirtual); 30687Assert.False(accessor.IsSealed); 30688Assert.False(accessor.IsStatic); 30689Assert.False(accessor.IsExtern); 30690Assert.False(accessor.IsAsync); 30691Assert.False(accessor.IsOverride); 30701Assert.False(p2.IsVirtual); 30702Assert.False(p2.IsSealed); 30703Assert.False(p2.IsStatic); 30704Assert.False(p2.IsExtern); 30705Assert.False(p2.IsOverride); 30715Assert.False(accessor.IsVirtual); 30717Assert.False(accessor.IsSealed); 30718Assert.False(accessor.IsStatic); 30719Assert.False(accessor.IsExtern); 30720Assert.False(accessor.IsAsync); 30721Assert.False(accessor.IsOverride); 30730Assert.False(p3.IsAbstract); 30731Assert.False(p3.IsVirtual); 30732Assert.False(p3.IsSealed); 30735Assert.False(p3.IsOverride); 30744Assert.False(accessor.IsAbstract); 30745Assert.False(accessor.IsVirtual); 30746Assert.False(accessor.IsMetadataVirtual()); 30747Assert.False(accessor.IsSealed); 30750Assert.False(accessor.IsAsync); 30751Assert.False(accessor.IsOverride); 30761Assert.False(p4.IsVirtual); 30762Assert.False(p4.IsSealed); 30764Assert.False(p4.IsExtern); 30765Assert.False(p4.IsOverride); 30775Assert.False(accessor.IsVirtual); 30777Assert.False(accessor.IsSealed); 30779Assert.False(accessor.IsExtern); 30780Assert.False(accessor.IsAsync); 30781Assert.False(accessor.IsOverride); 30789Assert.False(p5.IsAbstract); 30790Assert.False(p5.IsVirtual); 30791Assert.False(p5.IsSealed); 30792Assert.False(p5.IsStatic); 30793Assert.False(p5.IsExtern); 30794Assert.False(p5.IsOverride); 30803Assert.False(accessor.IsAbstract); 30804Assert.False(accessor.IsVirtual); 30805Assert.False(accessor.IsMetadataVirtual()); 30806Assert.False(accessor.IsSealed); 30807Assert.False(accessor.IsStatic); 30808Assert.False(accessor.IsExtern); 30809Assert.False(accessor.IsAsync); 30810Assert.False(accessor.IsOverride); 30893Assert.False(p1.IsAbstract); 30895Assert.False(p1.IsSealed); 30896Assert.False(p1.IsStatic); 30897Assert.False(p1.IsExtern); 30898Assert.False(p1.IsOverride); 30904Assert.False(m1.IsAbstract); 30907Assert.False(m1.IsSealed); 30908Assert.False(m1.IsStatic); 30909Assert.False(m1.IsExtern); 30910Assert.False(m1.IsAsync); 30911Assert.False(m1.IsOverride); 31246Assert.False(accessor.IsAbstract); 31247Assert.False(accessor.IsVirtual); 31248Assert.False(accessor.IsMetadataVirtual()); 31249Assert.False(accessor.IsSealed); 31251Assert.False(accessor.IsExtern); 31252Assert.False(accessor.IsAsync); 31253Assert.False(accessor.IsOverride); 33064Assert.False(m1.IsMetadataNewSlot()); 33066Assert.False(m1.IsVirtual); 33069Assert.False(m1.IsExtern); 33070Assert.False(m1.IsAsync); 33071Assert.False(m1.IsOverride); 33901Assert.False(m1.IsMetadataNewSlot()); 33902Assert.False(m1.IsAbstract); 33903Assert.False(m1.IsVirtual); 33904Assert.False(m1.IsSealed); 33907Assert.False(m1.IsAsync); 33908Assert.False(m1.IsOverride); 34017Assert.False(m1.IsMetadataNewSlot()); 34018Assert.False(m1.IsAbstract); 34019Assert.False(m1.IsVirtual); 34020Assert.False(m1.IsSealed); 34022Assert.False(m1.IsExtern); 34024Assert.False(m1.IsOverride); 37122Assert.False(m1.IsVirtual); 37125Assert.False(m1.IsExtern); 37126Assert.False(m1.IsOverride); 38013Assert.False(m1.IsAbstract); 38014Assert.False(m1.IsVirtual); 38015Assert.False(m1.IsSealed); 38018Assert.False(m1.IsOverride); 40155Assert.False(m1.IsVirtual); 40158Assert.False(m1.IsExtern); 40159Assert.False(m1.IsOverride); 51120Assert.False(m.IsMetadataNewSlot()); 51122Assert.False(m.IsVirtual); 51125Assert.False(m.IsExtern); 51126Assert.False(m.IsAsync); 51127Assert.False(m.IsOverride); 52564Assert.False(reabstracting.IsVirtual); 52567Assert.False(reabstracting.IsExtern); 52568Assert.False(reabstracting.IsOverride); 57528Assert.False(reabstracting.IsVirtual); 57531Assert.False(reabstracting.IsExtern); 57532Assert.False(reabstracting.IsOverride); 69406Assert.False(hasBeforeFieldInitFlag(module, "I4")); 69407Assert.False(hasBeforeFieldInitFlag(module, "I5")); 69408Assert.False(hasBeforeFieldInitFlag(module, "I6"));
Symbols\EnumTests.cs (1)
355Assert.False(value.HasValue);
Symbols\ExtendedPartialMethodsTests.cs (13)
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 (1)
2508Assert.False(sourceAssembly.MightContainExtensionMethods);
Symbols\FunctionPointerTypeSymbolTests.cs (18)
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)); 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 (26)
3418Assert.False(((NamedTypeSymbol)constraintType).IsSerializable); 3755Assert.False(i2.MangleName); 3789Assert.False(i2.MangleName); 3857Assert.False(i2.MangleName); 3906Assert.False(i2.MangleName); 3938Assert.False(t.MangleName); 3952Assert.False(t.MangleName); 3987Assert.False(t.MangleName); 3994Assert.False(t.MangleName); 4001Assert.False(t.MangleName); 4008Assert.False(t.MangleName); 4015Assert.False(t.MangleName); 4029Assert.False(t.MangleName); 4036Assert.False(t.MangleName); 4050Assert.False(t.MangleName); 4085Assert.False(t.MangleName); 4092Assert.False(t.MangleName); 4099Assert.False(t.MangleName); 4193Assert.False(t.MangleName); 4200Assert.False(t.MangleName); 4211Assert.False(t.MangleName); 4218Assert.False(t.MangleName); 4232Assert.False(t.MangleName); 4239Assert.False(t.MangleName); 4276Assert.False(t.MangleName); 4287Assert.False(t.MangleName);
Symbols\ImplicitClassTests.cs (3)
38Assert.False(implicitClass.IsSubmissionClass); 39Assert.False(implicitClass.IsScriptClass); 67Assert.False(scriptClass.IsSubmissionClass);
Symbols\InterfaceImplementationTests.cs (22)
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); 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());
Symbols\LocalFunctionTests.cs (2)
37Assert.False(local.IsStatic); 79Assert.False(local.IsStatic);
Symbols\Metadata\MetadataMemberTests.cs (35)
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());
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\HasUnsupportedMetadata.cs (10)
163Assert.False(c3.HasUnsupportedMetadata); 164Assert.False(c3.ContainingSymbol.HasUnsupportedMetadata); 168Assert.False(f1.HasUnsupportedMetadata); 172Assert.False(m1.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\LoadingFields.cs (25)
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);
Symbols\Metadata\PE\LoadingIndexers.cs (1)
1177Assert.False(classIndexer.IsIndexer);
Symbols\Metadata\PE\LoadingMethods.cs (100)
79Assert.False(localM3.ReturnsVoid); 83Assert.False(localM4.ReturnsVoid); 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()); 1244Assert.False(((MethodSymbol)m).IsVirtual); 1246Assert.False(((MethodSymbol)m).IsOverride);
Symbols\Metadata\PE\LoadingNamespacesAndTypes.cs (2)
144Assert.False(systemNS.IsGlobalNamespace); 157Assert.False(collectionsNS.IsGlobalNamespace);
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 (8)
309Assert.False(ambiguous.IsSerializable); 535Assert.False(missing.IsSerializable); 756Assert.False(pia1Ref.Properties.EmbedInteropTypes); 758Assert.False(pia5Ref.Properties.EmbedInteropTypes); 760Assert.False(library2Ref.Properties.EmbedInteropTypes); 1111Assert.False(pia5Ref.Properties.EmbedInteropTypes); 1119Assert.False(pia1Ref.Properties.EmbedInteropTypes); 1127Assert.False(library2Ref.Properties.EmbedInteropTypes);
Symbols\Metadata\PE\TypeForwarders.cs (1)
1693Assert.False(token.IsNil); //could the type ref be located? If not then the attribute's not there.
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 (23)
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\RequiredMembersTests.cs (2)
7180Assert.False(field2.IsRequired); 7181Assert.False(property2.IsRequired);
Symbols\Retargeting\RetargetCustomModifiers.cs (6)
121Assert.False(m7.ReturnsVoid); 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\Source\AccessTests.cs (1)
124Assert.False(comp.GetDeclarationDiagnostics().Any());
Symbols\Source\BaseClassTests.cs (1)
1041Assert.False(B2.IsSerializable);
Symbols\Source\CustomModifierCopyTests.cs (3)
484Assert.False(customModifiers.Any()); 552Assert.False(class3Method1.Parameters.Single().TypeWithAnnotations.CustomModifiers.Any()); 604Assert.False(@class.GetSynthesizedExplicitImplementations(CancellationToken.None).ForwardingMethods.Any());
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 (4)
132Assert.False(v.IsValueType); 134Assert.False(v.IsAbstract); 830Assert.False(lambda.ReturnsByRef); 837Assert.False(lambda.ReturnsByRef);
Symbols\Source\ExpressionBodiedMethodTests.cs (1)
49Assert.False(gooImpl.IsPartialDefinition);
Symbols\Source\FieldTests.cs (13)
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);
Symbols\Source\FileModifierTests.cs (6)
100Assert.False(((SourceMemberContainerTypeSymbol)classC).IsFileLocal); 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);
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 (106)
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); 2547Assert.False(partialImpl.IsPartialDefinition); 2580Assert.False(partialDefConstructed.IsPartialDefinition); 2585Assert.False(partialImpl.IsPartialDefinition); 2586Assert.False(partialImplConstructed.IsPartialDefinition);
Symbols\Source\NullablePublicAPITests.cs (2)
1748Assert.False(isNullableAnalysisEnabled(comp)); 2844Assert.False(event1.Equals(event2, SymbolEqualityComparer.IncludeNullability));
Symbols\Source\PropertyTests.cs (5)
721Assert.False(goodStatic.MustCallMethodsDirectly); 738Assert.False(goodInstance.MustCallMethodsDirectly); 2562Assert.False(property.MustCallMethodsDirectly); 2615Assert.False(comp.ExternalReferences[1].Properties.EmbedInteropTypes); 2633Assert.False(comp.ExternalReferences[1].Properties.EmbedInteropTypes);
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 (548)
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); 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); 5364Assert.False(compilation1.SupportsRuntimeCapability(RuntimeCapability.DefaultImplementationsOfInterfaces)); 5365Assert.False(compilation1.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 5380Assert.False(compilation2.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 5405Assert.False(compilation1.SupportsRuntimeCapability(RuntimeCapability.DefaultImplementationsOfInterfaces)); 5406Assert.False(compilation1.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 5421Assert.False(compilation2.SupportsRuntimeCapability(RuntimeCapability.VirtualStaticsInInterfaces)); 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()); 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()); 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); 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()); 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); 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()); 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); 27532Assert.False(c2M01.IsAbstract); 27533Assert.False(c2M01.IsVirtual); 27539Assert.False(c2M01Add.HasRuntimeSpecialName); 27545Assert.False(c2M01Remove.HasRuntimeSpecialName); 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()); 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()); 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); 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());
Symbols\SymbolDistinguisherTests.cs (2)
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)));
Symbols\SymbolEqualityTests.cs (10)
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 (1)
18515Assert.False(methods.Any(n => n.StartsWith("B..ctor", StringComparison.Ordinal))); // Haven't tried to emit it
Symbols\TypeTests.cs (1)
1861Assert.False(symbol.ContainingType.IsUnboundGenericType);
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)
146Assert.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)
2644Assert.False(tree.GetCompilationUnitRoot().ContainsDiagnostics); 2676Assert.False(tree.GetCompilationUnitRoot().ContainsDiagnostics); 9735Assert.False(shebang.HasStructuredTrivia); 9745Assert.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 (2)
Metadata\WinMdEventTests.cs (2)
3581Assert.False(addMethod.ReturnsVoid); 3604Assert.False(@event.IsWindowsRuntimeEvent);
Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (2)
CSharpSyntaxFactsServiceTests.cs (1)
217Assert.False(IsQueryKeyword(WrapInMethod(@"
EmbeddedLanguages\VirtualChars\CSharpVirtualCharServiceTests.cs (1)
51Assert.False(token.ContainsDiagnostics);
Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (2)
ExtractInterface\AbstractExtractInterfaceTests.cs (1)
114Assert.False(testState.Workspace.Documents.Select(d => d.Id).Contains(result.NavigationDocumentId));
RefactoringHelpers\RefactoringHelpersTestBase.cs (1)
57Assert.False(CodeRefactoringHelpers.IsNodeUnderselected(resultNode, selection));
Microsoft.CodeAnalysis.EditorFeatures.UnitTests (148)
CodeFixes\CodeFixServiceTests.cs (7)
135Assert.False(analyzerWithFix.ReceivedCallback); 136Assert.False(analyzerWithoutFix.ReceivedCallback); 147Assert.False(analyzerWithoutFix.ReceivedCallback); 172Assert.False(documentDiagnosticAnalyzer.ReceivedCallback); 208Assert.False(codeFix.Called); 301Assert.False(extensionManager.IsIgnored(codefix)); 323Assert.False(extensionManager.IsIgnored(codefix));
CodeRefactorings\CodeRefactoringServiceTest.cs (1)
112Assert.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)
643Assert.False(analyzer2.ReceivedSymbolCallback);
EditAndContinue\EditAndContinueLanguageServiceTests.cs (2)
138Assert.False(sessionState.IsSessionActive); 341Assert.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\ITextSnapshotLineExtensionsTests.cs (4)
162Assert.False(value); 169Assert.False(value); 176Assert.False(value); 183Assert.False(value);
Preview\PreviewWorkspaceTests.cs (1)
110Assert.False(previewWorkspace.IsDocumentOpen(document.Id));
RenameTracking\RenameTrackingTaggerProviderTests.cs (4)
877Assert.False(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(notRenamable, out _)); 880Assert.False(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(source.Task, out _)); 886Assert.False(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(source.Task, out _)); 890Assert.False(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(source.Task, out _));
Structure\StructureTaggerTests.cs (6)
68Assert.False(namespaceTag.IsImplementation); 82Assert.False(classTag.IsImplementation); 96Assert.False(ifTag.IsImplementation); 276Assert.False(namespaceTag.IsImplementation); 290Assert.False(moduleTag.IsImplementation); 304Assert.False(ifTag.IsImplementation);
Tagging\AsynchronousTaggerTests.cs (2)
175Assert.False(c.FrozenPartialSemantics); 223Assert.False(c.FrozenPartialSemantics);
Utilities\BloomFilterTests.cs (8)
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)); 185Assert.False(actualContains); 250Assert.False(actualContains);
Utilities\PatternMatcherTests.cs (2)
399Assert.False(match.First().IsCaseSensitive); 414Assert.False(match.Value.IsCaseSensitive);
Utilities\SymbolEquivalenceComparerTests.cs (94)
89Assert.False(SymbolEquivalenceComparer.Instance.Equals(intField1.Type, intArrayField1.Type)); 90Assert.False(SymbolEquivalenceComparer.Instance.Equals(intArrayField1.Type, stringArrayField1.Type)); 91Assert.False(SymbolEquivalenceComparer.Instance.Equals(stringArrayField1.Type, intArrayArrayField1.Type)); 92Assert.False(SymbolEquivalenceComparer.Instance.Equals(intArrayArrayField1.Type, intArrayRank2Field1.Type)); 93Assert.False(SymbolEquivalenceComparer.Instance.Equals(intArrayRank2Field1.Type, int32Field1.Type)); 146Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpIntField1.Type, vbIntArrayField1.Type)); 147Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbIntArrayField1.Type, csharpStringArrayField1.Type)); 148Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpStringArrayField1.Type, vbIntArrayArrayField1.Type)); 149Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbIntArrayArrayField1.Type, csharpIntArrayRank2Field1.Type)); 150Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpIntArrayRank2Field1.Type, vbInt32Field1.Type)); 154Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbIntField1.Type, csharpIntArrayField1.Type)); 155Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpIntArrayField1.Type, vbStringArrayField1.Type)); 156Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbStringArrayField1.Type, csharpIntArrayArrayField1.Type)); 157Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpIntArrayArrayField1.Type, vbIntArrayRank2Field1.Type)); 158Assert.False(SymbolEquivalenceComparer.Instance.Equals(vbIntArrayRank2Field1.Type, csharpInt32Field1.Type)); 211Assert.False(SymbolEquivalenceComparer.Instance.Equals(field2_v1, field2_v2)); 213Assert.False(SymbolEquivalenceComparer.Instance.Equals(field4_v1, field4_v2)); 259Assert.False(SymbolEquivalenceComparer.Instance.Equals(field2_v1, field2_v2)); 261Assert.False(SymbolEquivalenceComparer.Instance.Equals(field4_v1, field4_v2)); 297Assert.False(SymbolEquivalenceComparer.Instance.Equals(goo, goo_intInstantiation1)); 298Assert.False(SymbolEquivalenceComparer.Instance.Equals(goo, goo_intInstantiation2)); 299Assert.False(SymbolEquivalenceComparer.Instance.Equals(goo, goo_stringInstantiation)); 300Assert.False(SymbolEquivalenceComparer.Instance.Equals(goo_intInstantiation1, goo_stringInstantiation)); 333Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 358Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 383Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 408Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 539Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 591Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 631Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, csharpBarMethod)); 632Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, vbQuuxMethod)); 634Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, csharpGooMethod)); 635Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, vbGooMethod)); 636Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, vbQuuxMethod)); 676Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, csharpBarMethod)); 677Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, vbBarMethod)); 679Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, csharpGooMethod)); 680Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, vbGooMethod)); 681Assert.False(SymbolEquivalenceComparer.Instance.Equals(csharpBarMethod, vbBarMethod)); 700Assert.False(SymbolEquivalenceComparer.Instance.Equals(field1_v1, field2_v1)); 701Assert.False(SymbolEquivalenceComparer.Instance.Equals(field2_v1, field1_v1)); 762Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 763Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v2, method_v1)); 830Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 831Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v2, method_v1)); 883Assert.False(SymbolEquivalenceComparer.Instance.Equals(outer1, inner1)); 884Assert.False(SymbolEquivalenceComparer.Instance.Equals(inner1, outerType1)); 885Assert.False(SymbolEquivalenceComparer.Instance.Equals(outerType1, innerType1)); 886Assert.False(SymbolEquivalenceComparer.Instance.Equals(innerType1, outer1)); 947Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type2_v1)); 948Assert.False(SymbolEquivalenceComparer.Instance.Equals(type2_v1, type1_v1)); 972Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type1_v2)); 973Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v2, type1_v1)); 997Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type1_v2)); 998Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v2, type1_v1)); 1022Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type1_v2)); 1023Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v2, type1_v1)); 1055Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type1_v2)); 1056Assert.False(SymbolEquivalenceComparer.Instance.Equals(type1_v2, type1_v1)); 1120Assert.False(trueComp.Equals(method_v1, method_v2)); 1121Assert.False(trueComp.Equals(method_v2, method_v1)); 1157Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 1187Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 1249Assert.False(SymbolEquivalenceComparer.TupleNamesMustMatchInstance.Equals(method_v1, method_v2)); 1280Assert.False(SymbolEquivalenceComparer.TupleNamesMustMatchInstance.Equals(method_v1, method_v2)); 1311Assert.False(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2)); 1364Assert.False(notIgnoreComparer.Equals(a1, a2)); 1365Assert.False(notIgnoreComparer.Equals(b1, b2)); 1366Assert.False(notIgnoreComparer.Equals(c1, c2)); 1367Assert.False(notIgnoreComparer.Equals(d1, d2)); 1491Assert.False(notIgnoreComparer.Equals(a1, a2)); 1492Assert.False(notIgnoreComparer.Equals(b1, b2)); 1493Assert.False(notIgnoreComparer.Equals(c1, c2)); 1494Assert.False(notIgnoreComparer.Equals(d1, d2)); 1554Assert.False(notIgnoreComparer.Equals(a1, a2)); 1555Assert.False(notIgnoreComparer.Equals(b1, b2)); 1556Assert.False(notIgnoreComparer.Equals(c1, c2)); 1557Assert.False(notIgnoreComparer.Equals(d1, d2)); 1724Assert.False(SymbolEquivalenceComparer.Instance.Equals(namespace1, namespace2)); 1760Assert.False(SymbolEquivalenceComparer.Instance.Equals(ta1, tb1)); 1761Assert.False(identityComparer.Equals(ta1, tb1)); 1766Assert.False(identityComparer.Equals(tb1, tb2)); 1843Assert.False(identityComparer.Equals(f1[0], f2[1])); 1844Assert.False(identityComparer.Equals(f1[0], f2[2])); 1845Assert.False(identityComparer.Equals(f1[0], f2[3])); 1847Assert.False(identityComparer.Equals(f1[1], f2[0])); 1849Assert.False(identityComparer.Equals(f1[1], f2[2])); 1850Assert.False(identityComparer.Equals(f1[1], f2[3])); 1852Assert.False(identityComparer.Equals(f1[2], f2[0])); 1853Assert.False(identityComparer.Equals(f1[2], f2[1])); 1855Assert.False(identityComparer.Equals(f1[2], f2[3])); 1857Assert.False(identityComparer.Equals(f1[3], f2[0])); 1858Assert.False(identityComparer.Equals(f1[3], f2[1])); 1859Assert.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 (8)
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)
107Assert.False(reader.TryGetDocumentChecksum("/b/c.cs", out _, out _)); 108Assert.False(reader.TryGetDocumentChecksum("/a/d.cs", out _, out _)); 109Assert.False(reader.TryGetDocumentChecksum("/A/C.cs", out _, out _));
EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (1)
3580Assert.False(readers.Any(r => r is null));
Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (26)
Completion\CompletionFeaturesTests.cs (1)
1085Assert.False(results.Items.Any(i => i.Label == "if"));
Completion\CompletionTests.cs (3)
310Assert.False(results.Items.Any(item => "Console" == item.Label)); 333Assert.False(results.Items.Any(item => "ctor" == item.Label)); 1445Assert.False(list.IsIncomplete);
Configuration\DidChangeConfigurationNotificationHandlerTest.cs (1)
59Assert.False(clientCallbackTarget.ReceivedWorkspaceConfigurationRequest);
Diagnostics\PullDiagnosticTests.cs (11)
783Assert.False(results.Single().Diagnostics![1].Tags!.Contains(DiagnosticTag.Unnecessary)); 816AssertEx.All(results.Single().Diagnostics, d => Assert.False(d.Tags!.Contains(DiagnosticTag.Unnecessary))); 848Assert.False(results.Single().Diagnostics![0].Tags!.Contains(DiagnosticTag.Unnecessary)); 1423Assert.False(results.Any(r => r.TextDocument!.DocumentUri.GetRequiredParsedUri().LocalPath.Contains(".ts"))); 2043Assert.False(resultTask.IsCompleted); 2071Assert.False(resultTask.IsCompleted); 2100Assert.False(resultTask.IsCompleted); 2130Assert.False(resultTaskOne.IsCompleted); 2131Assert.False(resultTaskTwo.IsCompleted); 2156Assert.False(resultTaskOne.IsCompleted); 2157Assert.False(resultTaskTwo.IsCompleted);
DocumentChanges\DocumentChangesTests.cs (2)
397Assert.False(DidChangeHandler.AreChangesInReverseOrder([change1, change2, change3])); 407Assert.False(DidChangeHandler.AreChangesInReverseOrder([change1, change2, change3]));
HandlerTests.cs (3)
193Assert.False(didReport); 251Assert.False(didReport); 279Assert.False(didReport);
Hover\HoverTests.cs (1)
645Assert.False(classifiedTextElements.SelectMany(classifiedTextElements => classifiedTextElements.Runs).Any(run => run.NavigationAction != null));
LanguageServerTargetTests.cs (1)
142Assert.False(server.GetServerAccessor().HasShutdownStarted());
Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (1)
285Assert.False(optionsAfterProjectAdded.ContainsKey("test_option"));
Ordering\RequestOrderingTests.cs (1)
154Assert.False(longRunningWaitable.IsCompleted);
ProtocolConversionsTests.cs (1)
308Assert.False(projectContext.IsMiscellaneous);
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 (29)
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 (1)
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 (579)
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 (1)
251Assert.False(i2.MoveNext());
Collections\CachingFactoryTests.cs (1)
41Assert.False(found);
Collections\Extensions\EnumerableExtensionsTests.cs (8)
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)); 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));
Collections\Extensions\ImmutableArrayExtensionsTests.cs (13)
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); 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)));
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 (6)
43Assert.False(builder.ContainsKey(7)); 65Assert.False(builder.ContainsKey(7)); 75Assert.False(set.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. 185Assert.False(builder.ContainsKey("A"));
Collections\ImmutableSegmentedDictionaryTest.cs (7)
44Assert.False(map.ContainsKey("johnny")); 85Assert.False(dictionary.ContainsValue("c")); 86Assert.False(dictionary.ContainsValue(null)); 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 (12)
41Assert.False(builder.Contains(7)); 49Assert.False(set.Contains(8)); 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")); 252Assert.False(builder.Overlaps(Enumerable.Range(4, 3))); 259Assert.False(builder.Remove("b")); 285Assert.False(builder.IsReadOnly); 309Assert.False(builder.Remove(null)); 332Assert.False(builder.Contains(3));
Collections\ImmutableSegmentedHashSetTest.cs (1)
51Assert.False(ordinalSet.Contains("aPpLe"));
Collections\ImmutableSegmentedListBuilderTest.cs (14)
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));
Collections\ImmutableSegmentedListTest.cs (21)
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)));
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 (4)
37Assert.False(TemporaryArray<int>.Empty.GetEnumerator().MoveNext()); 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 (36)
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)); 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 (4)
31Assert.False(((IEnumerable)emptySet).GetEnumerator().MoveNext()); 36Assert.False(emptySet.Contains(0)); 53Assert.False(emptySet.Overlaps(new int[0])); 54Assert.False(emptySet.Overlaps(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);
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 (7)
RpcTests.cs (1)
242Assert.False(cancellationToken.CanBeCanceled);
VisualStudioMSBuildWorkspaceTests.cs (6)
323Assert.False(File.Exists(p1.OutputFilePath)); 1904Assert.False(options.PreprocessorSymbolNames.Contains("EnableMyAttribute")); 2082Assert.False(File.Exists(document.FilePath)); 2186Assert.False(workspace.CanApplyChange(ApplyChangesKind.AddAdditionalDocument)); 2196Assert.False(workspace.CanApplyChange(ApplyChangesKind.RemoveAdditionalDocument)); 2914Assert.False(projFileText.Contains(@"<Analyzer Include=""..\Analyzers\MyAnalyzer.dll"));
Microsoft.CodeAnalysis.Workspaces.UnitTests (129)
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)
709Assert.False(foundDeclarations.Any(decl => decl == null));
Formatter\FormatterTests.cs (2)
198Assert.False(formattingOptions.WrappingPreserveSingleLine); 199Assert.False(formattingOptions.WrappingKeepStatementsOnSingleLine);
ObjectSerializationTests.cs (2)
436Assert.False(reader.ReadBoolean()); 504Assert.False((bool)reader.ReadScalarValue());
Options\OptionKeyTests.cs (8)
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));
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 (15)
2559Assert.False(project.HasDocuments); 3090Assert.False(project.HasDocuments); 3093Assert.False(sol2.ProjectIds.Any()); 3116Assert.False(sol2.ContainsProject(pid)); 3141Assert.False(sol2.ContainsProject(pid)); 3169Assert.False(document.TryGetSyntaxRoot(out _)); 3225Assert.False(tree2.TryGetText(out _)); 4486Assert.False(frozenDoc1Root.DescendantNodes().Any(n => n.RawKind == StructDeclaration)); 4500Assert.False(frozenDoc1Root.DescendantNodes().Any(n => n.RawKind == ClassDeclaration)); 4778Assert.False(provider.TryGetDiagnosticValue(syntaxTreeAfterAddingEditorConfig, "CA1234", CancellationToken.None, out _)); 4843Assert.False(originalProvider.TryGetGlobalDiagnosticValue("CA1234", default, out _)); 4859Assert.False(finalProvider.TryGetGlobalDiagnosticValue("CA1234", default, out _)); 4926Assert.False(document.TryGetSyntaxTree(out _)); 4930Assert.False(document.TryGetSemanticModel(out _)); 5260Assert.False(compilation1.References.Any(r => r is CompilationReference));
SolutionTests\SolutionWithSourceGeneratorTests.cs (7)
582Assert.False(project.TryGetCompilation(out _)); 708Assert.False(workspace.IsDocumentOpen(generatedDocument.Identity.DocumentId)); 729Assert.False(generatorRan); 742Assert.False(generatorRan); 769Assert.False(generatorRan); 832Assert.False(generatorRan); 861Assert.False(noTreesPassed!.Value);
SymbolKeyTests.cs (3)
198Assert.False(symbols.Any(s => s is IFieldSymbol { MetadataName: "" })); 228Assert.False(symbols.Any(s => s is IFieldSymbol { MetadataName: "" })); 258Assert.False(symbols.Any(s => s is IFieldSymbol { MetadataName: "" }));
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 _)); 259Assert.False(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode _)); 289Assert.False(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode _)); 290Assert.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\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 (22)
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));
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 (54)
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)
236Assert.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);
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); 428Assert.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 (1)
ChatClientIntegrationTests.cs (1)
1003Assert.False(response.Result);
Microsoft.Extensions.AI.Ollama.Tests (1)
OllamaChatClientIntegrationTests.cs (1)
85Assert.False(didCallIrrelevantTool);
Microsoft.Extensions.AI.Tests (21)
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); 50Assert.False(client.AllowConcurrentInvocation); 54Assert.False(client.IncludeDetailedErrors);
Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (3)
160Assert.False(result1.IsCompleted); 161Assert.False(result2.IsCompleted); 229Assert.False(result1.IsCompleted);
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 (19)
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 (11)
15Assert.False(tags.IsArray); 26Assert.False(tags.IsArray); 37Assert.False(tags.IsArray); 54Assert.False(tags.IsEmpty); 55Assert.False(tags.IsArray); 66Assert.False(tags.IsEmpty); 67Assert.False(tags.IsArray); 85Assert.False(tags.IsEmpty); 99Assert.False(tags.IsEmpty); 122Assert.False(tags.IsEmpty); 133Assert.False(tags.IsEmpty);
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)
163Assert.False(logger.IsEnabled(LogLevel.Debug)); 168Assert.False(logger.IsEnabled((LogLevel)42)); 172Assert.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)
54Assert.False(es.IsEnabled()); 59Assert.False(esSockets.IsEnabled()); 64Assert.False(esHttp.IsEnabled()); 69Assert.False(esNameRes.IsEnabled()); 87Assert.False(es.IsEnabled());
Microsoft.Extensions.Http.Polly.Tests (1)
PolicyHttpMessageHandlerTest.cs (1)
409Assert.False(hangs);
Microsoft.Extensions.Http.Resilience.Tests (6)
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 (1)
64Assert.False(await options.ShouldHandle(CreatePredicateArguments(response)));
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 (48)
ColumnInferenceTests.cs (2)
36Assert.False(col.Source.Length > 1 || col.Source[0].Min != col.Source[0].Max); 71Assert.False(result.TextLoaderOptions.HasHeader);
ConversionTests.cs (2)
55Assert.False(success); 92Assert.False(success);
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.CpuMath.UnitTests (3)
UnitTests.cs (3)
127Assert.False(System.Runtime.Intrinsics.X86.Avx.IsSupported); 132Assert.False(System.Runtime.Intrinsics.X86.Avx.IsSupported); 133Assert.False(System.Runtime.Intrinsics.X86.Sse.IsSupported);
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 (46)
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)
238Assert.False(CookieHeaderValue.TryParse(value, out var _)); 318Assert.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 (2)
395Assert.False(SetCookieHeaderValue.TryParse(value, out var _)); 487Assert.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 (13)
CodeModel\FileCodeFunctionTests.cs (3)
122Assert.False(testObject.CanOverride); 178Assert.False(testObject.IsOverloaded); 186Assert.False(testObject.IsShared);
CodeModel\FileCodeVariableTests.cs (2)
146Assert.False(testObject.IsConstant); 162Assert.False(testObject.IsShared);
PersistentStorage\AbstractPersistentStorageTests.cs (1)
846Assert.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);
PresentationCore.Tests (4)
System\Windows\Media\Animation\RepeatBehavior.Tests.cs (4)
40Assert.False(behavior.HasDuration); 91Assert.False(behavior.HasCount); 117Assert.False(behavior.HasCount); 118Assert.False(behavior.HasDuration);
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)
596Assert.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 (46)
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 (4)
15Assert.False(DebuggerState.System.IsAttached); 17Assert.False(DebuggerState.Detached.IsAttached); 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 (1)
275Assert.False(o.Busy);
RentedSpan\RentedSpanTest.cs (3)
14Assert.False(rental1.Rented); 18Assert.False(rental2.Rented); 22Assert.False(rental3.Rented);
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));
System.Xaml.Tests (94)
System\Windows\Markup\ValueSerializerTests.cs (4)
26Assert.False(serializer.CanConvertToString(value, null)); 27Assert.False(serializer.CanConvertToString(value, new CustomValueSerializerContext())); 59Assert.False(serializer.CanConvertFromString(value, null)); 60Assert.False(serializer.CanConvertFromString(value, new CustomValueSerializerContext()));
System\Windows\Markup\XamlSetMarkupExtensionEventArgsTests.cs (1)
28Assert.False(e.Handled);
System\Windows\Markup\XamlSetTypeConverterEventArgsTests.cs (1)
31Assert.False(e.Handled);
System\Windows\Markup\XamlSetValueEventArgsTests.cs (1)
26Assert.False(e.Handled);
System\Xaml\Schema\XamlTypeNameTests.cs (3)
297Assert.False(XamlTypeName.TryParse("name", namespaceResolver, out result)); 383Assert.False(XamlTypeName.TryParse(typeName, namespaceResolver, out XamlTypeName result)); 433Assert.False(XamlTypeName.TryParseList(typeNameList, namespaceResolver, out IList<XamlTypeName> result));
System\Xaml\XamlBackgroundReaderTests.cs (1)
35Assert.False(reader.IsEof);
System\Xaml\XamlDirectiveTests.cs (5)
36Assert.False(directive.IsUnknown); 193Assert.False(directive.LookupIsAmbientEntry()); 200Assert.False(directive.LookupIsEventEntry()); 207Assert.False(directive.LookupIsReadOnlyEntry()); 228Assert.False(directive.LookupIsWriteOnlyEntry());
System\Xaml\XamlMemberTests.cs (21)
28Assert.False(member.IsDirective); 29Assert.False(member.IsEvent); 58Assert.False(member.IsAttachable); 59Assert.False(member.IsDirective); 60Assert.False(member.IsEvent); 80Assert.False(member.IsAttachable); 81Assert.False(member.IsDirective); 82Assert.False(member.IsEvent); 114Assert.False(member.IsAttachable); 115Assert.False(member.IsDirective); 136Assert.False(member.IsAttachable); 137Assert.False(member.IsDirective); 174Assert.False(member.IsDirective); 175Assert.False(member.IsEvent); 197Assert.False(member.IsDirective); 198Assert.False(member.IsEvent); 261Assert.False(member.IsDirective); 282Assert.False(member.IsDirective); 794Assert.False(directive.IsAmbient); 1035Assert.False(directive.IsReadOnly); 1277Assert.False(directive.IsWriteOnly);
System\Xaml\XamlNodeListTests.cs (15)
53Assert.False(reader.IsEof); 79Assert.False(reader.IsEof); 89Assert.False(reader.IsEof); 97Assert.False(reader.Read()); 135Assert.False(reader.IsEof); 183Assert.False(reader.IsEof); 251Assert.False(reader.IsEof); 281Assert.False(reader.IsEof); 311Assert.False(reader.IsEof); 341Assert.False(reader.IsEof); 371Assert.False(reader.IsEof); 401Assert.False(reader.IsEof); 432Assert.False(reader.IsEof); 470Assert.False(reader.IsEof); 525Assert.False(reader.Read());
System\Xaml\XamlNodeQueueTests.cs (11)
38Assert.False(reader.IsEof); 52Assert.False(reader.HasLineInfo); 63Assert.False(reader.Read()); 107Assert.False(reader.IsEof); 174Assert.False(reader.IsEof); 241Assert.False(reader.IsEof); 277Assert.False(reader.IsEof); 352Assert.False(reader.IsEof); 405Assert.False(reader.Read()); 421Assert.False(lineInfo.HasLineInfo); 434Assert.False(reader.Read());
System\Xaml\XamlObjectReaderSettingsTests.cs (4)
15Assert.False(settings.AllowProtectedMembersOnRoot); 19Assert.False(settings.IgnoreUidsOnPropertyElements); 20Assert.False(settings.ValuesMustBeString); 21Assert.False(settings.RequireExplicitContentVisibility);
System\Xaml\XamlObjectWriterSettingsTests.cs (5)
23Assert.False(settings.IgnoreCanConvert); 25Assert.False(settings.SkipDuplicatePropertyCheck); 26Assert.False(settings.RegisterNamesOnExternalNamescope); 27Assert.False(settings.SkipProvideValueOnRoot); 28Assert.False(settings.PreferUnconvertedDictionaryKeys);
System\Xaml\XamlReaderSettingsTests.cs (3)
16Assert.False(settings.AllowProtectedMembersOnRoot); 20Assert.False(settings.IgnoreUidsOnPropertyElements); 21Assert.False(settings.ValuesMustBeString);
System\Xaml\XamlReaderTests.cs (3)
93Assert.False(subReader.HasLineInfo); 123Assert.False(subReader.Read()); 136Assert.False(subReader.Read());
System\Xaml\XamlSchemaContextSettingsTests.cs (2)
16Assert.False(settings.SupportMarkupExtensionsWithDuplicateArity); 17Assert.False(settings.FullyQualifyAssemblyNamesInClrNamespaces);
System\Xaml\XamlSchemaContextTests.cs (4)
22Assert.False(context.SupportMarkupExtensionsWithDuplicateArity); 23Assert.False(context.FullyQualifyAssemblyNamesInClrNamespaces); 62Assert.False(context.SupportMarkupExtensionsWithDuplicateArity); 63Assert.False(context.FullyQualifyAssemblyNamesInClrNamespaces);
System\Xaml\XamlTypeTests.cs (2)
95Assert.False(type.IsUnknown); 115Assert.False(type.IsUnknown);
System\Xaml\XamlXmlReaderSettingsTests.cs (6)
16Assert.False(settings.AllowProtectedMembersOnRoot); 20Assert.False(settings.IgnoreUidsOnPropertyElements); 21Assert.False(settings.ValuesMustBeString); 23Assert.False(settings.XmlSpacePreserve); 24Assert.False(settings.SkipXmlCompatibilityProcessing); 25Assert.False(settings.CloseInput);
System\Xaml\XamlXmlWriterSettingsTests.cs (2)
15Assert.False(settings.AssumeValidInput); 16Assert.False(settings.CloseOutput);
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 (31)
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"));
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 (5)
44Assert.False(task.IsFaulted); 423Assert.False(_shutdown); 431Assert.False(_shutdown); 453Assert.False(Parse("-invalid")); 454Assert.False(Parse("name"));
WindowsBase.Tests (932)
System\ComponentModel\CurrentChangingEventArgsTests.cs (3)
13Assert.False(args.Cancel); 23Assert.False(args.Cancel); 55Assert.False(args.Cancel);
System\ComponentModel\GroupDescriptionTests.cs (14)
273Assert.False(property.ShouldSerializeValue(description)); 276Assert.False(property.ShouldSerializeValue(description)); 282Assert.False(property.ShouldSerializeValue(description)); 472Assert.False(property.ShouldSerializeValue(description)); 475Assert.False(property.ShouldSerializeValue(description)); 481Assert.False(property.ShouldSerializeValue(description)); 565Assert.False(description.ShouldSerializeGroupNames()); 568Assert.False(description.ShouldSerializeGroupNames()); 574Assert.False(description.ShouldSerializeGroupNames()); 584Assert.False(description.ShouldSerializeGroupNames()); 592Assert.False(description.ShouldSerializeSortDescriptions()); 595Assert.False(description.ShouldSerializeSortDescriptions()); 601Assert.False(description.ShouldSerializeSortDescriptions()); 611Assert.False(description.ShouldSerializeSortDescriptions());
System\ComponentModel\SortDescriptionCollectionTests.cs (4)
17Assert.False(((IList)collection).IsFixedSize); 18Assert.False(((IList)collection).IsReadOnly); 19Assert.False(((IList)collection).IsSynchronized); 784Assert.False(((IList)collection).IsSynchronized);
System\ComponentModel\SortDescriptionTests.cs (2)
14Assert.False(description.IsSealed); 27Assert.False(description.IsSealed);
System\Diagnostics\PresentationTraceSourcesTests.cs (1)
23Assert.False(property.ReadOnly);
System\IO\Packaging\PackageDigitalSignatureManagerTests.cs (1)
27Assert.False(manager.IsSigned);
System\Security\RightsManagement\ContentUserTests.cs (4)
108Assert.False(user.IsAuthenticated()); 115Assert.False(user.IsAuthenticated()); 122Assert.False(user.IsAuthenticated()); 131Assert.False(user.IsAuthenticated());
System\Security\RightsManagement\SecureEnvironmentTests.cs (4)
132Assert.False(SecureEnvironment.IsUserActivated(user)); 139Assert.False(SecureEnvironment.IsUserActivated(user)); 169Assert.False(SecureEnvironment.IsUserActivated(user)); 177Assert.False(SecureEnvironment.IsUserActivated(user));
System\Windows\Data\DataSourceProviderTests.cs (76)
21Assert.False(provider.IsRefreshDeferred); 211Assert.False(provider.IsInitialLoadEnabled); 216Assert.False(provider.IsInitialLoadEnabled); 227Assert.False(provider.IsInitialLoadEnabled); 245Assert.False(provider.IsRefreshDeferred); 266Assert.False(provider.IsRefreshDeferred); 287Assert.False(provider.IsRefreshDeferred); 308Assert.False(provider.IsRefreshDeferred); 336Assert.False(provider.IsRefreshDeferred); 364Assert.False(provider.IsRefreshDeferred); 377Assert.False(provider.IsRefreshDeferred); 382Assert.False(provider.IsRefreshDeferred); 392Assert.False(provider.IsRefreshDeferred); 410Assert.False(provider.IsRefreshDeferred); 431Assert.False(provider.IsRefreshDeferred); 452Assert.False(provider.IsRefreshDeferred); 473Assert.False(provider.IsRefreshDeferred); 501Assert.False(provider.IsRefreshDeferred); 529Assert.False(provider.IsRefreshDeferred); 542Assert.False(provider.IsRefreshDeferred); 547Assert.False(provider.IsRefreshDeferred); 557Assert.False(provider.IsRefreshDeferred); 584Assert.False(provider.IsRefreshDeferred); 588Assert.False(provider.IsRefreshDeferred); 602Assert.False(provider.IsRefreshDeferred); 606Assert.False(provider.IsRefreshDeferred); 638Assert.False(provider.IsRefreshDeferred); 666Assert.False(provider.IsRefreshDeferred); 671Assert.False(provider.IsRefreshDeferred); 701Assert.False(provider.IsRefreshDeferred); 718Assert.False(provider.IsRefreshDeferred); 736Assert.False(provider.IsRefreshDeferred); 741Assert.False(provider.IsRefreshDeferred); 746Assert.False(provider.IsRefreshDeferred); 764Assert.False(provider.IsRefreshDeferred); 769Assert.False(provider.IsRefreshDeferred); 774Assert.False(provider.IsRefreshDeferred); 797Assert.False(provider.IsRefreshDeferred); 825Assert.False(provider.IsRefreshDeferred); 843Assert.False(provider.IsRefreshDeferred); 861Assert.False(provider.IsRefreshDeferred); 866Assert.False(provider.IsRefreshDeferred); 871Assert.False(provider.IsRefreshDeferred); 889Assert.False(provider.IsRefreshDeferred); 894Assert.False(provider.IsRefreshDeferred); 899Assert.False(provider.IsRefreshDeferred); 922Assert.False(provider.IsRefreshDeferred); 950Assert.False(provider.IsRefreshDeferred); 980Assert.False(provider.IsRefreshDeferred); 985Assert.False(provider.IsRefreshDeferred); 1044Assert.False(provider.IsRefreshDeferred); 1049Assert.False(provider.IsRefreshDeferred); 1054Assert.False(provider.IsRefreshDeferred); 1066Assert.False(provider.IsRefreshDeferred); 1071Assert.False(provider.IsRefreshDeferred); 1076Assert.False(provider.IsRefreshDeferred); 1089Assert.False(provider.IsRefreshDeferred); 1094Assert.False(provider.IsRefreshDeferred); 1106Assert.False(provider.IsRefreshDeferred); 1111Assert.False(provider.IsRefreshDeferred); 1116Assert.False(provider.IsRefreshDeferred); 1184Assert.False(provider.IsRefreshDeferred); 1193Assert.False(provider.IsRefreshDeferred); 1202Assert.False(provider.IsRefreshDeferred); 1224Assert.False(provider.IsRefreshDeferred); 1249Assert.False(provider.IsRefreshDeferred); 1437Assert.False(provider.IsRefreshDeferred); 1446Assert.False(provider.IsRefreshDeferred); 1466Assert.False(provider.IsRefreshDeferred); 1475Assert.False(provider.IsRefreshDeferred); 1484Assert.False(provider.IsRefreshDeferred); 1512Assert.False(provider.IsRefreshDeferred); 1522Assert.False(provider.IsRefreshDeferred); 1547Assert.False(provider.IsRefreshDeferred); 1561Assert.False(provider.IsRefreshDeferred); 1588Assert.False(provider.IsRefreshDeferred);
System\Windows\DependencyObjectTests.cs (41)
20Assert.False(obj.IsSealed); 66Assert.False(obj.IsSealed); 75Assert.False(obj.IsSealed); 87Assert.False((bool)obj.GetValue(property)); 95Assert.False((bool)obj.GetValue(property)); 99Assert.False((bool)obj.GetValue(property)); 442Assert.False((bool)obj.GetValue(property)); 450Assert.False((bool)obj.GetValue(property)); 454Assert.False((bool)obj.GetValue(property)); 796Assert.False((bool)obj.GetValue(property)); 1148Assert.False((bool)obj.GetValue(property)); 1152Assert.False((bool)obj.GetValue(property)); 1249Assert.False(obj.Equals(new DependencyObject())); 1250Assert.False(obj.Equals(null)); 1272Assert.False(enumerator.MoveNext()); 1277Assert.False(enumerator.MoveNext()); 1282Assert.False(enumerator.MoveNext()); 1315Assert.False(enumerator.MoveNext()); 1320Assert.False(enumerator.MoveNext()); 1358Assert.False(enumerator.MoveNext()); 1363Assert.False(enumerator.MoveNext()); 1388Assert.False((bool)obj.GetValue(property)); 1391Assert.False((bool)obj.GetValue(property)); 1527Assert.False((bool)obj.GetValue(property)); 1530Assert.False((bool)obj.GetValue(property)); 1554Assert.False((bool)obj.GetValue(property)); 1557Assert.False((bool)obj.GetValue(property)); 1567Assert.False((bool)obj.GetValue(property)); 1570Assert.False((bool)obj.GetValue(property)); 2044Assert.False((bool)obj.GetValue(property)); 2067Assert.False((bool)obj.GetValue(property)); 2464Assert.False((bool)obj.GetValue(property)); 2488Assert.False((bool)obj.GetValue(property)); 2954Assert.False(obj.ShouldSerializeProperty(property)); 2957Assert.False(obj.ShouldSerializeProperty(property)); 2966Assert.False(obj.ShouldSerializeProperty(property)); 2969Assert.False(obj.ShouldSerializeProperty(property)); 2979Assert.False(obj.ShouldSerializeProperty(property)); 2982Assert.False(obj.ShouldSerializeProperty(property)); 2993Assert.False(obj.ShouldSerializeProperty(property)); 2996Assert.False(obj.ShouldSerializeProperty(property));
System\Windows\DependencyPropertyTests.cs (8)
37Assert.False(property.ReadOnly); 89Assert.False(property.ReadOnly); 148Assert.False(property.ReadOnly); 201Assert.False(property.ReadOnly); 348Assert.False(property.ReadOnly); 402Assert.False(property.ReadOnly); 461Assert.False(property.ReadOnly); 514Assert.False(property.ReadOnly);
System\Windows\ExpressionConverterTests.cs (5)
21Assert.False(converter.CanConvertTo(null, destinationType)); 22Assert.False(converter.CanConvertTo(new CustomTypeDescriptorContext(), destinationType)); 87Assert.False(converter.CanConvertFrom(sourceType!)); 88Assert.False(converter.CanConvertFrom(null, sourceType)); 89Assert.False(converter.CanConvertFrom(new CustomTypeDescriptorContext(), sourceType));
System\Windows\FreezableTests.cs (241)
20Assert.False(freezable.IsFrozen); 21Assert.False(freezable.IsSealed); 162Assert.False(freezable.CanFreeze); 339Assert.False(freezable.IsFrozen); 377Assert.False(freezable.IsSealed); 395Assert.False(freezable.IsSealed); 419Assert.False((bool)obj.GetValue(property)); 427Assert.False((bool)obj.GetValue(property)); 431Assert.False((bool)obj.GetValue(property)); 732Assert.False((bool)freezable.GetValue(property)); 742Assert.False((bool)freezable.GetValue(property)); 752Assert.False((bool)freezable.GetValue(property)); 779Assert.False((bool)freezable.GetValue(property)); 791Assert.False((bool)freezable.GetValue(property)); 797Assert.False((bool)freezable.GetValue(property)); 862Assert.False((bool)obj.GetValue(property)); 870Assert.False((bool)obj.GetValue(property)); 874Assert.False((bool)obj.GetValue(property)); 1206Assert.False((bool)freezable.GetValue(key.DependencyProperty)); 1216Assert.False((bool)freezable.GetValue(key.DependencyProperty)); 1226Assert.False((bool)freezable.GetValue(key.DependencyProperty)); 1253Assert.False((bool)freezable.GetValue(key.DependencyProperty)); 1265Assert.False((bool)freezable.GetValue(key.DependencyProperty)); 1271Assert.False((bool)freezable.GetValue(key.DependencyProperty)); 1338Assert.False(clone.IsFrozen); 1339Assert.False(clone.IsSealed); 1345Assert.False(freezable.IsFrozen); 1346Assert.False(freezable.IsSealed); 1360Assert.False(clone2.IsFrozen); 1361Assert.False(clone2.IsSealed); 1367Assert.False(clone.IsFrozen); 1368Assert.False(clone.IsSealed); 1374Assert.False(freezable.IsFrozen); 1375Assert.False(freezable.IsSealed); 1429Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property6)).IsFrozen); 1432Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property7)).IsFrozen); 1435Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property8)).IsFrozen); 1442Assert.False(clone.IsFrozen); 1443Assert.False(clone.IsSealed); 1498Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property6)).IsFrozen); 1501Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property7)).IsFrozen); 1504Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property8)).IsFrozen); 1510Assert.False(clone.IsFrozen); 1511Assert.False(clone.IsSealed); 1547Assert.False(clone.IsFrozen); 1548Assert.False(clone.IsSealed); 1611Assert.False(clone.CanFreeze); 1617Assert.False(clone.IsFrozen); 1618Assert.False(clone.IsSealed); 1650Assert.False(clone.IsFrozen); 1651Assert.False(clone.IsSealed); 1668Assert.False(freezable.IsFrozen); 1669Assert.False(freezable.IsSealed); 1678Assert.False(freezable.IsFrozen); 1679Assert.False(freezable.IsSealed); 1725Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property6)).IsFrozen); 1728Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property7)).IsFrozen); 1731Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property8)).IsFrozen); 1738Assert.False(freezable.IsFrozen); 1739Assert.False(freezable.IsSealed); 1770Assert.False(freezable.IsFrozen); 1771Assert.False(freezable.IsSealed); 1780Assert.False(freezable.IsFrozen); 1781Assert.False(freezable.IsSealed); 1829Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property6)).IsFrozen); 1832Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property7)).IsFrozen); 1835Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property8)).IsFrozen); 1842Assert.False(freezable.IsFrozen); 1843Assert.False(freezable.IsSealed); 1944Assert.False(freezable.IsFrozen); 1945Assert.False(freezable.IsSealed); 1954Assert.False(freezable.IsFrozen); 1955Assert.False(freezable.IsSealed); 2012Assert.False(freezable.IsFrozen); 2013Assert.False(freezable.IsSealed); 2032Assert.False(freezable.IsFrozen); 2033Assert.False(freezable.IsSealed); 2042Assert.False(freezable.IsFrozen); 2043Assert.False(freezable.IsSealed); 2102Assert.False(freezable.IsFrozen); 2103Assert.False(freezable.IsSealed); 2224Assert.False(clone.IsFrozen); 2225Assert.False(clone.IsSealed); 2231Assert.False(freezable.IsFrozen); 2232Assert.False(freezable.IsSealed); 2246Assert.False(clone2.IsFrozen); 2247Assert.False(clone2.IsSealed); 2253Assert.False(clone.IsFrozen); 2254Assert.False(clone.IsSealed); 2260Assert.False(freezable.IsFrozen); 2261Assert.False(freezable.IsSealed); 2315Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property6)).IsFrozen); 2318Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property7)).IsFrozen); 2321Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property8)).IsFrozen); 2328Assert.False(clone.IsFrozen); 2329Assert.False(clone.IsSealed); 2384Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property6)).IsFrozen); 2387Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property7)).IsFrozen); 2390Assert.False(((SubFreezable)clone.GetValue(SubFreezable.Property8)).IsFrozen); 2396Assert.False(clone.IsFrozen); 2397Assert.False(clone.IsSealed); 2433Assert.False(clone.IsFrozen); 2434Assert.False(clone.IsSealed); 2494Assert.False(clone.CanFreeze); 2500Assert.False(clone.IsFrozen); 2501Assert.False(clone.IsSealed); 2533Assert.False(clone.IsFrozen); 2534Assert.False(clone.IsSealed); 2551Assert.False(freezable.IsFrozen); 2552Assert.False(freezable.IsSealed); 2561Assert.False(freezable.IsFrozen); 2562Assert.False(freezable.IsSealed); 2608Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property6)).IsFrozen); 2611Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property7)).IsFrozen); 2614Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property8)).IsFrozen); 2621Assert.False(freezable.IsFrozen); 2622Assert.False(freezable.IsSealed); 2653Assert.False(freezable.IsFrozen); 2654Assert.False(freezable.IsSealed); 2663Assert.False(freezable.IsFrozen); 2664Assert.False(freezable.IsSealed); 2712Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property6)).IsFrozen); 2715Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property7)).IsFrozen); 2718Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property8)).IsFrozen); 2725Assert.False(freezable.IsFrozen); 2726Assert.False(freezable.IsSealed); 2828Assert.False(freezable.IsFrozen); 2829Assert.False(freezable.IsSealed); 2838Assert.False(freezable.IsFrozen); 2839Assert.False(freezable.IsSealed); 2896Assert.False(freezable.IsFrozen); 2897Assert.False(freezable.IsSealed); 2917Assert.False(freezable.IsFrozen); 2918Assert.False(freezable.IsSealed); 2927Assert.False(freezable.IsFrozen); 2928Assert.False(freezable.IsSealed); 2987Assert.False(freezable.IsFrozen); 2988Assert.False(freezable.IsSealed); 3199Assert.False((bool)obj.GetValue(property)); 3551Assert.False((bool)obj.GetValue(property)); 3555Assert.False((bool)obj.GetValue(property)); 3645Assert.False((bool)obj.GetValue(property)); 3649Assert.False((bool)obj.GetValue(property)); 3674Assert.False((bool)obj.GetValue(property)); 3827Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property6)).IsFrozen); 3830Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property7)).IsFrozen); 3834Assert.False(freezable.CanFreeze); 3839Assert.False(freezable.IsFrozen); 3840Assert.False(freezable.IsSealed); 3849Assert.False(freezable.CanFreeze); 3854Assert.False(freezable.IsFrozen); 3855Assert.False(freezable.IsSealed); 4019Assert.False(freezable.IsFrozen); 4065Assert.False(freezable.IsFrozen); 4095Assert.False(freezable.IsFrozen); 4096Assert.False(freezable.IsSealed); 4105Assert.False(freezable.IsFrozen); 4106Assert.False(freezable.IsSealed); 4155Assert.False(freezable.IsFrozen); 4156Assert.False(freezable.IsSealed); 4179Assert.False(freezable.IsFrozen); 4180Assert.False(freezable.IsSealed); 4232Assert.False(freezable.CanFreeze); 4237Assert.False(freezable.IsFrozen); 4238Assert.False(freezable.IsSealed); 4256Assert.False(freezable.CanFreeze); 4261Assert.False(freezable.IsFrozen); 4262Assert.False(freezable.IsSealed); 4284Assert.False(freezable.IsFrozen); 4285Assert.False(freezable.IsSealed); 4295Assert.False(freezable.IsFrozen); 4296Assert.False(freezable.IsSealed); 4332Assert.False(freezable.IsFrozen); 4376Assert.False(freezable.IsFrozen); 4377Assert.False(freezable.IsSealed); 4403Assert.False(freezable.IsFrozen); 4404Assert.False(freezable.IsSealed); 4664Assert.False(freezable.IsFrozen); 4665Assert.False(freezable.IsSealed); 4674Assert.False(freezable.IsFrozen); 4675Assert.False(freezable.IsSealed); 4721Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property6)).IsFrozen); 4724Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property7)).IsFrozen); 4734Assert.False(freezable.IsFrozen); 4735Assert.False(freezable.IsSealed); 4766Assert.False(freezable.IsFrozen); 4767Assert.False(freezable.IsSealed); 4776Assert.False(freezable.IsFrozen); 4777Assert.False(freezable.IsSealed); 4838Assert.False(freezable.IsFrozen); 4839Assert.False(freezable.IsSealed); 4941Assert.False(freezable.IsFrozen); 4942Assert.False(freezable.IsSealed); 4951Assert.False(freezable.IsFrozen); 4952Assert.False(freezable.IsSealed); 5009Assert.False(freezable.IsFrozen); 5010Assert.False(freezable.IsSealed); 5030Assert.False(freezable.IsFrozen); 5031Assert.False(freezable.IsSealed); 5040Assert.False(freezable.IsFrozen); 5041Assert.False(freezable.IsSealed); 5100Assert.False(freezable.IsFrozen); 5101Assert.False(freezable.IsSealed); 5229Assert.False(freezable.IsFrozen); 5230Assert.False(freezable.IsSealed); 5256Assert.False(freezable.IsFrozen); 5257Assert.False(freezable.IsSealed); 5517Assert.False(freezable.IsFrozen); 5518Assert.False(freezable.IsSealed); 5527Assert.False(freezable.IsFrozen); 5528Assert.False(freezable.IsSealed); 5574Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property6)).IsFrozen); 5577Assert.False(((SubFreezable)freezable.GetValue(SubFreezable.Property7)).IsFrozen); 5587Assert.False(freezable.IsFrozen); 5588Assert.False(freezable.IsSealed); 5619Assert.False(freezable.IsFrozen); 5620Assert.False(freezable.IsSealed); 5629Assert.False(freezable.IsFrozen); 5630Assert.False(freezable.IsSealed); 5691Assert.False(freezable.IsFrozen); 5692Assert.False(freezable.IsSealed); 5794Assert.False(freezable.IsFrozen); 5795Assert.False(freezable.IsSealed); 5804Assert.False(freezable.IsFrozen); 5805Assert.False(freezable.IsSealed); 5862Assert.False(freezable.IsFrozen); 5863Assert.False(freezable.IsSealed); 5883Assert.False(freezable.IsFrozen); 5884Assert.False(freezable.IsSealed); 5893Assert.False(freezable.IsFrozen); 5894Assert.False(freezable.IsSealed); 5952Assert.False(freezable.IsFrozen); 5953Assert.False(freezable.IsSealed); 6099Assert.False((bool)obj.GetValue(property)); 6102Assert.False((bool)obj.GetValue(property)); 6154Assert.False((bool)obj.GetValue(property)); 6157Assert.False((bool)obj.GetValue(property)); 6187Assert.False((bool)obj.GetValue(property)); 6713Assert.False((bool)freezable.GetValue(property)); 6743Assert.False((bool)freezable.GetValue(property)); 6788Assert.False((bool)freezable.GetValue(property));
System\Windows\Input\TraversalRequestTests.cs (1)
23Assert.False(request.Wrapped);
System\Windows\Int32RectTests.cs (10)
22Assert.False(rect.HasArea); 62Assert.False(rect.HasArea); 84Assert.False(rect.IsEmpty); 93Assert.False(rect.IsEmpty); 116Assert.False(rect.IsEmpty); 125Assert.False(rect.IsEmpty); 148Assert.False(rect.IsEmpty); 157Assert.False(rect.IsEmpty); 179Assert.False(rect.IsEmpty); 188Assert.False(rect.IsEmpty);
System\Windows\Interop\ComponentDispatcherTests.cs (2)
252Assert.False(ComponentDispatcher.IsThreadModal); 256Assert.False(ComponentDispatcher.IsThreadModal);
System\Windows\LocalValueEnumeratorTests.cs (4)
251Assert.False(enumerator.MoveNext()); 254Assert.False(enumerator.MoveNext()); 268Assert.False(enumerator.MoveNext()); 271Assert.False(enumerator.MoveNext());
System\Windows\Markup\Primitives\MarkupObjectTests.cs (58)
46Assert.False(properties[0].IsAttached); 47Assert.False(properties[0].IsComposite); 48Assert.False(properties[0].IsConstructorArgument); 49Assert.False(properties[0].IsContent); 50Assert.False(properties[0].IsKey); 80Assert.False(properties[0].IsAttached); 82Assert.False(properties[0].IsConstructorArgument); 84Assert.False(properties[0].IsKey); 85Assert.False(properties[0].IsValueAsString); 115Assert.False(properties[0].IsAttached); 116Assert.False(properties[0].IsComposite); 117Assert.False(properties[0].IsConstructorArgument); 118Assert.False(properties[0].IsContent); 119Assert.False(properties[0].IsKey); 120Assert.False(properties[0].IsValueAsString); 134Assert.False(properties[1].IsAttached); 136Assert.False(properties[1].IsConstructorArgument); 138Assert.False(properties[1].IsKey); 139Assert.False(properties[1].IsValueAsString); 174Assert.False(properties[0].IsAttached); 176Assert.False(properties[0].IsConstructorArgument); 178Assert.False(properties[0].IsKey); 179Assert.False(properties[0].IsValueAsString); 210Assert.False(properties[0].IsAttached); 212Assert.False(properties[0].IsConstructorArgument); 214Assert.False(properties[0].IsKey); 215Assert.False(properties[0].IsValueAsString); 248Assert.False(properties[0].IsAttached); 249Assert.False(properties[0].IsComposite); 250Assert.False(properties[0].IsConstructorArgument); 251Assert.False(properties[0].IsContent); 252Assert.False(properties[0].IsKey); 253Assert.False(properties[0].IsValueAsString); 287Assert.False(properties[0].IsAttached); 289Assert.False(properties[0].IsConstructorArgument); 290Assert.False(properties[0].IsContent); 291Assert.False(properties[0].IsKey); 292Assert.False(properties[0].IsValueAsString); 326Assert.False(properties[0].IsAttached); 328Assert.False(properties[0].IsConstructorArgument); 329Assert.False(properties[0].IsContent); 330Assert.False(properties[0].IsKey); 331Assert.False(properties[0].IsValueAsString); 370Assert.False(properties[0].IsAttached); 372Assert.False(properties[0].IsConstructorArgument); 373Assert.False(properties[0].IsContent); 374Assert.False(properties[0].IsKey); 375Assert.False(properties[0].IsValueAsString); 419Assert.False(properties[0].IsAttached); 420Assert.False(properties[0].IsComposite); 422Assert.False(properties[0].IsContent); 423Assert.False(properties[0].IsKey); 424Assert.False(properties[0].IsValueAsString); 438Assert.False(properties[1].IsAttached); 439Assert.False(properties[1].IsComposite); 441Assert.False(properties[1].IsContent); 442Assert.False(properties[1].IsKey); 443Assert.False(properties[1].IsValueAsString);
System\Windows\Markup\Primitives\MarkupPropertyTests.cs (58)
33Assert.False(properties[0].IsAttached); 34Assert.False(properties[0].IsComposite); 35Assert.False(properties[0].IsConstructorArgument); 36Assert.False(properties[0].IsContent); 37Assert.False(properties[0].IsKey); 67Assert.False(properties[0].IsAttached); 69Assert.False(properties[0].IsConstructorArgument); 71Assert.False(properties[0].IsKey); 72Assert.False(properties[0].IsValueAsString); 102Assert.False(properties[0].IsAttached); 103Assert.False(properties[0].IsComposite); 104Assert.False(properties[0].IsConstructorArgument); 105Assert.False(properties[0].IsContent); 106Assert.False(properties[0].IsKey); 107Assert.False(properties[0].IsValueAsString); 121Assert.False(properties[1].IsAttached); 123Assert.False(properties[1].IsConstructorArgument); 125Assert.False(properties[1].IsKey); 126Assert.False(properties[1].IsValueAsString); 161Assert.False(properties[0].IsAttached); 163Assert.False(properties[0].IsConstructorArgument); 165Assert.False(properties[0].IsKey); 166Assert.False(properties[0].IsValueAsString); 197Assert.False(properties[0].IsAttached); 199Assert.False(properties[0].IsConstructorArgument); 201Assert.False(properties[0].IsKey); 202Assert.False(properties[0].IsValueAsString); 235Assert.False(properties[0].IsAttached); 236Assert.False(properties[0].IsComposite); 237Assert.False(properties[0].IsConstructorArgument); 238Assert.False(properties[0].IsContent); 239Assert.False(properties[0].IsKey); 240Assert.False(properties[0].IsValueAsString); 274Assert.False(properties[0].IsAttached); 276Assert.False(properties[0].IsConstructorArgument); 277Assert.False(properties[0].IsContent); 278Assert.False(properties[0].IsKey); 279Assert.False(properties[0].IsValueAsString); 313Assert.False(properties[0].IsAttached); 315Assert.False(properties[0].IsConstructorArgument); 316Assert.False(properties[0].IsContent); 317Assert.False(properties[0].IsKey); 318Assert.False(properties[0].IsValueAsString); 357Assert.False(properties[0].IsAttached); 359Assert.False(properties[0].IsConstructorArgument); 360Assert.False(properties[0].IsContent); 361Assert.False(properties[0].IsKey); 362Assert.False(properties[0].IsValueAsString); 392Assert.False(properties[0].IsAttached); 393Assert.False(properties[0].IsComposite); 395Assert.False(properties[0].IsContent); 396Assert.False(properties[0].IsKey); 397Assert.False(properties[0].IsValueAsString); 411Assert.False(properties[1].IsAttached); 412Assert.False(properties[1].IsComposite); 414Assert.False(properties[1].IsContent); 415Assert.False(properties[1].IsKey); 416Assert.False(properties[1].IsValueAsString);
System\Windows\Media\MatrixTests.cs (12)
5187Assert.False(matrix.IsIdentity); 5197Assert.False(matrix.IsIdentity); 5297Assert.False(matrix.IsIdentity); 5307Assert.False(matrix.IsIdentity); 5378Assert.False(matrix.IsIdentity); 5388Assert.False(matrix.IsIdentity); 5459Assert.False(matrix.IsIdentity); 5469Assert.False(matrix.IsIdentity); 5540Assert.False(matrix.IsIdentity); 5550Assert.False(matrix.IsIdentity); 5621Assert.False(matrix.IsIdentity); 5631Assert.False(matrix.IsIdentity);
System\Windows\NameScopeTests.cs (40)
20Assert.False(nameScope.IsReadOnly); 233Assert.False(property.ReadOnly); 447Assert.False(nameScope.ContainsKey("name")); 448Assert.False(nameScope.Contains(new KeyValuePair<string, object>("name", scopedElement))); 456Assert.False(nameScope.ContainsKey("name")); 457Assert.False(nameScope.Contains(new KeyValuePair<string, object>("name", scopedElement))); 471Assert.False(nameScope.ContainsKey("name")); 472Assert.False(nameScope.Contains(new KeyValuePair<string, object>("name", new object()))); 480Assert.False(nameScope.ContainsKey("name")); 481Assert.False(nameScope.Contains(new KeyValuePair<string, object>("name", new object()))); 568Assert.False(nameScope.Contains(new KeyValuePair<string, object>("NAME", scopedElement))); 569Assert.False(nameScope.Contains(new KeyValuePair<string, object>("nAmE", scopedElement))); 570Assert.False(nameScope.Contains(new KeyValuePair<string, object>("name2", scopedElement))); 571Assert.False(nameScope.Contains(new KeyValuePair<string, object>("", scopedElement))); 588Assert.False(nameScope.Contains(new KeyValuePair<string, object>(name, new object()))); 607Assert.False(nameScope.Contains(new KeyValuePair<string, object>(name, new object()))); 627Assert.False(nameScope.ContainsKey("NAME")); 628Assert.False(nameScope.ContainsKey("nAmE")); 629Assert.False(nameScope.ContainsKey("name2")); 630Assert.False(nameScope.ContainsKey("")); 647Assert.False(nameScope.ContainsKey(name)); 666Assert.False(nameScope.ContainsKey(name)); 743Assert.False(enumerator.MoveNext()); 747Assert.False(enumerator.MoveNext()); 767Assert.False(enumerator.MoveNext()); 771Assert.False(enumerator.MoveNext()); 799Assert.False(enumerator.MoveNext()); 803Assert.False(enumerator.MoveNext()); 823Assert.False(enumerator.MoveNext()); 827Assert.False(enumerator.MoveNext()); 949Assert.False(nameScope.Remove("name")); 975Assert.False(nameScope.Remove(name)); 994Assert.False(nameScope.Remove(name)); 1009Assert.False(nameScope.Remove(new KeyValuePair<string, object>("name", scopedElement))); 1035Assert.False(nameScope.Remove(new KeyValuePair<string, object>(name, new object()))); 1054Assert.False(nameScope.Remove(new KeyValuePair<string, object>(name, new object()))); 1064Assert.False(nameScope.Remove(new KeyValuePair<string, object>("name", new object()))); 1065Assert.False(nameScope.Remove(new KeyValuePair<string, object>("name", null!))); 1094Assert.False(nameScope.TryGetValue(key, out object value)); 1114Assert.False(nameScope.TryGetValue(key, out object value));
System\Windows\PropertyMetadataTests.cs (14)
16Assert.False(metadata.IsSealed); 29Assert.False(metadata.IsSealed); 41Assert.False(metadata.IsSealed); 52Assert.False(metadata.IsSealed); 67Assert.False(metadata.IsSealed); 80Assert.False(metadata.IsSealed); 98Assert.False(metadata.IsSealed); 113Assert.False(metadata.IsSealed); 259Assert.False(metadata.IsSealed); 282Assert.False(metadata.IsSealed); 307Assert.False(metadata.IsSealed); 338Assert.False(metadata.IsSealed); 361Assert.False(metadata.IsSealed); 378Assert.False(metadata.IsSealed);
System\Windows\RectTests.cs (18)
23Assert.False(rect.IsEmpty); 61Assert.False(rect.IsEmpty); 121Assert.False(rect.IsEmpty); 204Assert.False(rect.IsEmpty); 261Assert.False(rect.IsEmpty); 355Assert.False(rect.IsEmpty); 421Assert.False(rect.IsEmpty); 443Assert.False(rect.IsEmpty); 493Assert.False(rect.IsEmpty); 515Assert.False(rect.IsEmpty); 616Assert.False(rect.IsEmpty); 638Assert.False(rect.IsEmpty); 689Assert.False(rect.IsEmpty); 711Assert.False(rect.IsEmpty); 759Assert.False(rect.IsEmpty); 781Assert.False(rect.IsEmpty); 841Assert.False(rect.IsEmpty); 863Assert.False(rect.IsEmpty);
System\Windows\SizeTests.cs (2)
19Assert.False(size.IsEmpty); 39Assert.False(size.IsEmpty);
System\Windows\Threading\DispatcherOperationTests.cs (5)
119Assert.False(operation.Abort()); 142Assert.False(operation.Abort()); 148Assert.False(operation.Abort()); 181Assert.False(operation.Abort()); 211Assert.False(operation.Abort());
System\Windows\Threading\DispatcherPriorityAwaitableTests..cs (2)
34Assert.False(awaiter.IsCompleted); 43Assert.False(awaiter.IsCompleted);
System\Windows\Threading\DispatcherPriorityAwaiterTests.cs (1)
12Assert.False(awaiter.IsCompleted);
System\Windows\Threading\DispatcherTests.cs (4)
17Assert.False(dispatcher.HasShutdownFinished); 18Assert.False(dispatcher.HasShutdownStarted); 36Assert.False(dispatcher.HasShutdownFinished); 37Assert.False(dispatcher.HasShutdownStarted);
System\Windows\Threading\DispatcherTimerTests.cs (7)
16Assert.False(timer.IsEnabled); 36Assert.False(timer.IsEnabled); 56Assert.False(timer.IsEnabled); 281Assert.False(timer.IsEnabled); 286Assert.False(timer.IsEnabled); 299Assert.False(timer.IsEnabled); 304Assert.False(timer.IsEnabled);
System\Windows\WeakEventManagerTests.cs (290)
57Assert.False(list.IsEmpty); 791Assert.False(list.IsEmpty); 799Assert.False(list.IsEmpty); 810Assert.False(list.IsEmpty); 815Assert.False(list.IsEmpty); 824Assert.False(list.IsEmpty); 829Assert.False(list.IsEmpty); 864Assert.False(list.IsEmpty); 872Assert.False(list.IsEmpty); 881Assert.False(list.IsEmpty); 891Assert.False(list.IsEmpty); 902Assert.False(list.IsEmpty); 914Assert.False(list.IsEmpty); 927Assert.False(list.IsEmpty); 963Assert.False(list.IsEmpty); 972Assert.False(list.IsEmpty); 1000Assert.False(list.IsEmpty); 1008Assert.False(list.IsEmpty); 1035Assert.False(list.IsEmpty); 1043Assert.False(list.IsEmpty); 1070Assert.False(list.IsEmpty); 1080Assert.False(list.IsEmpty); 1084Assert.False(list.IsEmpty); 1104Assert.False(list1.IsEmpty); 1112Assert.False(list2.IsEmpty); 1133Assert.False(list1.IsEmpty); 1144Assert.False(list1.IsEmpty); 1147Assert.False(list2.IsEmpty); 1168Assert.False(list1.IsEmpty); 1182Assert.False(list2.IsEmpty); 1212Assert.False(list.IsEmpty); 1264Assert.False(list.IsEmpty); 1272Assert.False(list.IsEmpty); 1283Assert.False(list.IsEmpty); 1288Assert.False(list.IsEmpty); 1297Assert.False(list.IsEmpty); 1302Assert.False(list.IsEmpty); 1335Assert.False(list.IsEmpty); 1344Assert.False(list.IsEmpty); 1374Assert.False(list.IsEmpty); 1382Assert.False(list.IsEmpty); 1408Assert.False(list.IsEmpty); 1416Assert.False(list.IsEmpty); 1442Assert.False(list.IsEmpty); 1452Assert.False(list.IsEmpty); 1456Assert.False(list.IsEmpty); 1474Assert.False(list1.IsEmpty); 1482Assert.False(list2.IsEmpty); 1501Assert.False(list1.IsEmpty); 1512Assert.False(list1.IsEmpty); 1515Assert.False(list2.IsEmpty); 1534Assert.False(list1.IsEmpty); 1548Assert.False(list2.IsEmpty); 1578Assert.False(list.IsEmpty); 1635Assert.False(list.IsEmpty); 1639Assert.False(list.IsEmpty); 1648Assert.False(list.IsEmpty); 1652Assert.False(list.IsEmpty); 1663Assert.False(list.IsEmpty); 1674Assert.False(list.IsEmpty); 1714Assert.False(list.IsEmpty); 1761Assert.False(list.IsEmpty); 1774Assert.False(list.IsEmpty); 1786Assert.False(list.IsEmpty); 1797Assert.False(list.IsEmpty); 1807Assert.False(list.IsEmpty); 1816Assert.False(list.IsEmpty); 1843Assert.False(list.IsEmpty); 1871Assert.False(list2.IsEmpty); 1880Assert.False(list3.IsEmpty); 1912Assert.False(list2.IsEmpty); 1924Assert.False(list1.IsEmpty); 1928Assert.False(list3.IsEmpty); 1936Assert.False(list1.IsEmpty); 1967Assert.False(list1.IsEmpty); 1982Assert.False(list3.IsEmpty); 2019Assert.False(list.IsEmpty); 2026Assert.False(list.IsEmpty); 2044Assert.False(list.IsEmpty); 2051Assert.False(list.IsEmpty); 2104Assert.False(list.IsEmpty); 2173Assert.False(list.IsEmpty); 2177Assert.False(list.IsEmpty); 2186Assert.False(list.IsEmpty); 2190Assert.False(list.IsEmpty); 2201Assert.False(list.IsEmpty); 2212Assert.False(list.IsEmpty); 2252Assert.False(list.IsEmpty); 2279Assert.False(list.IsEmpty); 2304Assert.False(list2.IsEmpty); 2313Assert.False(list3.IsEmpty); 2342Assert.False(list1.IsEmpty); 2354Assert.False(list1.IsEmpty); 2358Assert.False(list3.IsEmpty); 2366Assert.False(list1.IsEmpty); 2394Assert.False(list1.IsEmpty); 2409Assert.False(list3.IsEmpty); 2445Assert.False(list.IsEmpty); 2452Assert.False(list.IsEmpty); 2469Assert.False(list.IsEmpty); 2476Assert.False(list.IsEmpty); 2529Assert.False(list.IsEmpty); 2593Assert.False(manager.Purge(source, data, true)); 2599Assert.False(manager.Purge(source, data, true)); 2620Assert.False(manager.Purge(source, list, false)); 2621Assert.False(list.IsEmpty); 2698Assert.False(manager.Purge(null!, data, true)); 2702Assert.False(manager.Purge(null!, data, true)); 2716Assert.False(manager.Purge(null!, data, true)); 2720Assert.False(manager.Purge(null!, data, true)); 2740Assert.False(manager.Purge(source, data, true)); 2746Assert.False(manager.Purge(source, data, true)); 2765Assert.False(manager.Purge(source, list, false)); 2766Assert.False(list.IsEmpty); 2834Assert.False(manager.Purge(null!, data, true)); 2837Assert.False(manager.Purge(null!, data, true)); 2847Assert.False(manager.Purge(null!, data, true)); 2850Assert.False(manager.Purge(null!, data, true)); 2943Assert.False(list.IsEmpty); 2948Assert.False(list.IsEmpty); 2955Assert.False(list.IsEmpty); 2960Assert.False(list.IsEmpty); 2984Assert.False(list.IsEmpty); 2989Assert.False(list.IsEmpty); 2996Assert.False(list.IsEmpty); 3001Assert.False(list.IsEmpty); 3031Assert.False(list.IsEmpty); 3038Assert.False(list.IsEmpty); 3046Assert.False(list.IsEmpty); 3053Assert.False(list.IsEmpty); 3123Assert.False(ListenerList.PrepareForWriting(ref list)); 3136Assert.False(ListenerList.PrepareForWriting(ref list)); 3143Assert.False(ListenerList.PrepareForWriting(ref list)); 3163Assert.False(ListenerList.PrepareForWriting(ref list)); 3169Assert.False(ListenerList.PrepareForWriting(ref list)); 3187Assert.False(ListenerList.PrepareForWriting(ref list)); 3190Assert.False(list.IsEmpty); 3196Assert.False(ListenerList.PrepareForWriting(ref list)); 3200Assert.False(list.IsEmpty); 3223Assert.False(list.IsEmpty); 3229Assert.False(ListenerList.PrepareForWriting(ref list)); 3232Assert.False(list.IsEmpty); 3255Assert.False(ListenerList.PrepareForWriting(ref list)); 3258Assert.False(list.IsEmpty); 3263Assert.False(ListenerList.PrepareForWriting(ref list)); 3266Assert.False(list.IsEmpty); 3348Assert.False(handler.Target is IWeakEventListener); 3444Assert.False(list.IsEmpty); 3450Assert.False(list.IsEmpty); 3457Assert.False(list.IsEmpty); 3465Assert.False(list.IsEmpty); 3474Assert.False(list.IsEmpty); 3484Assert.False(list.IsEmpty); 3495Assert.False(list.IsEmpty); 3507Assert.False(list.IsEmpty); 3544Assert.False(list.BeginUse()); 3552Assert.False(list.IsEmpty); 3577Assert.False(list.IsEmpty); 3601Assert.False(list.IsEmpty); 3607Assert.False(list.IsEmpty); 3614Assert.False(list.IsEmpty); 3622Assert.False(list.IsEmpty); 3631Assert.False(list.IsEmpty); 3641Assert.False(list.IsEmpty); 3652Assert.False(list.IsEmpty); 3664Assert.False(list.IsEmpty); 3693Assert.False(list.IsEmpty); 3699Assert.False(list.IsEmpty); 3706Assert.False(list.IsEmpty); 3714Assert.False(list.IsEmpty); 3723Assert.False(list.IsEmpty); 3733Assert.False(list.IsEmpty); 3744Assert.False(list.IsEmpty); 3764Assert.False(list.IsEmpty); 3770Assert.False(list.IsEmpty); 3777Assert.False(list.IsEmpty); 3792Assert.False(list.IsEmpty); 3798Assert.False(list.IsEmpty); 3805Assert.False(list.IsEmpty); 3820Assert.False(list.IsEmpty); 3826Assert.False(list.IsEmpty); 3833Assert.False(list.IsEmpty); 3865Assert.False(list.BeginUse()); 3873Assert.False(list.IsEmpty); 3898Assert.False(list.IsEmpty); 3921Assert.False(list.BeginUse()); 3952Assert.False(list.IsEmpty); 3956Assert.False(newList.IsEmpty); 3980Assert.False(list.IsEmpty); 3986Assert.False(newList.IsEmpty); 4016Assert.False(list.IsEmpty); 4024Assert.False(newList.IsEmpty); 4061Assert.False(newList.IsEmpty); 4087Assert.False(newList.IsEmpty); 4119Assert.False(newList.IsEmpty); 4140Assert.False(list.IsEmpty); 4144Assert.False(newList.IsEmpty); 4168Assert.False(list.IsEmpty); 4174Assert.False(newList.IsEmpty); 4204Assert.False(list.IsEmpty); 4212Assert.False(newList.IsEmpty); 4240Assert.False(list.IsEmpty); 4244Assert.False(newList.IsEmpty); 4269Assert.False(list.IsEmpty); 4296Assert.False(list.IsEmpty); 4337Assert.False(list.DeliverEvent(sender, args, managerType)); 4370Assert.False(list.DeliverEvent(sender, args, managerType)); 4427Assert.False(list.DeliverEvent(sender, args, managerType)); 4504Assert.False(list.DeliverEvent(sender, args, managerType)); 4513Assert.False(list.BeginUse()); 4519Assert.False(list.BeginUse()); 4543Assert.False(list.BeginUse()); 4554Assert.False(list.Purge()); 4582Assert.False(list.Purge()); 4584Assert.False(list.IsEmpty); 4601Assert.False(list.Purge()); 4603Assert.False(list.IsEmpty); 4626Assert.False(list.Purge()); 4628Assert.False(list.IsEmpty); 4677Assert.False(list.IsEmpty); 4702Assert.False(list.IsEmpty); 4708Assert.False(list.IsEmpty); 4714Assert.False(list.IsEmpty); 4734Assert.False(list.IsEmpty); 4742Assert.False(list.IsEmpty); 4749Assert.False(list.IsEmpty); 4778Assert.False(list.IsEmpty); 4786Assert.False(list.IsEmpty); 4793Assert.False(list.IsEmpty); 4799Assert.False(list.IsEmpty); 4805Assert.False(list.IsEmpty); 4827Assert.False(list.IsEmpty); 4836Assert.False(list.IsEmpty); 4844Assert.False(list.IsEmpty); 4851Assert.False(list.IsEmpty); 4882Assert.False(list.IsEmpty); 4890Assert.False(list.IsEmpty); 4898Assert.False(list.IsEmpty); 4905Assert.False(list.IsEmpty); 4912Assert.False(list.IsEmpty); 4918Assert.False(list.IsEmpty); 4944Assert.False(list.IsEmpty); 4955Assert.False(list.IsEmpty); 4965Assert.False(list.IsEmpty); 4974Assert.False(list.IsEmpty); 5013Assert.False(list.IsEmpty); 5024Assert.False(list.IsEmpty); 5034Assert.False(list.IsEmpty); 5043Assert.False(list.IsEmpty); 5051Assert.False(list.IsEmpty); 5060Assert.False(list.IsEmpty); 5066Assert.False(list.IsEmpty); 5094Assert.False(list.IsEmpty); 5106Assert.False(list.IsEmpty); 5117Assert.False(list.IsEmpty); 5127Assert.False(list.IsEmpty); 5170Assert.False(list.IsEmpty); 5182Assert.False(list.IsEmpty); 5193Assert.False(list.IsEmpty); 5203Assert.False(list.IsEmpty); 5212Assert.False(list.IsEmpty); 5223Assert.False(list.IsEmpty); 5229Assert.False(list.IsEmpty); 5260Assert.False(list.BeginUse()); 5302Assert.False(list.IsEmpty); 5308Assert.False(list.IsEmpty); 5314Assert.False(list.IsEmpty); 5394Assert.False(list.IsEmpty); 5401Assert.False(list.IsEmpty); 5402Assert.False(list.IsEmpty); 5409Assert.False(list.IsEmpty); 5444Assert.False(list.IsEmpty); 5455Assert.False(list.IsEmpty); 5465Assert.False(list.IsEmpty); 5474Assert.False(list.IsEmpty); 5482Assert.False(list.IsEmpty); 5489Assert.False(list.IsEmpty); 5527Assert.False(list.BeginUse()); 5567Assert.False(list.IsEmpty); 5573Assert.False(list.IsEmpty); 5714Assert.False(list.IsEmpty); 5718Assert.False(newList.IsEmpty); 5742Assert.False(list.IsEmpty); 5748Assert.False(newList.IsEmpty); 5778Assert.False(list.IsEmpty); 5786Assert.False(newList.IsEmpty); 5833Assert.False(list.DeliverEvent(sender, args, managerType)); 5877Assert.False(list.DeliverEvent(sender, args, managerType)); 5945Assert.False(list.DeliverEvent(sender, args, managerType)); 6022Assert.False(list.DeliverEvent(sender, args, managerType));