True

Options\SymbolNamesWithValueOptionTests.cs (15)

NetHttpBindingTests.cs (2)

337Assert.True(secondRequestBlocked); // Captured before releasing the first request 338Assert.True(secondRequestSent); // Validate that header was seen

WSHttpBindingTests.cs (2)

337Assert.True(secondRequestBlocked); // Captured before releasing the first request 338Assert.True(secondRequestSent); // Validate that header was seen

DuplexChannelShapeTests.4.0.0.cs (2)

155Assert.True(imp.MyManualResetEvent.WaitOne(20000)); 184Assert.True(imp.ManualResetEvent.WaitOne(20000));

DuplexChannelWithSynchronizationContext.cs (2)

65Assert.True(syncCtxTask.Wait(ScenarioTestHelpers.TestTimeout)); 130Assert.True(syncCtxTask.Wait(ScenarioTestHelpers.TestTimeout));

SessionTests.cs (2)

474Assert.True(e is CommunicationException); 555Assert.True(e is ExpectedException);

CallbackDebugBehaviorTests.cs (1)

77Assert.True(serviceProxy2.GetResult(includeExceptionDetailInFaults));

CallbackErrorHandlerTests.cs (1)

49Assert.True(result);

XmlSerializerFormatTest.4.0.0.cs (7)

64Assert.True(false); 92Assert.True(response != null); 110Assert.True(response != null); 112Assert.True(!input.BoolValue); 136Assert.True(response != null); 172Assert.True(response != null); 173Assert.True(response.NonInstantiatedField == null);

DatabaseErrorPageMiddlewareTest.cs (2)

404Assert.True( 452Assert.True(

MigrationsEndPointMiddlewareTest.cs (4)

130Assert.True(databaseCreator.Exists()); 166Assert.True(content.Length > 512); 198Assert.True(content.Length > 512); 227Assert.True(content.Length > 512);

WelcomePageSampleTest.cs (1)

26Assert.True(bytes.Length > 1);

AlwaysPassTest.cs (1)

14Assert.True(true);

src\System.Private.ServiceModel\tests\Scenarios\Contract\XmlSerializer\XmlSerializerFormatTest.4.0.0.cs (7)

64Assert.True(false); 92Assert.True(response != null); 110Assert.True(response != null); 112Assert.True(!input.BoolValue); 136Assert.True(response != null); 172Assert.True(response != null); 173Assert.True(response.NonInstantiatedField == null);

SvcutilTests.cs (1)

28Assert.True(File.Exists(outputFile));

Lsp\LspCompletionBenchmarks.cs (1)

104Assert.True(results.IsIncomplete);

TestConnections.cs (1)

177Assert.True(count == 1);

Http2TrailersResetTests.cs (6)

169Assert.True(response2.IsSuccessStatusCode); 186Assert.True(response2.IsSuccessStatusCode); 237Assert.True(response.IsSuccessStatusCode); 298Assert.True(response.IsSuccessStatusCode); 322Assert.True(response.IsSuccessStatusCode); 353Assert.True(headerOrResetFrame.Type == Http2FrameType.HEADERS || headerOrResetFrame.Type == Http2FrameType.RST_STREAM);

src\Servers\IIS\IIS\test\Common.FunctionalTests\CompressionTests.cs (1)

143Assert.True(response.Content.Headers.TryGetValues("Content-Type", out var contentTypes));

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\EventLogHelpers.cs (2)

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds));

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\HttpSysRequestInfoTests.cs (4)

41Assert.True(timings.Length > (int)HttpSysRequestTimingType.Http3HeaderDecodeEnd); 46Assert.True(headerStart > 0); 47Assert.True(headerEnd > 0); 48Assert.True(headerEnd > headerStart);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\MaxRequestBodySizeTests.cs (2)

68Assert.True(result.StatusCode == HttpStatusCode.NotFound || result.StatusCode == HttpStatusCode.RequestEntityTooLarge); 129Assert.True(requestLine.Contains("404") || requestLine.Contains("413"));

src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (3)

347Assert.True(logContents.Contains("[aspnetcorev2_inprocess.dll]") || logContents.Contains("[aspnetcorev2_outofprocess.dll]")); 365Assert.True(DateTime.UtcNow > time); 367Assert.True(DateTime.UtcNow.AddHours(-2) < time);

src\Servers\IIS\IIS\test\Common.FunctionalTests\MaxRequestBodySizeTests.cs (2)

68Assert.True(result.StatusCode == HttpStatusCode.NotFound || result.StatusCode == HttpStatusCode.RequestEntityTooLarge); 129Assert.True(requestLine.Contains("404") || requestLine.Contains("413"));

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (5)

399Assert.True(response.IsSuccessStatusCode); 402Assert.True(response2.IsSuccessStatusCode); 529Assert.True(response.Headers.TryGetValues("UnknownHeader", out var headerValues)); 532Assert.True(response.Content.Headers.TryGetValues(Net.Http.Headers.HeaderNames.ContentType, out headerValues)); 535Assert.True(response.Headers.TryGetValues("MultiHeader", out headerValues));

src\Servers\IIS\IIS\test\IIS.Shared.FunctionalTests\ApplicationInitializationTests.cs (1)

67Assert.True(result.HostProcess.HasExited);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\EventLogHelpers.cs (2)

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds));

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (6)

213Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 738Assert.True(suspendedWaitHandle.WaitOne(TimeoutExtensions.DefaultTimeoutValue)); 919Assert.True(result.IsSuccessStatusCode); 931Assert.True(result.IsSuccessStatusCode); 975Assert.True(response.IsSuccessStatusCode); 1519Assert.True(matchedEntries.Length > 0);

NewHandlerTests.cs (1)

28Assert.True(response.IsSuccessStatusCode);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\EventLogHelpers.cs (2)

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds));

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (6)

213Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 738Assert.True(suspendedWaitHandle.WaitOne(TimeoutExtensions.DefaultTimeoutValue)); 919Assert.True(result.IsSuccessStatusCode); 931Assert.True(result.IsSuccessStatusCode); 975Assert.True(response.IsSuccessStatusCode); 1519Assert.True(matchedEntries.Length > 0);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\EventLogHelpers.cs (2)

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds));

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (6)

213Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 738Assert.True(suspendedWaitHandle.WaitOne(TimeoutExtensions.DefaultTimeoutValue)); 919Assert.True(result.IsSuccessStatusCode); 931Assert.True(result.IsSuccessStatusCode); 975Assert.True(response.IsSuccessStatusCode); 1519Assert.True(matchedEntries.Length > 0);

ShadowCopyTests.cs (21)

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\EventLogHelpers.cs (2)

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds));

ClientDisconnectTests.cs (1)

293Assert.True(!task.IsCompleted);

MaxRequestBodySizeTests.cs (1)

248Assert.True(feature.IsReadOnly);

ResponseAbortTests.cs (3)

143Assert.True(tokenAborted); 156Assert.True(token.WaitHandle.WaitOne(10000)); 157Assert.True(ctx.RequestAborted.WaitHandle.WaitOne(10000));

InProcess\AppOfflineIISExpressTests.cs (1)

64Assert.True(false);

InProcess\IISExpressShutdownTests.cs (2)

86Assert.True(result.HostProcess.ExitCode == 0); 98Assert.True(result.HostProcess.ExitCode == 1);

src\Servers\IIS\IIS\test\Common.FunctionalTests\CompressionTests.cs (1)

143Assert.True(response.Content.Headers.TryGetValues("Content-Type", out var contentTypes));

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\EventLogHelpers.cs (2)

20Assert.True(deploymentResult.HostProcess.HasExited); 39Assert.True(deploymentResult.HostProcess.HasExited);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Infrastructure\Helpers.cs (1)

160Assert.True(hostProcess.WaitForExit(timeout ?? (int)TimeoutExtensions.DefaultTimeoutValue.TotalMilliseconds));

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\HttpSysRequestInfoTests.cs (4)

41Assert.True(timings.Length > (int)HttpSysRequestTimingType.Http3HeaderDecodeEnd); 46Assert.True(headerStart > 0); 47Assert.True(headerEnd > 0); 48Assert.True(headerEnd > headerStart);

src\Servers\IIS\IIS\test\Common.FunctionalTests\Inprocess\MaxRequestBodySizeTests.cs (2)

68Assert.True(result.StatusCode == HttpStatusCode.NotFound || result.StatusCode == HttpStatusCode.RequestEntityTooLarge); 129Assert.True(requestLine.Contains("404") || requestLine.Contains("413"));

src\Servers\IIS\IIS\test\Common.FunctionalTests\LoggingTests.cs (3)

347Assert.True(logContents.Contains("[aspnetcorev2_inprocess.dll]") || logContents.Contains("[aspnetcorev2_outofprocess.dll]")); 365Assert.True(DateTime.UtcNow > time); 367Assert.True(DateTime.UtcNow.AddHours(-2) < time);

src\Servers\IIS\IIS\test\Common.FunctionalTests\MaxRequestBodySizeTests.cs (2)

68Assert.True(result.StatusCode == HttpStatusCode.NotFound || result.StatusCode == HttpStatusCode.RequestEntityTooLarge); 129Assert.True(requestLine.Contains("404") || requestLine.Contains("413"));

src\Servers\IIS\IIS\test\Common.FunctionalTests\RequestResponseTests.cs (5)

399Assert.True(response.IsSuccessStatusCode); 402Assert.True(response2.IsSuccessStatusCode); 529Assert.True(response.Headers.TryGetValues("UnknownHeader", out var headerValues)); 532Assert.True(response.Content.Headers.TryGetValues(Net.Http.Headers.HeaderNames.ContentType, out headerValues)); 535Assert.True(response.Headers.TryGetValues("MultiHeader", out headerValues));

src\Servers\IIS\IIS\test\Common.LongTests\StartupTests.cs (6)

213Assert.True(File.Exists(Path.Combine(deploymentResult.ContentRoot, "InProcessWebSite.exe"))); 738Assert.True(suspendedWaitHandle.WaitOne(TimeoutExtensions.DefaultTimeoutValue)); 919Assert.True(result.IsSuccessStatusCode); 931Assert.True(result.IsSuccessStatusCode); 975Assert.True(response.IsSuccessStatusCode); 1519Assert.True(matchedEntries.Length > 0);

BadHttpRequestTests.cs (1)

359Assert.True(badRequestEventListener.EventFired);

CertificateLoaderTests.cs (2)

24Assert.True(CertificateLoader.IsCertificateAllowedForServerAuth(cert)); 39Assert.True(CertificateLoader.IsCertificateAllowedForServerAuth(cert));

ChunkedRequestTests.cs (2)

592Assert.True(string.IsNullOrEmpty(request.Headers["X-Trailer-Header"])); 928Assert.True((await requestTask).IsCanceled);

ChunkedResponseTests.cs (2)

203Assert.True(length <= memory.Length); 1045Assert.True(memory.Length >= 1000000);

ConnectionLimitTests.cs (1)

46Assert.True(await lockedTcs.Task.DefaultTimeout());

Http2\Http2ConnectionTests.cs (39)

Http2\Http2StreamTests.cs (57)

Http2\Http2TestBase.cs (1)

1240Assert.True(buffer.Length > 0);

Http2\Http2TimeoutTests.cs (2)

390Assert.True((await _pair.Application.Input.ReadAsync().AsTask().DefaultTimeout()).IsCompleted); 445Assert.True((await _pair.Application.Input.ReadAsync().AsTask().DefaultTimeout()).IsCompleted);

Http2\Http2WebSocketTests.cs (9)

23Assert.True(connectFeature.IsExtendedConnect); 85Assert.True(connectFeature.IsExtendedConnect); 161Assert.True(connectFeature.IsExtendedConnect); 250Assert.True(_connection.StreamPool.TryPeek(out var pooledStream)); 398Assert.True(maxRequestBodySizeFeature.IsReadOnly); 400Assert.True(maxRequestBodySizeFeature.IsReadOnly); 524Assert.True(connectFeature.IsExtendedConnect); 600Assert.True(connectFeature.IsExtendedConnect); 687Assert.True(_connection.StreamPool.TryPeek(out var pooledStream));

Http3\Http3ConnectionTests.cs (5)

73Assert.True(requestStream.Disposed); 333Assert.True(lifetime.ConnectionClosedRequested.IsCancellationRequested); 616Assert.True(data.TryGetValue($"trailer-{i}", out var trailerValue) && bool.Parse(trailerValue)); 674Assert.True(requestStream.Disposed); 728Assert.True(requestStream.Disposed);

Http3\Http3StreamTests.cs (46)

Http3\WebTransport\WebTransportHandshakeTests.cs (1)

82Assert.True(await appCompletedTcs.Task);

Http3\WebTransport\WebTransportSessionTests.cs (4)

26Assert.True(streamDirectionFeature.CanWrite); 50Assert.True(streamDirectionFeature.CanWrite); 51Assert.True(streamDirectionFeature.CanRead); 59Assert.True(streamDirectionFeature2.CanRead);

HttpsConnectionMiddlewareTests.cs (7)

295Assert.True(stream.RemoteCertificate.Equals(_x509Certificate2)); 325Assert.True(stream.RemoteCertificate.Equals(_x509Certificate2)); 358Assert.True(stream.RemoteCertificate.Equals(_x509Certificate2)); 393Assert.True(stream.RemoteCertificate.Equals(_x509Certificate2)); 400Assert.True(stream.RemoteCertificate.Equals(_x509Certificate2NoExt)); 462Assert.True(stream.RemoteCertificate.Equals(_x509Certificate2)); 1190Assert.True(clientCertificateValidationCalled);

HttpsTests.cs (3)

71Assert.True(ranUseHttpsAction); 128Assert.True(ranUseHttpsAction); 161Assert.True(ranUseHttpsAction);

KestrelMetricsTests.cs (4)

176Assert.True(result.Buffer.Length > 0); 751Assert.True(m.Value > 0); 911Assert.True(m.Value > 0); 932Assert.True(measurement.Value > 0);

MaxRequestBodySizeTests.cs (4)

71Assert.True(requestBody.Length > maxRequestBodySize); 118Assert.True(chunkedPayload.Length > maxRequestBodySize); 295Assert.True(feature.IsReadOnly); 335Assert.True(feature.IsReadOnly);

RequestTests.cs (5)

209Assert.True(dataRead); 972Assert.True(readResult.IsCompleted); 1202Assert.True(readResult.IsCompleted); 1833Assert.True(bodyControlFeature.AllowSynchronousIO); 1917Assert.True((await requestTask).IsCanceled);

ResponseTests.cs (12)

224Assert.True(result.IsCompleted); 251Assert.True(cancelledResult.IsCanceled); 2853Assert.True(onCompletedCalled1); 2854Assert.True(onCompletedCalled2); 2898Assert.True(onStartingCalled); 2943Assert.True(onStartingCalled); 3242Assert.True(httpContext.Response.HasStarted); 3331Assert.True(httpContext.Response.HasStarted); 3369Assert.True(httpContext.Response.HasStarted); 3399Assert.True(httpContext.Response.HasStarted); 3477Assert.True(httpContext.Response.HasStarted); 3668Assert.True(bodyControlFeature.AllowSynchronousIO);

src\Servers\Kestrel\shared\test\StreamExtensions.cs (1)

45Assert.True(offset >= buffer.Length);

TlsListenerTests.cs (4)

47Assert.True(clientHelloBytes.Length > 32); 70Assert.True(tlsClientHelloCallbackInvoked); 90Assert.True(clientHelloBytes.Length > 32); 102Assert.True(readResult.IsCompleted);

UpgradeTests.cs (3)

173Assert.True(feature.IsUpgradableRequest); 198Assert.True(feature.IsUpgradableRequest); 246Assert.True(feature.IsUpgradableRequest);

Startup.cs (15)

367Assert.True(IPAddress.IsLoopback(ctx.Connection.LocalIpAddress)); 371Assert.True(IPAddress.IsLoopback(ctx.Connection.RemoteIpAddress)); 430Assert.True(10 <= memory.Length); 439Assert.True(10 <= memory.Length); 443Assert.True(10 <= memory.Length); 1166Assert.True(ctx.Request.Headers.ContainsKey("Transfer-Encoding")); 1184Assert.True(ctx.Request.Headers.ContainsKey("Transfer-Encoding")); 1187Assert.True(ctx.Request.Headers.ContainsKey("X-Content-Length")); 1202Assert.True(context.Response.SupportsTrailers()); 1215Assert.True(context.Response.SupportsTrailers()); 1681Assert.True(context.Request.IsHttps); 1695Assert.True(context.Request.IsHttps); 1714Assert.True(context.Request.IsHttps); 1728Assert.True(context.Request.IsHttps); 1744Assert.True(context.Request.IsHttps);

Startup.WebSockets.cs (1)

40Assert.True(upgradeFeature.IsUpgradableRequest);

InteractiveHostCoreTests.cs (2)

39Assert.True(errorOutput.StartsWith("Stack overflow.\n")); 40Assert.True(errorOutput.EndsWith(string.Format(InteractiveHostResources.Hosting_process_exited_with_exit_code_0, process!.ExitCode)));

InteractiveHostDesktopInitTests.cs (2)

77Assert.True(result); 84Assert.True(result);

InteractiveHostDesktopTests.cs (28)

117Assert.True(mayTerminate.WaitOne()); 124Assert.True(execution); 165Assert.True(mayTerminate.WaitOne()); 195Assert.True(execution); 291Assert.True(mayTerminate.WaitOne()); 294Assert.True(await Execute(@"1+1")); 305Assert.True(await LoadReference(Path.Combine(fxDir, "System.Data.dll"))); 306Assert.True(await Execute("new System.Data.DataSet()")); 313Assert.True(await LoadReference("System.Data")); 314Assert.True(await Execute("new System.Data.DataSet()")); 321Assert.True(await LoadReference("System.Data")); 322Assert.True(await LoadReference("System")); 323Assert.True(await LoadReference("System.Xml")); 333Assert.True(await LoadReference("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")); 334Assert.True(await Execute("new System.Data.DataSet()")); 346Assert.True(result); 353Assert.True(result); 360Assert.True(result); 374Assert.True(await LoadReference(c.Path)); 375Assert.True(await Execute("new C()")); 387Assert.True(result); 442Assert.True(await LoadReference(main.Path)); 443Assert.True(await Execute("Program.Main()")); 464Assert.True(await LoadReference(file1.Path)); 465Assert.True(await LoadReference(file2.Path)); 470Assert.True(await LoadReference(main.Path)); 471Assert.True(await Execute("Program.Main()")); 980Assert.True(error.StartsWith($"{new Exception().GetType()}: {new Exception().Message}"));

H2SpecCommands.cs (1)

250Assert.True(process.Start());

Http2\Http2RequestTests.cs (2)

75Assert.True(measurement.Value > 0); 144Assert.True(m.Value > 0);

Http2WebSocketInteropTests.cs (4)

62Assert.True(context.WebSockets.IsWebSocketRequest); 66Assert.True(result.EndOfMessage); 90Assert.True(result.EndOfMessage); 115Assert.True(context.WebSockets.IsWebSocketRequest);

Http3\Http3RequestTests.cs (7)

106Assert.True(m.Value > 0); 1089Assert.True(request2Headers.ContainsKey("alt-used")); 1105Assert.True(request3Headers.ContainsKey("alt-used")); 1350Assert.True(memoryPool.ContainsMemory(memory)); 1769Assert.True(hasWriteLog); 1774Assert.True(hasReadLog); 2354Assert.True(ranHandler);

Http3\Http3TlsTests.cs (5)

67Assert.True(serverCertificateSelectorActionCalled); 249Assert.True(response.IsSuccessStatusCode); 478Assert.True(ranConfigureKestrelAction); 479Assert.True(ranUseHttpsAction); 506Assert.True(ranCertificateValidation);

HttpClientHttp2InteropTests.cs (7)

281Assert.True(sequence.IsSingleSegment); 287Assert.True(finalResult.IsCompleted && finalResult.Buffer.Length == 0); 338Assert.True(sequence.IsSingleSegment); 353Assert.True(readResult.Buffer.IsSingleSegment); 358Assert.True(finalResult.IsCompleted && finalResult.Buffer.Length == 0); 1205Assert.True(sync.Wait(0)); 1266Assert.True(sync.Wait(0));

src\Servers\Kestrel\shared\test\StreamExtensions.cs (1)

45Assert.True(offset >= buffer.Length);

Resources\RoslynTestUtils.cs (1)

66Assert.True(proj.Solution.Workspace.TryApplyChanges(proj.Solution));

Json\JsonArrayTest.cs (3)

106Assert.True(obj.Contains("b")); 136Assert.True(genericEnumerator.MoveNext()); 137Assert.True(legacyEnumerator.MoveNext());

Json\JsonObjectTest.cs (4)

30Assert.True(obj.Remove("x")); 52Assert.True(obj.ContainsKey("x")); 73Assert.True(obj.Contains(value)); 80Assert.True(obj.Contains(((KeyValuePair<string, JsonValue>)value).Value));

Json\JsonValueTest.cs (34)

Resources\RoslynTestUtils.cs (1)

66Assert.True(proj.Solution.Workspace.TryApplyChanges(proj.Solution));

CompilationFeatureDetectorTest.cs (3)

36Assert.True(StartupFacts.IsStartupClass(symbols, type)); 76Assert.True(StartupFacts.IsStartupClass(symbols, type)); 116Assert.True(StartupFacts.IsStartupClass(symbols, type));

MinimalStartupTest.cs (2)

83Assert.True(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); 108Assert.True(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));

StartupAnalyzerTest.cs (2)

149Assert.True(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis)); 186Assert.True(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));

StartupFactsTest.cs (3)

127Assert.True(result); 175Assert.True(result); 216Assert.True(result);

AntiforgeryApplicationBuilderExtensionsTest.cs (1)

25Assert.True(builder.Properties.ContainsKey("__AntiforgeryMiddlewareSet"));

AntiforgeryMiddlewareTest.cs (1)

73Assert.True(httpContext.Items.ContainsKey("__AntiforgeryMiddlewareWithEndpointInvoked"));

AntiforgeryTokenTest.cs (1)

56Assert.True(token.IsCookieToken);

DefaultAntiforgeryTest.cs (29)

DefaultAntiforgeryTokenGeneratorTest.cs (4)

261Assert.True(isValid); 530Assert.True(result); 564Assert.True(result); 597Assert.True(result);

DefaultAntiforgeryTokenStoreTest.cs (4)

389Assert.True(cookies.Options!.HttpOnly); 428Assert.True(cookies.Options!.HttpOnly); 468Assert.True(cookies.Options!.HttpOnly); 507Assert.True(cookies.Options!.HttpOnly);

Dependencies\AddPackageTests.cs (2)

38Assert.True(MockAddPackageFixer.Invoked); 58Assert.True(MockAddPackageFixer.Invoked);

Dependencies\ExtensionMethodsCompletionProviderTests.cs (6)

39Assert.True(result.ShouldTriggerCompletion); 62Assert.True(result.ShouldTriggerCompletion); 85Assert.True(result.ShouldTriggerCompletion); 108Assert.True(result.ShouldTriggerCompletion); 131Assert.True(result.ShouldTriggerCompletion); 154Assert.True(result.ShouldTriggerCompletion);

Infrastructure\AmbiguousRoutePatternComparerTests.cs (3)

24Assert.True(result); 52Assert.True(result); 83Assert.True(token.IsKind(SyntaxKind.StringLiteralToken));

RouteEmbeddedLanguage\RoutePatternClassifierTests.cs (1)

29Assert.True(spans.Length == 1);

RouteEmbeddedLanguage\RoutePatternParserTests.cs (2)

37Assert.True(token.IsKind(SyntaxKind.StringLiteralToken)); 143Assert.True(allChars.IsDefault);

TargetingPackTests.cs (1)

217Assert.True(assemblyName.ProcessorArchitecture == ProcessorArchitecture.MSIL ||

AsyncContextHttpContextOfTTests.cs (3)

39Assert.True(_context.TryGet(out Thing? stored)); 46Assert.True(_context.TryGet(out Thing? stored)); 90Assert.True(_context.TryGet(out Thing? stored));

AuthenticationPropertiesTests.cs (2)

172Assert.True(props.IsPersistent); 339Assert.True(deserialized.Items.ContainsKey("foo"));

AuthenticationSchemeProviderTests.cs (8)

166Assert.True(o.TryAddScheme(new AuthenticationScheme("signin", "whatever", typeof(Handler)))); 167Assert.True(o.TryAddScheme(new AuthenticationScheme("signin2", "whatever", typeof(Handler)))); 169Assert.True(o.TryAddScheme(new AuthenticationScheme("signin3", "whatever", typeof(Handler)))); 172Assert.True(o.TryAddScheme(new AuthenticationScheme("signin2", "whatever", typeof(Handler)))); 211Assert.True(provider.TryAddScheme(scheme1)); 219Assert.True(provider.TryAddScheme(scheme2)); 223Assert.True(provider.TryAddScheme(scheme3)); 243Assert.True(provider.TryAddScheme(scheme2));

AuthenticationTicketTests.cs (1)

41Assert.True(ticket.Principal.HasClaim("name", "value"));

TokenExtensionTests.cs (3)

91Assert.True(props.UpdateTokenValue("One", ".11")); 92Assert.True(props.UpdateTokenValue("Two", ".22")); 93Assert.True(props.UpdateTokenValue("Three", ".33"));

UserJwtsTests.cs (13)

302Assert.True(secretsJson.ContainsKey(SigningKeysHandler.GetSigningKeyPropertyName(DevJwtsDefaults.Scheme))); 303Assert.True(secretsJson.TryGetPropertyValue("Foo", out var fooField)); 482Assert.True(handler.CanReadToken(output.Trim())); 523Assert.True(Convert.TryFromBase64String(signingKey["Value"].GetValue<string>(), new byte[32], out var _)); 524Assert.True(secretsJson.TryGetPropertyValue("Foo", out var fooField)); 551Assert.True(Convert.TryFromBase64String(signingKey["Value"].GetValue<string>(), new byte[32], out var _)); 552Assert.True(secretsJson.TryGetPropertyValue("Foo", out var fooField)); 587Assert.True(secretsJson.ContainsKey(SigningKeysHandler.GetSigningKeyPropertyName("test-scheme"))); 590Assert.True(Convert.TryFromBase64String(signingKey["Value"].GetValue<string>(), new byte[32], out var _)); 609Assert.True(secretsJson.ContainsKey(SigningKeysHandler.GetSigningKeyPropertyName("test-scheme"))); 634Assert.True(Convert.TryFromBase64String(signingKey1["Value"].GetValue<string>(), new byte[32], out var _)); 638Assert.True(Convert.TryFromBase64String(signingKey2["Value"].GetValue<string>(), new byte[32], out var _)); 688Assert.True(Convert.TryFromBase64String(key, buffer, out var bytesParsed));

EventTests.cs (2)

43Assert.True(eventInvoked); 280Assert.True(identity.IsAuthenticated);

NegotiateHandlerTests.cs (1)

279Assert.True(context.User.Identity.IsAuthenticated);

ServerDeferralTests.cs (1)

38Assert.True(options.DeferToServer);

AuthenticationMetricsTest.cs (4)

37Assert.True(measurement.Value > 0); 65Assert.True(measurement.Value > 0); 93Assert.True(measurement.Value > 0); 122Assert.True(measurement.Value > 0);

AuthenticationMiddlewareTests.cs (6)

79Assert.True(authenticateResultFeature.AuthenticateResult.Succeeded); 122Assert.True(authenticateResultFeature.AuthenticateResult.Succeeded); 148Assert.True(authenticateResultFeature.AuthenticateResult.Succeeded); 176Assert.True(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); 177Assert.True(app.Properties.ContainsKey("__AuthorizationMiddlewareSet")); 196Assert.True(app.Properties.ContainsKey("__AuthenticationMiddlewareSet"));

CertificateTests.cs (2)

48Assert.True(Certificates.SelfSignedValidWithNoEku.IsSelfSigned()); 316Assert.True(failCalled);

CookieTests.cs (5)

203Assert.True(transaction.Response.Headers.CacheControl.NoCache); 204Assert.True(transaction.Response.Headers.CacheControl.NoStore); 336Assert.True(transaction.Response.Headers.CacheControl.NoCache); 337Assert.True(transaction.Response.Headers.CacheControl.NoStore); 1123Assert.True(c.Principal.Identities.First().HasClaim("marker", "true"));

GoogleTests.cs (7)

70Assert.True(queryParams.ContainsKey("redirect_uri")); 71Assert.True(queryParams.ContainsKey("scope")); 72Assert.True(queryParams.ContainsKey("state")); 73Assert.True(queryParams.ContainsKey("code_challenge")); 361Assert.True(result.None); 489Assert.True(accessDeniedCalled); 490Assert.True(remoteFailureCalled);

JwtBearerTests.cs (3)

126Assert.True(options.MapInboundClaims); 132Assert.True(jwtHandler.MapInboundClaims); 136Assert.True(tokenHandler.MapInboundClaims);

JwtBearerTests_Handler.cs (10)

117Assert.True(options.MapInboundClaims); 123Assert.True(jwtHandler.MapInboundClaims); 127Assert.True(tokenHandler.MapInboundClaims); 986Assert.True(jwtBearerOptions.SaveToken); 988Assert.True(jwtBearerOptions.TokenValidationParameters.ValidateIssuerSigningKey); 990Assert.True(jwtBearerOptions.MapInboundClaims); 991Assert.True(jwtBearerOptions.TokenValidationParameters.ValidateIssuer); 992Assert.True(jwtBearerOptions.TokenValidationParameters.ValidateAudience); 1069Assert.True(jwtBearerOptions.TokenValidationParameters.ValidateIssuer); 1070Assert.True(jwtBearerOptions.TokenValidationParameters.ValidateAudience);

OpenIdConnect\OpenIdConnectChallengeTests.cs (7)

272Assert.True(eventIsHit); 441Assert.True(nonceCookie.Expires.HasValue); 442Assert.True(nonceCookie.Expires > DateTime.UtcNow); 443Assert.True(nonceCookie.HttpOnly); 449Assert.True(correlationCookie.Expires.HasValue); 450Assert.True(nonceCookie.Expires > DateTime.UtcNow); 451Assert.True(correlationCookie.HttpOnly);

OpenIdConnect\OpenIdConnectEventTests.cs (3)

1015Assert.True(response.Headers.TryGetValues(HeaderNames.SetCookie, out var values)); 1016Assert.True(SetCookieHeaderValue.TryParseStrictList(values.ToList(), out var parsedValues)); 1018Assert.True(StringSegment.IsNullOrEmpty(parsedValues.Single().Value));

OpenIdConnect\OpenIdConnectEventTests_Handler.cs (3)

1015Assert.True(response.Headers.TryGetValues(HeaderNames.SetCookie, out var values)); 1016Assert.True(SetCookieHeaderValue.TryParseStrictList(values.ToList(), out var parsedValues)); 1018Assert.True(StringSegment.IsNullOrEmpty(parsedValues.Single().Value));

OpenIdConnect\OpenIdConnectTests.cs (9)

254Assert.True(query.TryGetValue("post_logout_redirect_uri", out redirectUri)); 258Assert.True(query.TryGetValue("state", out state)); 285Assert.True(query.TryGetValue("post_logout_redirect_uri", out redirectUri)); 289Assert.True(query.TryGetValue("state", out state)); 383Assert.True(options.MapInboundClaims); 388Assert.True(jwtHandler.MapInboundClaims); 489Assert.True(options.CorrelationCookie.HttpOnly); 492Assert.True(options.NonceCookie.IsEssential); 493Assert.True(options.NonceCookie.HttpOnly);

TokenExtensionTests.cs (3)

87Assert.True(props.UpdateTokenValue("One", ".11")); 88Assert.True(props.UpdateTokenValue("Two", ".22")); 89Assert.True(props.UpdateTokenValue("Three", ".33"));

TwitterTests.cs (6)

219Assert.True(transaction.Response.Headers.TryGetValues(HeaderNames.SetCookie, out var setCookie)); 220Assert.True(SetCookieHeaderValue.TryParseList(setCookie.ToList(), out var setCookieValues)); 269Assert.True(transaction.Response.Headers.TryGetValues(HeaderNames.SetCookie, out var setCookie)); 270Assert.True(SetCookieHeaderValue.TryParseList(setCookie.ToList(), out var setCookieValues)); 376Assert.True(transaction.Response.Headers.TryGetValues(HeaderNames.SetCookie, out var setCookie)); 377Assert.True(SetCookieHeaderValue.TryParseList(setCookie.ToList(), out var setCookieValues));

AuthorizationAppBuilderExtensionsTests.cs (1)

40Assert.True(authenticationService.ChallengeCalled);

AuthorizationEndpointConventionBuilderExtensionsTests.cs (2)

117Assert.True(chainedBuilder.TestProperty); 248Assert.True(chainedBuilder.TestProperty);

AuthorizationMetricsTest.cs (1)

35Assert.True((bool)measurement.Tags["aspnetcore.user.is_authenticated"]);

AuthorizationMiddlewareTests.cs (24)

DefaultAuthorizationServiceTests.cs (29)

PassThroughAuthorizationHandlerTests.cs (1)

45Assert.True(willFail.Invoked);

PolicyEvaluatorTests.cs (7)

44Assert.True(result.Succeeded); 63Assert.True(result.Succeeded); 80Assert.True(result.Succeeded); 100Assert.True(result2.Succeeded); 116Assert.True(result.Challenged); 134Assert.True(result.Forbidden); 154Assert.True(result.Forbidden);

TransformTest.cs (1)

89Assert.True(transform.Apply(doc));

AuthorizeRouteViewTest.cs (1)

350Assert.True(render2Task.IsCompletedSuccessfully);

src\Components\Shared\test\AssertFrame.cs (2)

113Assert.True(string.IsNullOrWhiteSpace(frame.TextContent)); 120Assert.True(string.IsNullOrWhiteSpace(frame.TextContent));

src\Components\Shared\test\AutoRenderComponent.cs (1)

30Assert.True(t.IsCompleted);

src\Components\Shared\test\TestRenderer.cs (1)

82Assert.True(task.IsCompleted);

Binding\FormDataMapperTests.cs (4)

590Assert.True(result.Count == maxCollectionSize || result.Count == maxCollectionSize - 1); 1087Assert.True(result.Count == maxCollectionSize || result.Count == maxCollectionSize - 1); 1281Assert.True(((IEnumerable<TElement>)expected).SequenceEqual((IEnumerable<TElement>)list)); 2093Assert.True(result);

Binding\FormDataMetadataFactoryTests.cs (5)

334Assert.True(metadata.IsRecursive); 367Assert.True(metadata.IsRecursive); 385Assert.True(property.PropertyMetadata.IsRecursive); 421Assert.True(metadata.IsRecursive); 458Assert.True(metadata.IsRecursive);

Binding\PrefixResolverTests.cs (8)

18Assert.True(result); 43Assert.True(result); 61Assert.True(result); 96Assert.True(result); 136Assert.True(result); 176Assert.True(result); 200Assert.True(result); 224Assert.True(result);

Buffering\BufferedTextWriterTest.cs (1)

68Assert.True(flushAsyncTask3.IsCompleted);

Buffering\TextChunkPageTest.cs (3)

19Assert.True(page.TryAdd(new TextChunk("Item1"))); 20Assert.True(page.TryAdd(new TextChunk("Item2"))); 21Assert.True(page.TryAdd(new TextChunk("Item3")));

FormMapping\BrowserFileFromFormFileTests.cs (4)

61Assert.True(result); 62Assert.True(found); 98Assert.True(result); 99Assert.True(found);

FormMapping\Converters\NullableConverterTests.cs (13)

23Assert.True(returnValue); 38Assert.True(returnValue); 75Assert.True(returnValue); 97Assert.True(found); 98Assert.True(returnValue); 121Assert.True(found); 122Assert.True(returnValue); 147Assert.True(found); 162Assert.True(returnValue); 164Assert.True(result.Value.WasEmptyOrNull); 177Assert.True(returnValue); 179Assert.True(result.Value.WasEmptyOrNull); 195Assert.True(returnValue);

HotReloadServiceTests.cs (2)

37Assert.True(invoked); 194Assert.True(wrappedChangeTokenDisposable.IsDisposed);

ImportMapTest.cs (1)

315Assert.True(task.IsCompleted);

src\Components\Shared\test\AutoRenderComponent.cs (1)

30Assert.True(t.IsCompleted);

TypeNameHashTest.cs (1)

64Assert.True(type.FullName.Length > TypeNameHash.MaxStackBufferSize);

WebRootComponentParametersTest.cs (4)

85Assert.True(result); 99Assert.True(result); 141Assert.True(result); 169Assert.True(result);

EditContextDataAnnotationsExtensionsTest.cs (4)

75Assert.True(editContext.Validate()); 95Assert.True(editContext.Validate()); 101Assert.True(editContext.Validate()); 179Assert.True(editContext.Validate());

EditContextTest.cs (12)

FieldIdentifierTest.cs (3)

88Assert.True(fieldIdentifier1.Equals(fieldIdentifier2)); 101Assert.True(fieldIdentifier1.Equals(fieldIdentifier2)); 115Assert.True(fieldIdentifier1.Equals(fieldIdentifier2));

src\Components\Shared\test\AssertFrame.cs (2)

113Assert.True(string.IsNullOrWhiteSpace(frame.TextContent)); 120Assert.True(string.IsNullOrWhiteSpace(frame.TextContent));

src\Components\Shared\test\AutoRenderComponent.cs (1)

30Assert.True(t.IsCompleted);

src\Components\Shared\test\TestRenderer.cs (1)

82Assert.True(task.IsCompleted);

GridRaceConditionTest.cs (1)

49Assert.True(testJsRuntime.JsModuleDisposed);

src\Components\Shared\test\AssertFrame.cs (2)

113Assert.True(string.IsNullOrWhiteSpace(frame.TextContent)); 120Assert.True(string.IsNullOrWhiteSpace(frame.TextContent));

src\Components\Shared\test\AutoRenderComponent.cs (1)

30Assert.True(t.IsCompleted);

src\Components\Shared\test\TestRenderer.cs (1)

82Assert.True(task.IsCompleted);

Circuits\CircuitActivitySourceTest.cs (3)

55Assert.True(activity.IsAllDataRequested); 61Assert.True(activity.IsStopped); 81Assert.True(activity!.IsStopped);

Circuits\CircuitClientProxyTest.cs (1)

46Assert.True(circuitClient.Connected);

Circuits\CircuitHostTest.cs (11)

40Assert.True(remoteRenderer.Disposed); 66Assert.True(remoteRenderer.Disposed); 92Assert.True(throwOnDisposeComponent.DidCallDispose); 94Assert.True(remoteRenderer.Disposed); 117Assert.True(component.Called); 393Assert.True(asyncLocal1ValueInHandler); 394Assert.True(asyncLocal3ValueInHandler); 412Assert.True(wasHandlerFuncInvoked); 438Assert.True(result); 1100Assert.True(task.IsCompletedSuccessfully); 1143Assert.True(task.IsCompletedSuccessfully);

Circuits\CircuitMetricsTest.cs (3)

117Assert.True(durationMeasurements[0].Value > 0); 131Assert.True(circuitMetrics.IsDurationEnabled()); 188Assert.True(durationMeasurements[0].Value > 0);

Circuits\CircuitRegistryTest.cs (6)

171Assert.True(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out _)); 323Assert.True(circuitPersistenceProvider.PersistCalled); 432Assert.True(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out var _)); 462Assert.True(registry.ConnectedCircuits.TryGetValue(circuitHost.CircuitId, out var cacheValue)); 483Assert.True(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out _)); 559Assert.True(registry.ConnectedCircuits.TryGetValue(circuitHost.CircuitId, out var connectedCircuit));

Circuits\ComponentHubTest.cs (2)

133Assert.True(called); 276Assert.True(lastCircuit.HasPendingPersistedCircuitState);

Circuits\RemoteJSDataStreamTest.cs (9)

69Assert.True(sendDataCompleted); 97Assert.True(sendDataCompleted); 227Assert.True(unhandledExceptionResult); 266Assert.True(success); 270Assert.True(success); 276Assert.True(unhandledExceptionResult); 306Assert.True(linkedCts.Token.IsCancellationRequested); 330Assert.True(linkedCts.HasLinkedCancellationTokenSource); 342Assert.True(linkedCts.Token.IsCancellationRequested);

Circuits\RemoteRendererTest.cs (2)

770Assert.True(task.IsCompletedSuccessfully); 799Assert.True(task.IsCompletedSuccessfully);

Circuits\RevalidatingServerAuthenticationStateProviderTest.cs (1)

168Assert.True(firstRevalidationCall.CancellationToken.IsCancellationRequested);

Circuits\ServerComponentDeserializerTest.cs (17)

ComponentEndpointRouteBuilderExtensionsTest.cs (4)

34Assert.True(called); 53Assert.True(called); 85Assert.True(called); 121Assert.True(called);

ProtectedBrowserStorageTest.cs (2)

111Assert.True(result.Success); 138Assert.True(result.Success);

src\SignalR\common\SignalR.Common\test\Internal\Protocol\MessagePackHubProtocolTestBase.cs (4)

230Assert.True(HubProtocol.TryParseMessage(ref data, new TestBinder(testData.Message), out var message)); 255Assert.True(HubProtocol.TryParseMessage(ref data, new TestBinder(expectedMessage), out var message)); 276Assert.True(BinaryMessageParser.TryParseMessage(ref byteSpan, out var unframed)); 480Assert.True(BinaryMessageParser.TryParseMessage(ref data, out var message));

BindConverterTest.cs (3)

313Assert.True(successfullyConverted); 341Assert.True(successfullyConverted); 354Assert.True(successfullyConverted);

CascadingParameterStateTest.cs (1)

390Assert.True(hasSingleDeliveryParameters);

ComponentBaseTest.cs (7)

224Assert.True(@event.IsSet); 269Assert.True(firstRender); 280Assert.True(onAfterRenderCompleted); 297Assert.True(onAfterRenderCompleted); 313Assert.True(firstRender); 326Assert.True(onAfterRenderCompleted); 347Assert.True(onAfterRenderCompleted);

ComponentFactoryTest.cs (1)

151Assert.True(renderer.ResolverWasCalled);

ComponentsActivitySourceTest.cs (7)

61Assert.True(activity.IsAllDataRequested); 67Assert.True(activity.IsStopped); 97Assert.True(activity.IsAllDataRequested); 104Assert.True(activity.IsStopped); 124Assert.True(activity!.IsStopped); 144Assert.True(activity!.IsStopped); 164Assert.True(activity!.IsStopped);

ComponentsMetricsTest.cs (22)

EventCallbackFactoryTest.cs (18)

EventCallbackTest.cs (2)

289Assert.True(result); 451Assert.True(result);

LayoutViewTest.cs (8)

28Assert.True(setParametersTask.IsCompletedSuccessfully); 47Assert.True(setParametersTask.IsCompletedSuccessfully); 67Assert.True(setParametersTask.IsCompletedSuccessfully); 97Assert.True(setParametersTask.IsCompletedSuccessfully); 129Assert.True(setParametersTask.IsCompletedSuccessfully); 169Assert.True(setParametersTask.IsCompletedSuccessfully); 211Assert.True(setParametersTask1.IsCompletedSuccessfully); 220Assert.True(setParametersTask2.IsCompletedSuccessfully);

NavigationManagerTest.cs (31)

OwningComponentBaseTest.cs (1)

52Assert.True(component1.IsDisposedPublic);

ParameterViewTest.cs (5)

141Assert.True(didFind); 464Assert.True(hasRemovedDirectParameters); 489Assert.True(hasRemovedDirectParameters); 515Assert.True(hasRemovedDirectParameters); 542Assert.True(hasRemovedDirectParameters);

PersistentState\ComponentStatePersistenceManagerTest.cs (7)

57Assert.True(persistenceManager.State.TryTakeFromJson<byte[]>("MyState", out var retrieved)); 130Assert.True(testStore.State.TryGetValue(typeof(PersistentServicesRegistry).FullName, out var registrations)); 159Assert.True(store.State.TryGetValue("MyState", out var persisted)); 182Assert.True(invoked); 271Assert.True(invoked); 302Assert.True(invoked); 398Assert.True(callbackInvoked);

PersistentState\PersistentComponentStateTest.cs (8)

28Assert.True(applicationState.TryTakeFromJson<byte[]>("MyState", out var existing)); 76Assert.True(applicationState.TryTakeFromJson<byte[]>("MyState", out var existing)); 96Assert.True(currentState.TryGetValue("MyState", out var stored)); 132Assert.True(currentState.TryGetValue("MyState", out var stored)); 150Assert.True(currentState.TryGetValue("MyState", out var stored)); 166Assert.True(applicationState.TryTakeFromJson<byte[]>("MyState", out var stored)); 184Assert.True(applicationState.TryTakeFromJson<byte[]>("MyState", out var stored)); 207Assert.True(callbackInvoked);

PersistentState\RestoreContextTest.cs (3)

17Assert.True(result); 53Assert.True(result); 103Assert.True(result);

PersistentStateValueProviderKeyResolverTests.cs (4)

93Assert.True(newState.TryTakeFromJson<string>(key1, out var retrievedValue1)); 96Assert.True(newState.TryTakeFromJson<string>(key2, out var retrievedValue2)); 148Assert.True(newState.TryTakeFromJson<string>(key1, out var retrievedValue1)); 151Assert.True(newState.TryTakeFromJson<string>(key2, out var retrievedValue2));

RendererTest.cs (45)

Rendering\RendererSynchronizationContextTest.cs (2)

360Assert.True(e3.IsSet); 367Assert.True(e4.IsSet);

Rendering\RenderTreeBuilderTest.cs (1)

2122Assert.True(frame.ComponentFrameFlags.HasFlag(ComponentFrameFlags.HasCallerSpecifiedRenderMode));

Rendering\SimplifiedStringHashComparerTest.cs (1)

11Assert.True(SimplifiedStringHashComparer.Instance.Equals("abc", "ABC"));

ResourceAssetCollectionTest.cs (1)

89Assert.True(isContentSpecificUrl2);

Routing\RouteKeyTest.cs (4)

17Assert.True(key1.Equals(key2)); 29Assert.True(key1.Equals(key2)); 65Assert.True(key1.Equals(key2)); 77Assert.True(key1.Equals(key2));

Routing\RouterTest.cs (3)

56Assert.True(called); 114Assert.True(true); 167Assert.True(true);

Routing\RouteTableFactoryTests.cs (9)

src\Components\Shared\test\AssertFrame.cs (2)

113Assert.True(string.IsNullOrWhiteSpace(frame.TextContent)); 120Assert.True(string.IsNullOrWhiteSpace(frame.TextContent));

src\Components\Shared\test\AutoRenderComponent.cs (1)

30Assert.True(t.IsCompleted);

src\Components\Shared\test\TestRenderer.cs (1)

82Assert.True(task.IsCompleted);

Forms\InputBaseTest.cs (6)

196Assert.True(rootComponent.EditContext.IsModified(() => model.StringProperty)); 300Assert.True(rootComponent.EditContext.IsModified(fieldIdentifier)); 325Assert.True(rootComponent.EditContext.IsModified(fieldIdentifier)); 335Assert.True(rootComponent.EditContext.IsModified(fieldIdentifier)); 397Assert.True(component.AdditionalAttributes.ContainsKey("aria-invalid")); 517Assert.True(component.AdditionalAttributes.ContainsKey("aria-invalid"));

Forms\InputRadioTest.cs (1)

42Assert.All(inputRadioComponents, inputRadio => Assert.True(Guid.TryParseExact(inputRadio.GroupName, "N", out _)));

src\Components\Shared\test\AssertFrame.cs (2)

113Assert.True(string.IsNullOrWhiteSpace(frame.TextContent)); 120Assert.True(string.IsNullOrWhiteSpace(frame.TextContent));

src\Components\Shared\test\AutoRenderComponent.cs (1)

30Assert.True(t.IsCompleted);

src\Components\Shared\test\TestRenderer.cs (1)

82Assert.True(task.IsCompleted);

ContentEncodingNegotiatorTests.cs (14)

Hosting\WebAssemblyHostBuilderTest.cs (3)

65Assert.True(factory.CreateServiceProviderCalled); 87Assert.True(factory.CreateServiceProviderCalled); 131Assert.True(WebAssemblyHostEnvironmentExtensions.IsDevelopment(builder.HostEnvironment));

Infrastructure\AssertHelpers.cs (3)

15Assert.True(IpcCommon.TryDeserializeOutgoing(message, out var messageType, out var args)); 23Assert.True(IpcCommon.TryDeserializeOutgoing(message, out var messageType, out var args)); 32Assert.True(IpcCommon.TryDeserializeOutgoing(message, out var messageType, out var args));

StaticContentProviderTests.cs (2)

27Assert.True(scp.TryGetResponseContent( 40Assert.True(headers.TryGetValue("Content-Type", out var contentTypeValue));

MiddlewareTests.cs (6)

26Assert.True(flag); 44Assert.True(onRejectedInvoked); 122Assert.True(flag); 171Assert.True(firstRequest.IsCompletedSuccessfully); 176Assert.True(thirdRequest.IsCompletedSuccessfully); 197Assert.True(flag);

PolicyTests\QueuePolicyTests.cs (11)

16Assert.True(t1.IsCompleted); 19Assert.True(t2.IsCompleted); 29Assert.True(await s.TryEnterAsync().DefaultTimeout()); 35Assert.True(await waitingTask.DefaultTimeout()); 45Assert.True(t1.IsCompleted); 46Assert.True(t1.Result); 49Assert.True(t2.IsCompleted); 50Assert.True(t2.Result); 56Assert.True(t4.IsCompleted); 67Assert.True(await s1.TryEnterAsync().DefaultTimeout()); 68Assert.True(await s2.TryEnterAsync().DefaultTimeout());

PolicyTests\StackPolicyTests.cs (12)

21Assert.True(task1.IsCompleted); 22Assert.True(await task1); 30Assert.True(await task2); 45Assert.True(task1.IsCompleted); 74Assert.True(task1.IsCompleted); 77Assert.True(task2.IsCompleted); 93Assert.True(task1.IsCompleted && await task1); 99Assert.True(await task2); 104Assert.True(task3.IsCompleted && await task3); 117Assert.True(task0.IsCompleted && await task0); 123Assert.True(await task1); 129Assert.True(await task2);

CookieConsentTests.cs (66)

CookiePolicyTests.cs (8)

402Assert.True(cookie.HttpOnly); 403Assert.True(cookie.Secure); 455Assert.True(cookie.HttpOnly); 456Assert.True(cookie.Secure); 462Assert.True(cookie.HttpOnly); 463Assert.True(cookie.Secure); 469Assert.True(cookie.HttpOnly); 470Assert.True(cookie.Secure);

CorsEndpointConventionBuilderExtensionsTests.cs (2)

51Assert.True(metadata.Policy.AllowAnyOrigin); 85Assert.True(builder.TestProperty);

CorsMiddlewareTests.cs (1)

797Assert.True(executed);

CorsPolicyBuilderTests.cs (6)

31Assert.True(corsPolicy.SupportsCredentials); 170Assert.True(corsPolicy.AllowAnyOrigin); 200Assert.True(corsPolicy.IsOriginAllowed("http://test.example.com")); 243Assert.True(corsPolicy.AllowAnyMethod); 273Assert.True(corsPolicy.AllowAnyHeader); 316Assert.True(corsPolicy.SupportsCredentials);

CorsPolicyExtensionsTests.cs (2)

20Assert.True(actual); 58Assert.True(isAllowed);

CorsPolicyTests.cs (1)

25Assert.True(corsPolicy.IsDefaultIsOriginAllowed);

CorsServiceTests.cs (6)

169Assert.True(result.SupportsCredentials); 221Assert.True(result.VaryByOrigin); 238Assert.True(result.VaryByOrigin); 390Assert.True(result.SupportsCredentials); 558Assert.True(result.SupportsCredentials); 917Assert.True(result.VaryByOrigin);

UriHelpersTests.cs (1)

16Assert.True(isSubdomain);

CryptoUtilTests.cs (2)

19Assert.True(CryptoUtil.TimeConstantBuffersAreEqual(a.AsSpan(1, 3), b.AsSpan(2, 3))); 40Assert.True(CryptoUtil.TimeConstantBuffersAreEqual((byte*)&a, (byte*)&b, sizeof(uint)));

WeakReferenceHelpersTests.cs (4)

25Assert.True(wr.TryGetTarget(out var target)); 43Assert.True(wr.TryGetTarget(out var target)); 67Assert.True(wr.TryGetTarget(out var target)); 71Assert.True(instanceThatWillBeCreatedSecond.HasBeenDisposed);

ActivatorTests.cs (1)

51Assert.True(retVal3.ParameterlessCtorCalled);

ContainerUtilsTests.cs (1)

51Assert.True(ContainerUtils.IsDirectoryMounted(new DirectoryInfo(directory), fstab));

Internal\KeyManagementOptionsPostSetupTest.cs (7)

52Assert.True(options.AutoGenerateKeys); 71Assert.True(options.AutoGenerateKeys); 96Assert.True(options.AutoGenerateKeys); 123Assert.True(options.AutoGenerateKeys); 139Assert.True(options.AutoGenerateKeys); 153Assert.True(options.AutoGenerateKeys); 178Assert.True(options.AutoGenerateKeys);

KeyManagement\CacheableKeyRingTests.cs (2)

27Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now.UtcDateTime)); 42Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now.UtcDateTime));

KeyManagement\DefaultKeyResolverTests.cs (9)

27Assert.True(resolution.ShouldGenerateNewKey); 122Assert.True(resolution.ShouldGenerateNewKey); 138Assert.True(resolution.ShouldGenerateNewKey); 168Assert.True(resolution.ShouldGenerateNewKey); 203Assert.True(resolution.ShouldGenerateNewKey); 221Assert.True(resolution.ShouldGenerateNewKey); 238Assert.True(resolution.ShouldGenerateNewKey); 306Assert.True(resolution.ShouldGenerateNewKey); 385Assert.True(resolution.ShouldGenerateNewKey);

KeyManagement\DeferredKeyTests.cs (1)

55Assert.True(key.IsRevoked);

KeyManagement\KeyRingBasedDataProtectorTests.cs (3)

455Assert.True(requiresMigration); 456Assert.True(wasRevoked); 553Assert.True(requiresMigration);

KeyManagement\KeyRingProviderTests.cs (16)

49Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 92Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 140Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 142Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 229Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 231Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 313Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 315Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 353Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 391Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now)); 439Assert.True(activation1 < now); // Key1 is active 440Assert.True(now < activation2); // Key2 is not yet active 441Assert.True(now < expiration1); // Key1 is not expired (also implies activation1 < expiration1) 442Assert.True(activation2 < expiration2); // Key2 is not well-formed (also implies Key2 is unexpired, now < expiration2) 443Assert.True(activation2 < expiration1); // Key1 and Key2 have overlapping activation periods - the alternative is covered in other tests 799Assert.True(resolveDefaultKeyPolicyReturnValuesEnumerator.MoveNext());

KeyManagement\KeyRingTests.cs (2)

78Assert.True(isRevoked); 81Assert.True(isRevoked);

KeyManagement\KeyTests.cs (1)

45Assert.True(key.IsRevoked);

KeyManagement\XmlKeyManagerTests.cs (13)

125Assert.True(firstCancellationToken.IsCancellationRequested); 223Assert.True(firstCancellationToken.IsCancellationRequested); 450Assert.True(keys[0].IsRevoked); 452Assert.True(keys[1].IsRevoked); 456Assert.True(keys[3].IsRevoked); 647Assert.True(firstCancellationToken.IsCancellationRequested); 700Assert.True(firstCancellationToken.IsCancellationRequested); 965Assert.True(keyDictWithRevocations[key1.KeyId].IsRevoked); 966Assert.True(keyDictWithRevocations[key2.KeyId].IsRevoked); 967Assert.True(keyDictWithRevocations[key3.KeyId].IsRevoked); 970Assert.True(keyManager.DeleteKeys(key => key.KeyId == key1.KeyId || key.KeyId == key3.KeyId)); 977Assert.True(keyDictWithRevocations[key2.KeyId].IsRevoked); 990Assert.True(withDeletion.CanDeleteKeys);

Repositories\EphemeralXmlRepositoryTests.cs (4)

55Assert.True(repository.DeleteElements(deletableElements => 76Assert.True(ranSelector); 95Assert.True(repository.DeleteElements(deletableElements => 106Assert.True(ranSelector);

Repositories\FileSystemXmlRepositoryTests.cs (11)

160Assert.True(repository.DeleteElements(deletableElements => 181Assert.True(ranSelector); 209Assert.True(File.Exists(filePath1)); 210Assert.True(File.Exists(filePath2)); 211Assert.True(File.Exists(filePath3)); 233Assert.True(ranSelector); 240Assert.True(File.Exists(filePath1)); // Deletion not attempted after failure 241Assert.True(File.Exists(filePath2)); // Deletion fails because of lock 256Assert.True(File.Exists(filePath)); 260Assert.True(repository.DeleteElements(deletableElements => 271Assert.True(ranSelector);

Repositories\RegistryXmlRepositoryTests.cs (4)

148Assert.True(repository.DeleteElements(deletableElements => 169Assert.True(ranSelector); 202Assert.True(repository.DeleteElements(deletableElements => 213Assert.True(ranSelector);

ServiceCollectionTests.cs (1)

124Assert.True(options.AutoGenerateKeys);

CertificateManagerTests.cs (12)

50Assert.True(File.Exists(CertificateName)); 58Assert.True(httpsCertificate.HasPrivateKey); 149Assert.True(File.Exists(CertificateName)); 153Assert.True(exportedCertificate.HasPrivateKey); 183Assert.True(File.Exists(CertificateName)); 187Assert.True(exportedCertificate.HasPrivateKey); 216Assert.True(File.Exists(CertificateName)); 311Assert.True(CertificateManager.IsHttpsDevelopmentCertificate(wrongSubjectCertificate)); 345Assert.True(File.Exists(CertificateName)); 349Assert.True(exportedCertificate.HasPrivateKey); 538Assert.True(File.Exists(CertificateName)); 541Assert.True(File.Exists(KeyName));

Latency\AcceptanceTests.cs (5)

62Assert.True(IsMatchByName(ld.Checkpoints, (c) => c.Name == checkpointName)); 63Assert.True(IsMatchByName(ld.Measures, (m) => m.Name == measureName)); 64Assert.True(IsMatchByName(ld.Tags, (t) => t.Name == tagName)); 65Assert.True(((double)ld.DurationTimestamp / ld.DurationTimestampFrequency) * 1000 >= taskTimeMs); 81Assert.True(isInLambda);

Latency\AddServerTimingHeaderMiddlewareTests.cs (1)

46Assert.True(header.Count > 0);

Latency\ChecpointAcceptanceTests.cs (2)

64Assert.True(reachedLambda); 133Assert.True(long.TryParse(metricFragments[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var value));

Latency\RequestLatencyTelemetryExtensionsTests.cs (1)

64Assert.True(actualOptions.Value.LatencyDataExportTimeout == expectedOptions.LatencyDataExportTimeout);

Latency\RequestLatencyTelemetryMiddlewareTests.cs (16)

45Assert.True(header.Count > 0); 47Assert.True(nextInvoked); 48Assert.True(ex1.Invoked == 1); 49Assert.True(ex2.Invoked == 1); 75Assert.True(nextInvoked); 76Assert.True(ex1.Invoked == 1); 77Assert.True(ex2.Invoked == 1); 103Assert.True(header.Count > 0); 105Assert.True(nextInvoked); 106Assert.True(ex1.Invoked == 1); 107Assert.True(ex2.Invoked == 1); 134Assert.True(nextInvoked); 135Assert.True(ex1.Invoked == 1); 136Assert.True(ex2.Invoked == 1); 157Assert.True(nextInvoked); 183Assert.True(nextInvoked);

Latency\RequestLatencyTelemetryOptionsValidatorTests.cs (2)

17Assert.True(validator.Validate(nameof(RequestLatencyTelemetryOptions), options).Failed); 26Assert.True(validationResult.Succeeded);

Logging\AcceptanceTests.cs (14)

Logging\AcceptanceTests.Mvc.cs (4)

66Assert.True(response.IsSuccessStatusCode); 101Assert.True(response.IsSuccessStatusCode); 147Assert.True(response.IsSuccessStatusCode); 191Assert.True(response.IsSuccessStatusCode);

Logging\AcceptanceTests.Routing.cs (1)

66Assert.True(response.IsSuccessStatusCode);

Logging\IncomingHttpRouteUtilityTests.cs (18)

Logging\RequestHeadersEnricherTests.cs (2)

104Assert.True(enrichedState.Count == 2); 286Assert.True(enrichedState.Count == 0);

DeveloperExceptionPageMiddlewareTest.cs (1)

616Assert.True(m.Value > 0);

ExceptionHandlerMiddlewareTest.cs (12)

ExceptionHandlerTest.cs (23)

WebApplicationFunctionalTests.cs (7)

37Assert.True(false); 48Assert.True(logWritten); 80Assert.True(false); 91Assert.True(logWritten); 134Assert.True(false); 168Assert.True(logWritten); 169Assert.True(logger.IsEnabled(LogLevel.Warning));

WebHostFunctionalTests.cs (1)

142Assert.True(logWritten);

ConverterTests\JsonConverterReadTests.cs (1)

869Assert.True(objectNew.Equals(objectOld));

ConverterTests\JsonConverterWriteTests.cs (1)

622Assert.True(comparer.Equals(doc1.RootElement, doc2.RootElement));

HttpRoutePatternParserTests.cs (3)

194Assert.True(v.HasCatchAllPath); 255Assert.True(v.HasCatchAllPath); 277Assert.True(v.HasCatchAllPath);

JsonTranscodingServerCallContextTests.cs (1)

55Assert.True(headers[1].IsBinary);

ServiceDescriptorHelpersTests.cs (1)

18Assert.True(ServiceDescriptorHelpers.TryGetHttpRule(method, out var httpRule));

UnaryServerCallHandlerTests.cs (2)

1416Assert.True((bool)interceptorRun!); 1559Assert.True(request!.Data.SingleBool);

Binding\BodyTests.cs (4)

28Assert.True(path.Operations.TryGetValue(OperationType.Post, out var operation)); 47Assert.True(path.Operations.TryGetValue(OperationType.Post, out var operation)); 63Assert.True(path.Operations.TryGetValue(OperationType.Post, out var operation)); 77Assert.True(path.Operations.TryGetValue(OperationType.Post, out var operation));

Binding\ParametersTests.cs (9)

Binding\ResponseBodyTests.cs (4)

29Assert.True(path.Operations.TryGetValue(OperationType.Post, out var operation)); 43Assert.True(path.Operations.TryGetValue(OperationType.Post, out var operation)); 59Assert.True(path.Operations.TryGetValue(OperationType.Post, out var operation)); 84Assert.True(path.Operations.TryGetValue(OperationType.Post, out var operation));

GrpcSwaggerServiceExtensionsTests.cs (4)

48Assert.True(path.Operations.TryGetValue(OperationType.Get, out var operation)); 82Assert.True(swagger.Paths["/v1/greeter/{name}"].Operations.ContainsKey(OperationType.Get)); 87Assert.True(swagger.Paths["/v1/greeter/{name}"].Operations.ContainsKey(OperationType.Get)); 88Assert.True(swagger.Paths["/v1/add/{value1}/{value2}"].Operations.ContainsKey(OperationType.Get));

HeaderKeyTests.cs (1)

53Assert.True(sut.HasDefaultValue);

HeaderParsingExtensionsTests.cs (3)

27Assert.True(options.DefaultValues.ContainsKey("Test")); 112Assert.True(context.Request.TryGetHeaderValue(dateHeaderKey, out var parsedDate, out var result)); 116Assert.True(context.Request.TryGetHeaderValue(dateHeaderKey, out parsedDate));

HeaderParsingFeatureTests.cs (10)

HeaderRegistryTests.cs (1)

48Assert.True(key.HasDefaultValue);

HostHeaderValueTests.cs (4)

32Assert.True(sameAsHost1.Equals((object)host1)); 49Assert.True(host1 == sameAsHost1); 54Assert.True(host1 != differentHost); 55Assert.True(host1 != differentPort);

HeaderPropagationIntegrationTest.cs (4)

117Assert.True(handler.Headers.Contains("out")); 144Assert.True(handler.Headers.Contains("first")); 146Assert.True(handler.Headers.Contains("second")); 190Assert.True(handler.Headers.Contains("different"));

HeaderPropagationMessageHandlerTest.cs (13)

HostFilteringMiddlewareTests.cs (2)

106Assert.True(c.Request.Headers.TryGetValue(HeaderNames.Host, out var host)); 107Assert.True(StringValues.Equals("", host));

MiddlewareConfigurationManagerTests.cs (6)

37Assert.True(configurationBeforeChange.AllowedHosts is null); 41Assert.True(options.AllowedHosts.All(x => configurationBeforeChange.AllowedHosts.Contains(x))); 60Assert.True(configurationAfterChange.AllowedHosts is null); 64Assert.True(newOption.AllowedHosts.All(x => configurationAfterChange.AllowedHosts.Contains(x))); 88Assert.True(options.AllowedHosts.All(x => result1.AllowedHosts.Contains(x)) && options.AllowedHosts.Count.Equals(result1.AllowedHosts.Count)); 93Assert.True(ReferenceEquals(result1, result2));

HostingApplicationDiagnosticsTests.cs (22)

91m => Assert.True(m.Value > 0)); 93m => Assert.True(m.Value > 0)); 129m => Assert.True(m.Value > 0), 130m => Assert.True(m.Value > 0)); 132m => Assert.True(m.Value > 0), 133m => Assert.True(m.Value > 0)); 168Assert.True(context.EventLogEnabled); 233Assert.True(context.MetricsEnabled); 350Assert.True(m.Value > 0); 415Assert.True(m.Value > 0); 509Assert.True(context.MetricsTagsFeature.MetricsDisabled); 628Assert.True(isEnabledActivityFired); 665Assert.True(isEnabledActivityFired); 666Assert.True(isEnabledStartFired); 692Assert.True(startCalled); 709Assert.True(Activity.Current.Duration > TimeSpan.Zero); 717Assert.True(endCalled); 733Assert.True(Activity.Current.Duration > TimeSpan.Zero); 741Assert.True(endCalled); 763Assert.True(endCalled); 1078Assert.True(onActivityImportCalled); 1080Assert.True(Activity.Current.Recorded);

HostingMetricsTests.cs (2)

94Assert.True(measurement.Value > 0); 107Assert.True((bool)measurement.Tags["aspnetcore.request.is_unhandled"]);

Http\DefaultHttpContextFactoryTests.cs (2)

94Assert.True(context._active); 113Assert.True(context._active);

StartupManagerTests.cs (6)

329Assert.True(instance.DisposableService.Disposed); 355Assert.True(options.Configured); 402Assert.True(options.Configured); 481Assert.True(foo.Invoked); 559Assert.True(((MyContainer)app.ApplicationServices).FancyMethodCalled); 575Assert.True(((MyContainer)app.ApplicationServices).FancyMethodCalled);

StaticWebAssets\ManifestStaticWebAssetsFileProviderTests.cs (6)

288Assert.True(file.Exists); 321Assert.True(file.Exists); 338Assert.True(contents.Exists); 340Assert.True(file.Exists); 357Assert.True(file.Exists); 393Assert.True(provider.GetFileInfo("/_content/Static Web Assets.txt").Exists);

WebHostBuilderTests.cs (7)

264Assert.True(configurationCallbackCalled); 446Assert.True(service.Disposed); 687Assert.True(Path.IsPathRooted(basePath)); 690Assert.True(Path.IsPathRooted(basePath2)); 999Assert.True(disposables[0].Disposed); 1000Assert.True(disposables[1].Disposed); 1395Assert.True(service.StopCalled);

WebHostConfigurationsTests.cs (3)

31Assert.True(config.CaptureStartupErrors); 32Assert.True(config.DetailedErrors); 33Assert.True(config.SuppressStatusMessages);

WebHostTests.AsyncDisposable.cs (1)

41Assert.True(provider.DisposeAsyncCalled);

WebHostTests.cs (35)

EndpointFilterInvocationContextOfTTests.cs (1)

64Assert.True(context.Contains("This is a test"));

FragmentStringTests.cs (2)

15Assert.True(FragmentString.Empty == default(FragmentString)); 16Assert.True(default(FragmentString) == FragmentString.Empty);

HostStringTest.cs (3)

104Assert.True(new HostString(string.Empty) == default(HostString)); 105Assert.True(default(HostString) == new HostString(string.Empty)); 146Assert.True(HostString.MatchesAny(host, new StringSegment[] { pattern }));

MapPathMiddlewareTests.cs (2)

225Assert.True(mockWebApplication.UseCalled); 235Assert.True(mockWebApplication.UseCalled);

PathStringTests.cs (6)

25Assert.True(PathString.Empty == default(PathString)); 26Assert.True(default(PathString) == PathString.Empty); 27Assert.True(PathString.Empty.Equals(default(PathString))); 28Assert.True(default(PathString).Equals(PathString.Empty)); 296Assert.True(converter.CanConvertFrom(typeof(string))); 299Assert.True(converter.CanConvertTo(typeof(string)));

QueryStringTests.cs (3)

38Assert.True(query.HasValue); 137Assert.True(QueryString.Empty == default(QueryString)); 138Assert.True(default(QueryString) == QueryString.Empty);

RouteValueDictionaryTests.cs (38)

UseExtensionsTests.cs (5)

27Assert.True(firstCalled); 33Assert.True(secondCalled); 42Assert.True(firstCalled); 43Assert.True(secondCalled); 44Assert.True(lastCalled);

UseMiddlewareTest.cs (2)

273Assert.True(Assert.IsType<bool>(context.Items["before"])); 274Assert.True(Assert.IsType<bool>(context.Items["after"]));

HttpConnectionDispatcherTests.cs (41)

98Assert.True(manager.TryGetConnection(connectionToken, out var connectionContext)); 125Assert.True(manager.TryGetConnection(connectionToken, out var connection)); 244Assert.True(connection.Transport.Input.TryRead(out var result)); 480Assert.True(result.IsCompleted); 544Assert.True(result.IsCompleted); 612Assert.True(connection.Transport.Input.TryRead(out var result)); 790Assert.True(task.IsCompleted); 1174Assert.True(measurement.Value > 0); 1306Assert.True(connection.SendingToken.IsCancellationRequested); 1345Assert.True(connection.SendingToken.IsCancellationRequested); 1389Assert.True(connection.SendingToken.IsCancellationRequested); 1495Assert.True(request1.IsCompleted); 1562Assert.True(request1.IsCompleted); 1725Assert.True(task.IsCompleted); 1766Assert.True(task1.IsCompleted); 1971Assert.True(((WindowsIdentity)connection.User.Identity).AccessToken.IsClosed); 1999Assert.True(connection.HasInherentKeepAlive); 2002Assert.True(connection.Features.Get<IConnectionInherentKeepAliveFeature>().HasInherentKeepAlive); 2070Assert.True(pollTask.IsCompleted); 2175Assert.True(pollTask.IsCompleted); 2201Assert.True(manager.TryGetConnection(connection.ConnectionId, out _)); 2305Assert.True(manager.TryGetConnection(negotiateResponse["connectionToken"].ToString(), out var connection)); 2334Assert.True(manager.TryGetConnection(negotiateResponse["connectionToken"].ToString(), out var connection)); 2361Assert.True((bool)negotiateResponse["useStatefulReconnect"]); 2363Assert.True(manager.TryGetConnection(negotiateResponse["connectionToken"].ToString(), out var connection)); 2781Assert.True(pollTask.IsCompleted); 2809Assert.True(manager.TryGetConnection(connection.ConnectionId, out _)); 3280Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context)); 3282Assert.True(context.AuthenticationExpiration > DateTimeOffset.UtcNow); 3283Assert.True(context.AuthenticationExpiration < DateTimeOffset.MaxValue); 3342Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context)); 3344Assert.True(context.AuthenticationExpiration > DateTimeOffset.UtcNow); 3345Assert.True(context.AuthenticationExpiration < DateTimeOffset.MaxValue); 3442Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context)); 3444Assert.True(context.AuthenticationExpiration > DateTimeOffset.UtcNow); 3445Assert.True(context.AuthenticationExpiration < DateTimeOffset.MaxValue); 3481Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context)); 3522Assert.True(((HttpRequestTimeoutFeature)c.Features.Get<IHttpRequestTimeoutFeature>()).Enabled); 3559Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context)); 3584Assert.True(((HttpRequestTimeoutFeature)context.Features.Get<IHttpRequestTimeoutFeature>()).Enabled); 3591Assert.True(((HttpRequestTimeoutFeature)context.Features.Get<IHttpRequestTimeoutFeature>()).Enabled);

HttpConnectionManagerTests.cs (11)

129Assert.True(result.IsCompleted); 132Assert.True(result.IsCompleted); 152Assert.True(connectionManager.TryGetConnection(connection.ConnectionToken, out var newConnection)); 170Assert.True(connectionManager.TryGetConnection(connection.ConnectionToken, out var newConnection)); 189Assert.True(connectionManager.TryGetConnection(connection.ConnectionToken, out var newConnection)); 211Assert.True(connectionManager.TryGetConnection(connection.ConnectionToken, out var newConnection)); 232Assert.True(connectionManager.TryGetConnection(connection.ConnectionToken, out var newConnection)); 255Assert.True(result.IsCompleted); 268Assert.True(result.IsCanceled); 405Assert.True(result.IsCompleted); 424Assert.True(result.IsCompleted);

MapConnectionHandlerTests.cs (1)

345Assert.True(optionsMetaData.CloseOnAuthenticationExpiration);

ServerSentEventsTests.cs (1)

57Assert.True(feature.ResponseBufferingDisabled);

WebSocketsTests.cs (2)

104Assert.True(clientSummary.Received[0].EndOfMessage); 425Assert.True(messages.Received[1].EndOfMessage);

ParameterBindingMethodCacheTests.cs (26)

ProblemDetailsDefaultWriterTest.cs (1)

653Assert.True(result);

ProblemDetailsServiceTest.cs (1)

59Assert.True(result);

PropertyAsParameterInfoTests.cs (1)

157Assert.True(parameterInfo.HasDefaultValue);

RequestDelegateFactoryTests.cs (16)

RequestDelegateGenerator\CompileTimeCreationTests.cs (1)

609Assert.True(endpointModel.Response.IsAwaitable);

RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (1)

152Assert.True(result.Success);

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBody.cs (2)

333Assert.True(result.IsCompleted); 374Assert.True(result.IsCompleted);

RequestDelegateGenerator\RequestDelegateCreationTests.Metadata.cs (6)

532m => Assert.True(m is IAcceptsMetadata am && am.RequestType == typeof(AddsCustomParameterMetadata)), 534m => Assert.True(m is IParameterBindingMetadata { Name: "param1" }), 538m => Assert.True(m is ParameterNameMetadata { Name: "param1" }), 540m => Assert.True(m is CustomEndpointMetadata { Source: MetadataSource.Parameter }), 542m => Assert.True(m is MetadataCountMetadata), 544m => Assert.True(m is CustomEndpointMetadata { Source: MetadataSource.Caller }));

RequestDelegateGenerator\RequestDelegateCreationTests.Responses.cs (8)

166Assert.True(endpointModel.Response.IsAwaitable); 191Assert.True(endpointModel.Response.IsAwaitable); 219Assert.True(endpointModel.Response.IsAwaitable); 241Assert.True(endpointModel.Response.IsAwaitable); 242Assert.True(endpointModel.Response.HasNoResponse); 247Assert.True(endpointModel.Response.IsAwaitable); 248Assert.True(endpointModel.Response.HasNoResponse); 492Assert.True(todo.IsComplete);

RequestDelegateGenerator\RuntimeCreationTests.ComplexFormBinding.cs (6)

42Assert.True(todo.IsComplete); 78Assert.True(todo.IsComplete); 109Assert.True(elements["foo"]); 111Assert.True(elements["baz"]); 146Assert.True(elements["foo"]); 148Assert.True(elements["baz"]);

ValidationFilterEndpointFactoryTests.cs (7)

60Assert.True(problemDetails.Extensions.TryGetValue("errors", out var errorsObj)); 62Assert.True(errors.EnumerateObject().Count() == 1); 110Assert.True(problemDetails.Extensions.TryGetValue("errors", out var errorsObj)); 112Assert.True(errors.EnumerateObject().Count() == 1); 168Assert.True(problemDetails.Extensions.TryGetValue("errors", out var errorsObj)); 170Assert.True(errors.EnumerateObject().Count() == 1); 173Assert.True(problemDetails.Extensions.ContainsKey("timestamp"));

src\Http\Http.Extensions\test\RequestDelegateGenerator\RequestDelegateCreationTestBase.cs (1)

152Assert.True(result.Success);

HttpResultsHelperTests.cs (7)

43Assert.True(body!.IsComplete); 75Assert.True(body!.IsComplete); 108Assert.True(body!.IsComplete); 142Assert.True(body!.IsComplete); 176Assert.True(body!.IsComplete); 206Assert.True(one.IsComplete); 216Assert.True(three.IsComplete);

LocalRedirectResultTests.cs (3)

38Assert.True(result.Permanent); 52Assert.True(result.PreserveMethod); 53Assert.True(result.Permanent);

RedirectResultTests.cs (3)

20Assert.True(result.PreserveMethod); 21Assert.True(result.Permanent); 48Assert.True(actual);

ResultsTests.cs (15)

ServerSentEventsResultTests.cs (1)

283Assert.True(bufferingDisabled);

src\Shared\ResultsTests\FileStreamResultTestBase.cs (2)

391Assert.True(originalBytes.SequenceEqual(outBytes)); 416Assert.True(originalBytes.SequenceEqual(outBytes));

TypedResultsTests.cs (13)

DefaultHttpContextTests.cs (10)

85Assert.True(object.ReferenceEquals(context.User, context.User)); 87Assert.True(string.IsNullOrEmpty(context.User.Identity.AuthenticationType)); 92Assert.True(object.ReferenceEquals(context.User, context.User)); 94Assert.True(string.IsNullOrEmpty(context.User.Identity.AuthenticationType)); 99Assert.True(object.ReferenceEquals(context.User, context.User)); 104Assert.True(context.User.Identity.IsAuthenticated); 227Assert.True(instance.Disposed); 254Assert.True(instance.Disposed); 256Assert.True(scope.DisposeAsyncCalled); 269Assert.True(context._active);

Features\FormFeatureTests.cs (4)

308Assert.True(body.CanSeek); 393Assert.True(body.CanSeek); 440Assert.True(body.CanSeek); 588Assert.True(body.CanSeek);

Features\QueryFeatureTests.cs (1)

56Assert.True(queryCollection.Keys.Contains(emptyParam));

Features\StreamResponseBodyFeatureTests.cs (1)

50Assert.True(innerFeature.DisableBufferingCalled);

HeaderDictionaryTests.cs (2)

31Assert.True(headers.ContainsKey("header1")); 81Assert.True(headers.ContainsKey("header1"));

Internal\DefaultHttpRequestTests.cs (1)

131Assert.True(request.IsHttps);

Internal\DefaultHttpResponseTests.cs (2)

171Assert.True(mock.IsCalled); 187Assert.True(instance.DisposeAsyncCalled);

Internal\ReferenceReadStreamTests.cs (1)

14Assert.True(stream.CanRead);

FileLoggerProcessorTests.cs (12)

HttpLoggingMiddlewareTests.cs (5)

833Assert.True(context.TryDisable(HttpLoggingFields.RequestPath)); 1342Assert.True(TestSink.Writes.TryTake(out var contentTypeLog)); 1345Assert.True(TestSink.Writes.TryTake(out var requestLog)); 1552Assert.True(upgradeFeature is UpgradeFeatureLoggingDecorator); 1834Assert.True(context.TryDisable(HttpLoggingFields.ResponseStatusCode));

W3CLoggingMiddlewareTests.cs (1)

305Assert.True(Double.TryParse(lines[3], NumberStyles.Number, CultureInfo.InvariantCulture, out num));

ForwardedHeadersMiddlewareTest.cs (15)

84Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-For")); 184Assert.True(context.Request.Headers.ContainsKey("X-Original-For")); 383Assert.True(assertsExecuted); 468Assert.True(assertsExecuted); 518Assert.True(assertsExecuted); 569Assert.True(assertsExecuted); 605Assert.True(assertsExecuted); 695Assert.True(assertsExecuted); 752Assert.True(assertsExecuted); 895Assert.True(options.ForwardedHeaders == ForwardedHeaders.None); 1325Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1375Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-For")); 1376Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Host")); 1377Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Proto")); 1378Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Prefix"));

HttpMethodOverrideMiddlewareTest.cs (6)

42Assert.True(assertsExecuted); 72Assert.True(assertsExecuted); 102Assert.True(assertsExecuted); 140Assert.True(assertsExecuted); 177Assert.True(assertsExecuted); 215Assert.True(assertsExecuted);

IPNetworkTest.cs (2)

27Assert.True(network.Contains(IPAddress.Parse(addressText))); 118Assert.True(result);

CustomSchemaTest.cs (1)

47Assert.True(DbUtil.VerifyColumns(sqlConn, "CustomColumns", "Id"));

DbUtil.cs (2)

94Assert.True(reader.Read()); 95Assert.True(reader.GetInt32(0) > 0);

EmptySchemaTest.cs (6)

51Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUsers")); 52Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetRoles")); 53Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserRoles")); 54Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserClaims")); 55Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserLogins")); 56Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserTokens"));

MaxKeyLengthSchemaTest.cs (10)

SqlStoreOnlyUsersTestBase.cs (5)

85Assert.True(DbUtil.VerifyColumns(db, "AspNetUsers", "Id", "UserName", "Email", "PasswordHash", "SecurityStamp", 90Assert.True(DbUtil.VerifyColumns(db, "AspNetUserClaims", "Id", "UserId", "ClaimType", "ClaimValue")); 91Assert.True(DbUtil.VerifyColumns(db, "AspNetUserLogins", "UserId", "ProviderKey", "LoginProvider", "ProviderDisplayName")); 92Assert.True(DbUtil.VerifyColumns(db, "AspNetUserTokens", "UserId", "LoginProvider", "Name", "Value")); 127Assert.True(db.Users.Any(u => u.UserName == user.UserName));

SqlStoreTestBase.cs (9)

UserStoreEncryptPersonalDataTest.cs (7)

221Assert.True(FindInk(connection, "PhoneNumber", guid)); 222Assert.True(FindInk(connection, "Email", guid)); 223Assert.True(FindInk(connection, "UserName", guid)); 224Assert.True(FindInk(connection, "PersonalData1", guid)); 225Assert.True(FindInk(connection, "PersonalData2", guid)); 226Assert.True(FindAuthenticatorKeyInk(connection, guid)); 227Assert.True(FindTokenInk(connection, guid, "loginProvider", "token"));

UserStoreTest.cs (1)

36Assert.True(db.Users.Any(u => u.UserName == guid));

VersionOneSchemaTest.cs (10)

VersionThreeSchemaTest.cs (11)

VersionTwoSchemaTest.cs (10)

ManagementTests.cs (6)

300Assert.True(jsonData.ContainsKey("Id")); 302Assert.True(jsonData.ContainsKey("UserName")); 304Assert.True(jsonData.ContainsKey("Email")); 306Assert.True(jsonData.ContainsKey("EmailConfirmed")); 308Assert.True(jsonData.ContainsKey("PhoneNumber")); 310Assert.True(jsonData.ContainsKey("PhoneNumberConfirmed"));

MapIdentityApiTests.cs (21)

Pages\Account\Manage\Email.cs (1)

22Assert.True(Context.UserAuthenticated);

Pages\Account\Manage\EnableAuthenticator.cs (1)

23Assert.True(Context.UserAuthenticated);

Pages\Account\Manage\Index.cs (1)

25Assert.True(Context.UserAuthenticated);

Pages\Account\Manage\ResetAuthenticator.cs (1)

20Assert.True(Context.UserAuthenticated);

Pages\Index.cs (2)

64Assert.True(Context.UserAuthenticated); 74Assert.True(Context.UserAuthenticated);

ControllerTest.cs (1)

56Assert.True(result.Succeeded);

IdentityResultAssert.cs (1)

22Assert.True(result.Succeeded);

IdentitySpecificationTestBase.cs (10)

UserManagerSpecificationTests.cs (39)

IdentityOptionsTest.cs (10)

17Assert.True(options.Lockout.AllowedForNewUsers); 21Assert.True(options.Password.RequireDigit); 22Assert.True(options.Password.RequireLowercase); 23Assert.True(options.Password.RequireNonAlphanumeric); 24Assert.True(options.Password.RequireUppercase); 49Assert.True(myOptions.Password.RequireLowercase); 50Assert.True(myOptions.Password.RequireDigit); 51Assert.True(myOptions.Password.RequireNonAlphanumeric); 52Assert.True(myOptions.Password.RequireUppercase); 68Assert.True(myOptions.User.RequireUniqueEmail);

Passkeys\PasskeyHandlerAssertionTest.cs (16)

30Assert.True(result.Succeeded); 39Assert.True(credentialJson.Remove("id")); 90Assert.True(credentialJson.Remove("type")); 139Assert.True(credentialJson.Remove("response")); 173Assert.True(originalOptionsJson.Remove("challenge")); 208Assert.True(response.Remove("clientDataJSON")); 258Assert.True(response.Remove("authenticatorData")); 325Assert.True(response.Remove("signature")); 459Assert.True(clientDataJson.Remove("type")); 511Assert.True(clientDataJson.Remove("challenge")); 594Assert.True(clientDataJson.Remove("origin")); 723Assert.True(result.Succeeded); 738Assert.True(result.Succeeded); 782Assert.True(result.Succeeded); 845Assert.True(result.Succeeded); 896Assert.True(result.Succeeded);

Passkeys\PasskeyHandlerAttestationTest.cs (17)

30Assert.True(result.Succeeded); 39Assert.True(credentialJson.Remove("id")); 90Assert.True(credentialJson.Remove("type")); 139Assert.True(credentialJson.Remove("response")); 174Assert.True(user.Remove("id")); 209Assert.True(user.Remove("name")); 244Assert.True(user.Remove("displayName")); 278Assert.True(attestationStateJson.Remove("userEntity")); 294Assert.True(attestationStateJson.Remove("challenge")); 329Assert.True(response.Remove("clientDataJSON")); 379Assert.True(response.Remove("attestationObject")); 428Assert.True(clientDataJson.Remove("type")); 480Assert.True(clientDataJson.Remove("challenge")); 563Assert.True(clientDataJson.Remove("origin")); 692Assert.True(result.Succeeded); 720Assert.True(result.Succeeded); 881Assert.True(result.Succeeded);

RoleManagerTest.cs (3)

26Assert.True(result.Succeeded); 46Assert.True(result.Succeeded); 108Assert.True(result);

SignInManagerTest.cs (19)

UserManagerTest.cs (18)

AspNetTestAssemblyRunnerTest.cs (2)

27Assert.True(fixture.ForAssemblyCalled); 41Assert.True(fixture.ConstructorWithMessageSinkCalled);

AssemblyTestLogTests.cs (2)

343Assert.True(File.Exists(Path.Combine( 353Assert.True(File.Exists(Path.Combine(

ConditionalFactTest.cs (2)

23Assert.True(true); 54Assert.True(Asserter.TestRan);

ConditionalTheoryTest.cs (3)

44Assert.True(true); 82Assert.True(true); 109Assert.True(Asserter.TestRan);

EnvironmentVariableSkipConditionTest.cs (4)

49Assert.True(isMet); 68Assert.True(isMet); 90Assert.True(isMet); 129Assert.True(isMet);

LoggedTestXunitTests.cs (2)

131Assert.True(SetupInvoked); 171Assert.True(ITestOutputHelperIsInitialized);

MaximumOSVersionAttributeTest.cs (4)

38Assert.True(osSkipAttribute.IsMet); 50Assert.True(osSkipAttribute.IsMet); 62Assert.True(osSkipAttribute.IsMet); 86Assert.True(osSkipAttribute.IsMet);

MaximumOSVersionTest.cs (4)

41Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); 46Assert.True(17134 >= int.Parse(currentVersion, CultureInfo.InvariantCulture)); 54Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); 59Assert.True(18363 >= int.Parse(currentVersion, CultureInfo.InvariantCulture));

MinimumOSVersionAttributeTest.cs (3)

38Assert.True(osSkipAttribute.IsMet); 50Assert.True(osSkipAttribute.IsMet); 74Assert.True(osSkipAttribute.IsMet);

MinimumOSVersionTest.cs (4)

40Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); 45Assert.True(17134 <= int.Parse(currentVersion, CultureInfo.InvariantCulture)); 53Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); 58Assert.True(18363 <= int.Parse(currentVersion, CultureInfo.InvariantCulture));

OSSkipConditionAttributeTest.cs (1)

33Assert.True(osSkipAttribute.IsMet);

QuarantinedTestAttributeTest.cs (1)

27Assert.True(new Random().Next(100) <= 80);

TestPlatformHelperTest.cs (4)

16Assert.True(TestPlatformHelper.IsLinux); 27Assert.True(TestPlatformHelper.IsMac); 38Assert.True(TestPlatformHelper.IsWindows); 45Assert.True(TestPlatformHelper.IsMono);

Internal\DictionaryAdapterTest.cs (12)

28Assert.True(addStatus); 48Assert.True(addStatus); 67Assert.True(addStatus); 95Assert.True(addStatus); 122Assert.True(addStatus); 131Assert.True(addStatus); 150Assert.True(replaceStatus); 170Assert.True(replaceStatus); 249Assert.True(replaceStatus); 269Assert.True(removeStatus); 288Assert.True(removeStatus); 313Assert.True(testStatus);

Internal\ListAdapterTest.cs (11)

62Assert.True(addStatus); 134Assert.True(addStatus); 152Assert.True(addStatus); 172Assert.True(addStatus); 240Assert.True(addStatus); 295Assert.True(addStatus); 335Assert.True(getStatus); 374Assert.True(removeStatus); 406Assert.True(replaceStatus); 442Assert.True(replaceStatus); 461Assert.True(testStatus);

Internal\ObjectVisitorTest.cs (4)

54Assert.True(visitStatus); 88Assert.True(visitStatus); 132Assert.True(visitStatus); 186Assert.True(visitStatus);

Internal\PocoAdapterTest.cs (6)

28Assert.True(addStatus); 68Assert.True(getStatus); 109Assert.True(removeStatus); 149Assert.True(replaceStatus); 218Assert.True(replaceStatus); 238Assert.True(testStatus);

Internal\DictionaryAdapterTest.cs (12)

31Assert.True(addStatus); 51Assert.True(addStatus); 70Assert.True(addStatus); 98Assert.True(addStatus); 125Assert.True(addStatus); 134Assert.True(addStatus); 153Assert.True(replaceStatus); 173Assert.True(replaceStatus); 251Assert.True(replaceStatus); 271Assert.True(removeStatus); 290Assert.True(removeStatus); 315Assert.True(testStatus);

Internal\DynamicObjectAdapterTest.cs (1)

202Assert.True(target.NewProperty is Rectangle);

Internal\ListAdapterTest.cs (11)

62Assert.True(addStatus); 134Assert.True(addStatus); 152Assert.True(addStatus); 172Assert.True(addStatus); 240Assert.True(addStatus); 295Assert.True(addStatus); 335Assert.True(getStatus); 374Assert.True(removeStatus); 406Assert.True(replaceStatus); 442Assert.True(replaceStatus); 459Assert.True(testStatus);

Internal\ObjectVisitorTest.cs (5)

54Assert.True(visitStatus); 87Assert.True(visitStatus); 117Assert.True(visitStatus); 149Assert.True(visitStatus); 203Assert.True(visitStatus);

Internal\PocoAdapterTest.cs (6)

34Assert.True(addStatus); 74Assert.True(getStatus); 115Assert.True(removeStatus); 155Assert.True(replaceStatus); 221Assert.True(replaceStatus); 239Assert.True(testStatus);

Filters\FilterContextTest.cs (1)

50Assert.True(result);

ModelBinding\ModelMetadataTest.cs (5)

44Assert.True(modelMetadata.IsComplexType); 117Assert.True(modelMetadata.IsCollectionType); 142Assert.True(modelMetadata.IsEnumerableType); 437Assert.True(metadata.IsParseableType); 439Assert.True(metadata.IsConvertibleType);

ModelBinding\ModelStateDictionaryTest.cs (15)

42Assert.True(remove); 61Assert.True(result); 480Assert.True(isValid); 622Assert.True(dictionary.ContainsKey("foo")); 767Assert.True(dictionary.HasReachedMaxErrors); 789Assert.True(result); 792Assert.True(result); 821Assert.True(result); 825Assert.True(result); 831Assert.True(dictionary.HasReachedMaxErrors); 835Assert.True(dictionary.HasReachedMaxErrors); 867Assert.True(dictionary.HasReachedMaxErrors); 894Assert.True(result); 897Assert.True(result); 1636Assert.True(isValid);

ApiResponseTypeProviderTest.cs (5)

312Assert.True(responseType.IsDefaultResponse); 464Assert.True(responseType.IsDefaultResponse); 507Assert.True(responseType.IsDefaultResponse); 603Assert.True(responseType.IsDefaultResponse); 649Assert.True(responseType.IsDefaultResponse);

DefaultApiDescriptionProviderTest.cs (7)

57Assert.True(categoryParameter.IsRequired); 58Assert.True(groupParameter.IsRequired); 1383Assert.True(parameter.ModelMetadata.IsRequired); 1384Assert.True(parameter.ModelMetadata.IsBindingRequired); 2072Assert.True(description.IsRequired); 2129Assert.True(description.IsRequired); 2147Assert.True(description.IsRequired);

EndpointMetadataApiDescriptionProviderTest.cs (18)

129Assert.True(apiParameterDescription.IsRequired); 871Assert.True(fooParam.IsRequired); 878Assert.True(barParam.IsRequired); 885Assert.True(fromBodyParam.IsRequired); 901Assert.True(param.IsRequired); 908Assert.True(param.IsRequired); 947param => Assert.True(param.IsRequired), 949param => Assert.True(param.IsRequired), 977param => Assert.True(param.IsRequired), 992Assert.True(fooParam.IsRequired); 1021Assert.True(apiExplorerSettings!.IgnoreApi); 1043Assert.True(barParam.IsRequired); 1353Assert.True(bodyParameterDescription.IsRequired); 1445Assert.True(bodyParameterDescription.IsRequired); 1503Assert.True(bodyParameterDescription.IsRequired); 1541Assert.True(fromFileParam0.IsRequired); 1591Assert.True(bodyParameterDescription.IsRequired); 1636Assert.True(parameter.RouteInfo.IsOptional);

ApiExplorer\ApiConventionMatcherTest.cs (12)

22Assert.True(result); 92Assert.True(result); 106Assert.True(result); 120Assert.True(result); 218Assert.True(result); 246Assert.True(result); 271Assert.True(result); 285Assert.True(result); 299Assert.True(result); 397Assert.True(result); 411Assert.True(result); 425Assert.True(result);

ApiExplorer\ApiConventionResultTest.cs (7)

40Assert.True(result); 80Assert.True(result); 105Assert.True(result); 125Assert.True(result); 148Assert.True(result); 172Assert.True(result); 196Assert.True(result);

ApplicationModels\AttributeRouteModelTests.cs (2)

314Assert.True(combined.SuppressLinkGeneration); 351Assert.True(combined.SuppressPathMatching);

ApplicationModels\ControllerActionDescriptorProviderTests.cs (3)

1315Assert.True(context.Results[0].RouteValues.ContainsKey("page")); 1318Assert.True(context.Results[1].RouteValues.ContainsKey("controller")); 1320Assert.True(context.Results[1].RouteValues.ContainsKey("action"));

ApplicationModels\DefaultApplicationModelProviderTest.cs (5)

533Assert.True(method.IsSpecialName); 629Assert.True(isValid); 662Assert.True(isValid); 701Assert.True(isValid); 721Assert.True(isValid);

ApplicationModels\EndpointMetadataProviderTest.cs (9)

ApplicationModels\InferParameterBindingInfoConventionTest.cs (2)

623Assert.True(convention.IsInferForServiceParametersEnabled); 641Assert.True(convention.IsInferForServiceParametersEnabled);

Builder\MvcAreaRouteBuilderExtensionsTest.cs (1)

257Assert.True(match);

ConsumesAttributeTests.cs (4)

101Assert.True(constraint.Accept(context)); 174Assert.True(constraint1.Accept(context)); 289Assert.True(constraint1.Accept(context)); 291Assert.True(constraint2.Accept(context));

ControllerBaseTest.cs (79)

Controllers\ControllerActivatorProviderTest.cs (1)

127Assert.True(controller.Disposed);

Controllers\ControllerBinderDelegateProviderTest.cs (4)

562Assert.True(controllerContext.ModelState.IsValid); 1190Assert.True(modelState.IsValid); 1191Assert.True(arguments.TryGetValue("accountId", out var value)); 1194Assert.True(arguments.TryGetValue("transferInfo", out value));

Controllers\DefaultControllerActivatorTest.cs (4)

57Assert.True(controller.Disposed); 71Assert.True(controller.Disposed); 85Assert.True(controller.Disposed); 100Assert.True(controller.AsyncDisposed);

DependencyInjection\MvcBuilderExtensionsTest.cs (1)

157Assert.True(options.SuppressMapClientErrors);

DependencyInjection\MvcCoreBuilderExtensionsTest.cs (1)

100Assert.True(options.SuppressMapClientErrors);

FileResultHelperTest.cs (4)

46Assert.True(result.WasWriteFileCalled); 68Assert.True(result.WasWriteFileCalled); 94Assert.True(result.WasWriteFileCalled); 115Assert.True(result.WasWriteFileCalled);

Filters\MiddlewareFilterTest.cs (5)

77Assert.True(resourceExecutedContext.HttpContext.Response.Headers.ContainsKey(expectedHeader)); 78Assert.True(resourceExecutedContext.Canceled); 126Assert.True(response.Headers.ContainsKey(expectedHeader)); 128Assert.True(resourceExecutedContext.Canceled); 213Assert.True(response.Headers.ContainsKey("Error"));

Formatters\InputFormatterTest.cs (5)

50Assert.True(result); 84Assert.True(result); 149Assert.True(result); 217Assert.True(result); 285Assert.True(result);

Formatters\JsonInputFormatterTestBase.cs (5)

146Assert.True(result.HasError); 173Assert.True(result.HasError); 201Assert.True(result.HasError); 403Assert.True(result.HasError); 432Assert.True(result.HasError);

Formatters\MediaTypeTest.cs (3)

226Assert.True(result); 268Assert.True(result); 298Assert.True(result);

Formatters\NoContentFormatterTests.cs (1)

80Assert.True(result);

Formatters\OutputFormatterTests.cs (1)

28Assert.True(result);

Formatters\StreamOutputFormatterTest.cs (1)

33Assert.True(canWrite);

Formatters\StringOutputFormatterTests.cs (2)

75Assert.True(result); 102Assert.True(result);

Formatters\SystemTextJsonInputFormatterTest.cs (6)

153Assert.True(result.HasError); 154Assert.True(!formatterContext.ModelState.IsValid); 155Assert.True(formatterContext.ModelState.ContainsKey(modelStateKey)); 175Assert.True(result.HasError); 176Assert.True(!formatterContext.ModelState.IsValid); 177Assert.True(formatterContext.ModelState.ContainsKey("$"));

Formatters\TextInputFormatterTest.cs (2)

33Assert.True(result.HasError); 34Assert.True(context.ModelState.ContainsKey("something"));

Infrastructure\ActionMethodExecutorTest.cs (4)

34Assert.True(controller.Executed); 60Assert.True(valueTask.IsCompleted); 223Assert.True(controller.Executed); 249Assert.True(controller.Executed);

Infrastructure\AsyncEnumerableReaderTest.cs (14)

Infrastructure\CompatibilitySwitchTest.cs (4)

26Assert.True(@switch.Value); 41Assert.True(@switch.IsValueSet); 54Assert.True(@switch.Value); 55Assert.True(@switch.IsValueSet);

Infrastructure\ConfigureCompatibilityOptionsTest.cs (1)

70Assert.True(options.TestProperty);

Infrastructure\ControllerActionInvokerTest.cs (3)

370Assert.True(context.Canceled); 439Assert.True(context.Canceled); 494Assert.True(context.Canceled);

Infrastructure\DefaultActionDescriptorCollectionProviderTest.cs (2)

130Assert.True(changeToken1.HasChanged); 147Assert.True(changeToken2.HasChanged);

Infrastructure\DefaultApiProblemDetailsWriterTest.cs (1)

148Assert.True(result);

Infrastructure\FileStreamResultExecutorTest.cs (1)

27Assert.True(stream.DidDisposeAsync);

Infrastructure\NonDisposableStreamTest.cs (2)

19Assert.True(innerStream.CanRead); 45Assert.True(innerStream.CanRead);

LocalRedirectResultTest.cs (3)

43Assert.True(result.Permanent); 57Assert.True(result.PreserveMethod); 58Assert.True(result.Permanent);

ModelBinding\Binders\ArrayModelBinderProviderTest.cs (1)

69Assert.True(binder.AllowValidatingTopLevelNodes);

ModelBinding\Binders\ArrayModelBinderTest.cs (4)

36Assert.True(bindingContext.Result.IsModelSet); 82Assert.True(bindingContext.Result.IsModelSet); 116Assert.True(bindingContext.Result.IsModelSet); 210Assert.True(bindingContext.Result.IsModelSet);

ModelBinding\Binders\BodyModelBinderProviderTest.cs (2)

95Assert.True(allowEmpty); 115Assert.True(allowEmpty);

ModelBinding\Binders\BodyModelBinderTests.cs (4)

48Assert.True(bindingContext.Result.IsModelSet); 214Assert.True(bindingContext.Result.IsModelSet); 216Assert.True(bindingContext.ModelState.IsValid); 585Assert.True(bindingContext.Result.IsModelSet);

ModelBinding\Binders\ByteArrayModelBinderTests.cs (1)

52Assert.True(bindingContext.Result.IsModelSet);

ModelBinding\Binders\CancellationTokenModelBinderTests.cs (1)

22Assert.True(bindingContext.Result.IsModelSet);

ModelBinding\Binders\CollectionModelBinderProviderTest.cs (1)

84Assert.True(binder.AllowValidatingTopLevelNodes);

ModelBinding\Binders\CollectionModelBinderTest.cs (10)

84Assert.True(bindingContext.Result.IsModelSet); 89Assert.True(modelState.IsValid); 115Assert.True(bindingContext.Result.IsModelSet); 120Assert.True(modelState.IsValid); 141Assert.True(bindingContext.Result.IsModelSet); 167Assert.True(bindingContext.Result.IsModelSet); 188Assert.True(bindingContext.Result.IsModelSet); 268Assert.True(bindingContext.Result.IsModelSet); 302Assert.True(bindingContext.Result.IsModelSet); 377Assert.True(bindingContext.Result.IsModelSet);

ModelBinding\Binders\ComplexObjectModelBinderTest.cs (17)

ModelBinding\Binders\ComplexTypeModelBinderTest.cs (18)

ModelBinding\Binders\DateTimeModelBinderTest.cs (4)

172Assert.True(bindingContext.Result.IsModelSet); 176Assert.True(bindingContext.ModelState.ContainsKey("theModelName")); 195Assert.True(bindingContext.Result.IsModelSet); 199Assert.True(bindingContext.ModelState.ContainsKey("theModelName"));

ModelBinding\Binders\DictionaryModelBinderTest.cs (10)

ModelBinding\Binders\EnumTypeModelBinderTest.cs (6)

23Assert.True(bindingContext.Result.IsModelSet); 62Assert.True(bindingContext.Result.IsModelSet); 86Assert.True(bindingContext.Result.IsModelSet); 110Assert.True(bindingContext.Result.IsModelSet); 172Assert.True(bindingContext.Result.IsModelSet); 197Assert.True(bindingContext.Result.IsModelSet);

ModelBinding\Binders\FloatingPointTypeModelBinderTestOfT.cs (12)

ModelBinding\Binders\FormCollectionModelBinderTest.cs (2)

31Assert.True(bindingContext.Result.IsModelSet); 52Assert.True(bindingContext.Result.IsModelSet);

ModelBinding\Binders\FormFileModelBinderTest.cs (11)

ModelBinding\Binders\HeaderModelBinderTests.cs (9)

34Assert.True(bindingContext.Result.IsModelSet); 56Assert.True(bindingContext.Result.IsModelSet); 83Assert.True(bindingContext.Result.IsModelSet); 102Assert.True(bindingContext.Result.IsModelSet); 153Assert.True(bindingContext.Result.IsModelSet); 212Assert.True(bindingContext.Result.IsModelSet); 229Assert.True(bindingContext.Result.IsModelSet); 246Assert.True(bindingContext.Result.IsModelSet); 270Assert.True(bindingContext.Result.IsModelSet);

ModelBinding\Binders\KeyValuePairModelBinderTest.cs (3)

80Assert.True(bindingContext.ModelState.IsValid); 100Assert.True(bindingContext.Result.IsModelSet); 168Assert.True(bindingContext.Result.IsModelSet);

ModelBinding\Binders\ServicesModelBinderTest.cs (2)

25Assert.True(bindingContext.Result.IsModelSet); 28Assert.True(entry.SuppressValidation);

ModelBinding\Binders\SimpleTypeModelBinderTest.cs (15)

ModelBinding\Binders\TryParseTypeModelBinderTest.cs (13)

ModelBinding\ElementalValueProviderTests.cs (1)

29Assert.True(containsPrefix);

ModelBinding\EnumerableValueProviderTest.cs (2)

52Assert.True(result); 67Assert.True(valueProvider.ContainsPrefix(prefix));

ModelBinding\FormFileValueProviderTest.cs (1)

46Assert.True(result);

ModelBinding\Metadata\BindingSourceTest.cs (2)

50Assert.True(result); 60Assert.True(result);

ModelBinding\Metadata\CompositeBindingSourceTest.cs (1)

44Assert.True(result);

ModelBinding\Metadata\DefaultBindingMetadataProviderTest.cs (21)

ModelBinding\ModelBindingHelperTest.cs (9)

123Assert.True(result); 202Assert.True(result); 279Assert.True(result); 329Assert.True(result); 533Assert.True(result); 600Assert.True(result); 1352Assert.True(result); 1423Assert.True(result); 1439Assert.True(result);

ModelBinding\ModelBindingResultTest.cs (1)

18Assert.True(result.IsModelSet);

ModelBinding\ParameterBinderTest.cs (6)

344Assert.True(result.IsModelSet); 399Assert.True(result.IsModelSet); 454Assert.True(result.IsModelSet); 508Assert.True(result.IsModelSet); 568Assert.True(result.IsModelSet); 697Assert.True(result.IsModelSet);

ModelBinding\PrefixContainerTest.cs (6)

33Assert.True(result); 51Assert.True(result); 92Assert.True(result); 132Assert.True(result); 156Assert.True(result); 180Assert.True(result);

ModelBinding\RouteValueProviderTests.cs (2)

154Assert.True(result); 227Assert.True(result);

ModelBinding\Validation\DefaultModelValidatorProviderTest.cs (1)

153Assert.True(result);

ModelBinding\Validation\DefaultObjectValidatorTests.cs (15)

ModelBinding\Validation\ValidationStackTest.cs (2)

21Assert.True(validationStack.Push(model)); 89Assert.True(validationStack.UsingHashSet());

RedirectResultTest.cs (3)

60Assert.True(result.Permanent); 74Assert.True(result.PreserveMethod); 75Assert.True(result.Permanent);

RequestFormLimitsAttributeTest.cs (1)

71Assert.True(requestFormLimitsAttribute.FormOptions.BufferBody);

ResponseCacheAttributeTest.cs (5)

38Assert.True(responseCacheFilter.NoStore); 221Assert.True(response.Headers.TryGetValue("Cache-Control", out values)); 224Assert.True(response.Headers.TryGetValue("Vary", out values)); 277Assert.True(context.HttpContext.Response.Headers.TryGetValue("Cache-Control", out values)); 296Assert.True(context.HttpContext.Response.Headers.TryGetValue("Cache-Control", out values));

Routing\ActionEndpointFactoryTest.cs (1)

488Assert.True(isPresent);

Routing\DynamicControllerEndpointMatcherPolicyTest.cs (5)

202Assert.True(candidates.IsValidCandidate(0)); 290Assert.True(candidates.IsValidCandidate(0)); 391Assert.True(candidates.IsValidCandidate(0)); 431Assert.True(candidates.IsValidCandidate(0)); 432Assert.True(candidates.IsValidCandidate(1));

Routing\KnownRouteValueConstraintTests.cs (4)

54Assert.True(match); 115Assert.True(match); 237Assert.True(match); 266Assert.True(match);

Routing\UrlHelperTestBase.cs (2)

89Assert.True(result); 104Assert.True(result);

src\Shared\ResultsTests\FileStreamResultTestBase.cs (2)

391Assert.True(originalBytes.SequenceEqual(outBytes)); 416Assert.True(originalBytes.SequenceEqual(outBytes));

CommonFilterTest.cs (1)

184Assert.True(context.Cancel);

CommonResourceInvokerTest.cs (6)

836Assert.True(context.Canceled); 878Assert.True(context.Canceled); 920Assert.True(context.Canceled); 1570Assert.True(context.Canceled); 1617Assert.True(context.Canceled); 1667Assert.True(context.Canceled);

DataAnnotationsMetadataProviderTest.cs (3)

1165Assert.True(((RequiredAttribute)attribute).AllowEmptyStrings); // non-Default for [Required] 1592Assert.True(result); 1661Assert.True(result);

DataAnnotationsModelValidatorProviderTest.cs (2)

121Assert.True(result); 135Assert.True(result);

DataMemberRequiredBindingMetadataProviderTest.cs (1)

33Assert.True(context.BindingMetadata.IsBindingRequired);

ModelMetadataProviderTest.cs (13)

68Assert.True(provider.GetMetadataForProperty(type, "NoAttribute").ShowForDisplay); 69Assert.True(provider.GetMetadataForProperty(type, "ScaffoldColumnTrue").ShowForDisplay); 81Assert.True(provider.GetMetadataForProperty(type, "NoAttribute").ShowForEdit); 82Assert.True(provider.GetMetadataForProperty(type, "ScaffoldColumnTrue").ShowForEdit); 98Assert.True(result); 113Assert.True(result); 673Assert.True(metadata.IsRequired); 705Assert.True(metadata.IsRequired); 720Assert.True(metadata.IsBindingRequired); 809Assert.True(metadata.IsBindingAllowed); 825Assert.True(metadata.IsBindingAllowed); 826Assert.True(metadata.IsBindingRequired); 841Assert.True(metadata.IsBindingAllowed);

ValidationAttributeAdapterOfTAttributeTest.cs (1)

39Assert.True(attribute.Formatted);

SerializableErrorWrapperTests.cs (1)

40Assert.True(wrapper.SerializableError.ContainsKey("key1"));

XmlDataContractSerializerInputFormatterTest.cs (1)

472Assert.True(context.HttpContext.Request.Body.CanRead);

XmlDataContractSerializerOutputFormatterTest.cs (2)

146Assert.True(writerSettings.OmitXmlDeclaration); 341Assert.True(body.CanRead);

XmlSerializerInputFormatterTest.cs (1)

489Assert.True(context.HttpContext.Request.Body.CanRead);

XmlSerializerOutputFormatterTest.cs (2)

152Assert.True(writerSettings.OmitXmlDeclaration); 330Assert.True(outputFormatterContext.HttpContext.Response.Body.CanRead);

AntiforgeryTests.cs (3)

47Assert.True(response.Headers.CacheControl.NoCache); 99Assert.True(response.Headers.CacheControl.NoCache); 181Assert.True(response.Headers.CacheControl.NoCache);

ApiExplorerTest.cs (10)

328Assert.True(day.RouteInfo.IsOptional); 333Assert.True(year.RouteInfo.IsOptional); 382Assert.True(id.RouteInfo.IsOptional); 1159Assert.True(parameter.IsRequired); 1169Assert.True(parameter.IsRequired); 1283Assert.True(responseType.IsDefaultResponse); 1374Assert.True(responseType.IsDefaultResponse); 1409Assert.True(responseType.IsDefaultResponse); 1444Assert.True(responseType.IsDefaultResponse); 1484Assert.True(responseType.IsDefaultResponse);

AsyncDisposalTest.cs (3)

49Assert.True(sink.DisposeAsyncInvoked); 61Assert.True(sink.DisposeAsyncInvoked); 73Assert.True(sink.DisposeAsyncInvoked);

AuthMiddlewareAndFilterTestBase.cs (1)

282Assert.True(response.Headers.Contains("Set-Cookie"));

AuthMiddlewareUsingRequireAuthTest.cs (1)

84Assert.True(response.Headers.Contains("Set-Cookie"));

BasicTests.cs (1)

486Assert.True(assemblyParts.Count > 2);

ConsumesAttributeEndpointRoutingTests.cs (1)

23Assert.True(result);

ControllerEndpointFiltersTest.cs (4)

45Assert.True(content.TryGetValue(nameof(IEndpointFilter), out var endpointFilterCalled)); 46Assert.True(((JsonElement)endpointFilterCalled).GetBoolean()); 59Assert.True(content.TryGetValue(nameof(EndpointFilterFactoryContext.MethodInfo.Name), out var methodInfo)); 84Assert.True(content.TryGetValue(nameof(EndpointFilterInvocationContext.Arguments), out var argument));

FormFileUploadTest.cs (2)

80Assert.True(product.Specs.ContainsKey("camera")); 82Assert.True(product.Specs.ContainsKey("battery"));

GlobalAuthorizationFilterTestBase.cs (1)

68Assert.True(response.Headers.Contains("Set-Cookie"));

KeyedServicesTests.cs (5)

41Assert.True(okResponse.IsSuccessStatusCode); 42Assert.True(notokResponse.IsSuccessStatusCode); 57Assert.True(response.IsSuccessStatusCode); 71Assert.True(response.IsSuccessStatusCode); 85Assert.True(response.IsSuccessStatusCode);

PageAsyncDisposalTest.cs (1)

47Assert.True(sink.DisposeAsyncInvoked);

RazorPagesTest.cs (1)

1254Assert.True(cacheControl.Private);

RequestServicesEndpointRoutingTest.cs (1)

23Assert.True(result);

RoutingAcrossPipelineBranchesTest.cs (4)

58Assert.True(subdirContent.RouteValues.TryGetValue("subdir", out var subdir)); 62Assert.True(commonContent.RouteValues.TryGetValue("common", out var common)); 66Assert.True(defaultContent.RouteValues.TryGetValue("default", out var @default)); 171Assert.True(content.RouteValues.TryGetValue("action", out var action));

RoutingDynamicOrderTest.cs (3)

74Assert.True(content.RouteValues.TryGetValue("identifier", out var identifier)); 119Assert.True(content.RouteValues.TryGetValue("identifier", out var identifier)); 163Assert.True(content.RouteValues.TryGetValue("identifier", out var identifier));

RoutingEndpointRoutingTest.cs (1)

209Assert.True(result);

RoutingGroupsTest.cs (1)

46Assert.True(content.RouteValues.TryGetValue("org", out var org));

TempDataInCookiesTest.cs (8)

69Assert.True(response.Headers.TryGetValues(HeaderNames.SetCookie, out IEnumerable<string> setCookieValues)); 75Assert.True(cookie.Length <= ChunkingCookieManager.DefaultChunkSize); 95Assert.True(response.Headers.TryGetValues(HeaderNames.SetCookie, out setCookieValues)); 104Assert.True(setCookieHeaderValue.Expires < DateTimeOffset.Now); // expired cookie 128Assert.True(response.Headers.TryGetValues(HeaderNames.SetCookie, out IEnumerable<string> setCookieValues)); 151Assert.True(response.Headers.TryGetValues(HeaderNames.SetCookie, out setCookieValues)); 160Assert.True(setCookieHeader.Expires < DateTimeOffset.Now); // expired cookie 181Assert.True(response.Headers.TryGetValues(HeaderNames.SetCookie, out IEnumerable<string> setCookieValues));

TestingInfrastructureInheritanceTests.cs (13)

TestingInfrastructureTests.cs (2)

82Assert.True(request.Headers.TryAddWithoutValidation("X-Invalid-Request-Header", "Bearer 1234,5678")); 83Assert.True(request.Content.Headers.TryAddWithoutValidation("X-Invalid-Content-Header", "Bearer 1234,5678"));

VersioningEndpointRoutingTests.cs (1)

24Assert.True(result);

WebApplicationFactorySlnxTests.cs (2)

60Assert.True(Directory.Exists(environment.ContentRootPath)); 64Assert.True(response.IsSuccessStatusCode);

ActionParametersIntegrationTest.cs (21)

ArrayModelBinderIntegrationTest.cs (18)

35Assert.True(modelBindingResult.IsModelSet); 42Assert.True(modelState.IsValid); 79Assert.True(modelBindingResult.IsModelSet); 86Assert.True(modelState.IsValid); 119Assert.True(modelBindingResult.IsModelSet); 126Assert.True(modelState.IsValid); 159Assert.True(modelBindingResult.IsModelSet); 164Assert.True(modelState.IsValid); 194Assert.True(modelBindingResult.IsModelSet); 202Assert.True(modelState.IsValid); 239Assert.True(modelBindingResult.IsModelSet); 247Assert.True(modelState.IsValid); 280Assert.True(modelBindingResult.IsModelSet); 288Assert.True(modelState.IsValid); 321Assert.True(modelBindingResult.IsModelSet); 326Assert.True(modelState.IsValid); 358Assert.True(modelBindingResult.IsModelSet); 360Assert.True(modelState.IsValid);

BinderTypeBasedModelBinderIntegrationTest.cs (13)

40Assert.True(modelBindingResult.IsModelSet); 44Assert.True(modelState.IsValid); 75Assert.True(modelState.IsValid); 111Assert.True(modelBindingResult.IsModelSet); 115Assert.True(modelState.IsValid); 173Assert.True(modelBindingResult.IsModelSet); 180Assert.True(modelState.IsValid); 224Assert.True(modelBindingResult.IsModelSet); 232Assert.True(modelState.IsValid); 262Assert.True(modelBindingResult.IsModelSet); 270Assert.True(modelState.IsValid); 301Assert.True(modelBindingResult.IsModelSet); 309Assert.True(modelState.IsValid);

BindingSourceMetadataProviderIntegrationTest.cs (4)

50Assert.True(modelBindingResult.IsModelSet); 59Assert.True(modelState.IsValid); 103Assert.True(modelBindingResult.IsModelSet); 111Assert.True(modelState.IsValid);

BindPropertyIntegrationTest.cs (3)

45Assert.True(result.IsModelSet); 72Assert.True(result.IsModelSet); 133Assert.True(testContext.ModelState.IsValid);

BodyValidationIntegrationTests.cs (28)

ByteArrayModelBinderIntegrationTest.cs (5)

50Assert.True(modelBindingResult.IsModelSet); 59Assert.True(modelState.IsValid); 98Assert.True(modelState.IsValid); 134Assert.True(modelBindingResult.IsModelSet); 141Assert.True(modelState.IsValid);

CancellationTokenModelBinderIntegrationTest.cs (9)

41Assert.True(modelBindingResult.IsModelSet); 48Assert.True(boundPerson.Token.IsCancellationRequested); 51Assert.True(modelState.IsValid); 77Assert.True(modelBindingResult.IsModelSet); 84Assert.True(boundPerson.Token.IsCancellationRequested); 87Assert.True(modelState.IsValid); 116Assert.True(modelBindingResult.IsModelSet); 122Assert.True(token.IsCancellationRequested); 125Assert.True(modelState.IsValid);

CollectionModelBinderIntegrationTest.cs (37)

ComplexRecordIntegrationTest.cs (140)

ComplexTypeIntegrationTestBase.cs (106)

DictionaryModelBinderIntegrationTest.cs (52)

ExcludeBindingMetadataProviderIntegrationTest.cs (3)

49Assert.True(modelBindingResult.IsModelSet); 108Assert.True(modelBindingResult.IsModelSet); 116Assert.True(modelBinderProvider.Invoked);

FormCollectionModelBindingIntegrationTest.cs (5)

54Assert.True(modelBindingResult.IsModelSet); 66Assert.True(modelState.IsValid); 103Assert.True(modelBindingResult.IsModelSet); 114Assert.True(modelState.IsValid); 147Assert.True(modelState.IsValid);

FormFileModelBindingIntegrationTest.cs (39)

GenericModelBinderIntegrationTest.cs (27)

HeaderModelBinderIntegrationTest.cs (13)

52Assert.True(modelBindingResult.IsModelSet); 91Assert.True(modelBindingResult.IsModelSet); 100Assert.True(modelState.IsValid); 133Assert.True(modelBindingResult.IsModelSet); 142Assert.True(modelState.IsValid); 177Assert.True(result.IsModelSet); 187Assert.True(modelState.IsValid); 224Assert.True(result.IsModelSet); 234Assert.True(modelState.IsValid); 289Assert.True(modelBindingResult.IsModelSet); 296Assert.True(modelState.IsValid); 340Assert.True(modelBindingResult.IsModelSet); 358Assert.True(modelState.IsValid);

JQueryFormatModelBindingIntegrationTest.cs (4)

41Assert.True(modelBindingResult.IsModelSet); 51Assert.True(modelState.IsValid); 79Assert.True(modelBindingResult.IsModelSet); 89Assert.True(modelState.IsValid);

KeyValuePairModelBinderIntegrationTest.cs (16)

ModelPrefixSelectionIntegrationTest.cs (10)

50Assert.True(modelBindingResult.IsModelSet); 57Assert.True(modelState.IsValid); 99Assert.True(modelBindingResult.IsModelSet); 106Assert.True(modelState.IsValid); 138Assert.True(modelBindingResult.IsModelSet); 145Assert.True(modelState.IsValid); 187Assert.True(modelBindingResult.IsModelSet); 194Assert.True(modelState.IsValid); 233Assert.True(modelBindingResult.IsModelSet); 240Assert.True(modelState.IsValid);

NullableReferenceTypeIntegrationTest.cs (4)

41Assert.True(modelBindingResult.IsModelSet); 89Assert.True(modelBindingResult.IsModelSet); 96Assert.True(modelState.IsValid); 128Assert.True(modelBindingResult.IsModelSet);

ServicesModelBinderIntegrationTest.cs (18)

SimpleTypeModelBinderIntegrationTest.cs (24)

TryUpdateModelIntegrationTest.cs (56)

TryValidateModelIntegrationTest.cs (2)

69Assert.True(result); 70Assert.True(modelState.IsValid);

ValidationIntegrationTests.cs (75)

ValidationWithRecordIntegrationTests.cs (70)

NewtonsoftJsonInputFormatterTest.cs (13)

169Assert.True(result.HasError); 246Assert.True(result.HasError); 247Assert.True(!formatterContext.ModelState.IsValid); 248Assert.True(formatterContext.ModelState.ContainsKey(modelStateKey)); 301Assert.True(result.HasError); 302Assert.True(!formatterContext.ModelState.IsValid); 303Assert.True(formatterContext.ModelState.ContainsKey(string.Empty)); 334Assert.True(result.HasError); 335Assert.True(!formatterContext.ModelState.IsValid); 336Assert.True(formatterContext.ModelState.ContainsKey(string.Empty)); 366Assert.True(result.HasError); 397Assert.True(result.HasError); 428Assert.True(result.HasError);

NewtonsoftJsonPatchInputFormatterTest.cs (1)

218Assert.True(result.HasError);

src\Mvc\Mvc.Core\test\Formatters\JsonInputFormatterTestBase.cs (5)

146Assert.True(result.HasError); 173Assert.True(result.HasError); 201Assert.True(result.HasError); 403Assert.True(result.HasError); 432Assert.True(result.HasError);

src\Mvc\Mvc.Core\test\Infrastructure\AsyncEnumerableReaderTest.cs (14)

src\Mvc\Mvc.ViewFeatures\test\Infrastructure\TempDataSerializerTestBase.cs (1)

40Assert.True(values.ContainsKey(key));

ChecksumValidatorTest.cs (6)

57Assert.True(result); 70Assert.True(result); 87Assert.True(result); 106Assert.True(result); 186Assert.True(result); 208Assert.True(result);

CSharpCompilerTest.cs (3)

169Assert.True(compiler.EmitPdb); 184Assert.True(compiler.EmitPdb); 211Assert.True(compilationOptions.AllowUnsafe);

FileProviderRazorProjectFileSystemTest.cs (2)

196Assert.True(item.Exists); 218Assert.True(item.Exists);

RuntimeViewCompilerTest.cs (10)

597Assert.True(resetEvent1.WaitOne(waitDuration)); 600Assert.True(resetEvent2.Set()); 603Assert.True(resetEvent1.WaitOne(waitDuration)); 605Assert.True(compilingTwo); 614Assert.True(resetEvent2.WaitOne(waitDuration)); 617Assert.True(resetEvent1.Set()); 619Assert.True(compilingOne); 639Assert.True(compilingOne); 640Assert.True(compilingTwo); 674Assert.True(resetEvent2.WaitOne(waitDuration));

Compilation\DefaultRazorPageFactoryProviderTest.cs (2)

69Assert.True(result.Success); 95Assert.True(result.Success);

RazorViewTest.cs (2)

456Assert.True(layoutExecuted); 510Assert.True(layoutExecuted);

TagHelpers\UrlResolutionTagHelperTest.cs (1)

336Assert.True(Assert.IsType<bool>(attribute.Value));

ApplicationModels\DefaultPageApplicationModelProviderTest.cs (2)

988Assert.True(p.BindingInfo.RequestPredicate(new ActionContext 1040Assert.True(result);

ApplicationModels\PageRouteModelFactoryTest.cs (1)

215Assert.True(success);

ApplicationModels\ResponseCacheFilterApplicationModelProviderTest.cs (1)

75Assert.True(filter.NoStore);

DependencyInjection\PageConventionCollectionExtensionsTest.cs (3)

895Assert.True(selector.AttributeRouteModel.SuppressLinkGeneration); 900Assert.True(selector.AttributeRouteModel.SuppressLinkGeneration); 966Assert.True(selector.AttributeRouteModel.SuppressLinkGeneration);

Filters\PageHandlerResultFilterTest.cs (1)

169Assert.True(invoked);

Infrastructure\DefaultPageActivatorProviderTest.cs (4)

124Assert.True(page.Disposed); 145Assert.True(page.Disposed); 166Assert.True(page.Disposed); 187Assert.True(page.AsyncDisposed);

Infrastructure\DefaultPageFactoryProviderTest.cs (2)

324Assert.True(((DisposablePage)instance).Disposed); 362Assert.True(((DisposablePage)instance).Disposed);

Infrastructure\DefaultPageModelActivatorProviderTest.cs (4)

149Assert.True(model.Disposed); 170Assert.True(model.Disposed); 191Assert.True(model.Disposed); 212Assert.True(model.AsyncDisposed);

Infrastructure\DynamicPageEndpointMatcherPolicyTest.cs (5)

213Assert.True(candidates.IsValidCandidate(0)); 264Assert.True(candidates.IsValidCandidate(0)); 392Assert.True(candidates.IsValidCandidate(0)); 431Assert.True(candidates.IsValidCandidate(0)); 432Assert.True(candidates.IsValidCandidate(1));

Infrastructure\ExecutorFactoryTest.cs (2)

94Assert.True(page.SideEffects); 117Assert.True(page.SideEffects);

Infrastructure\PageActionInvokerTest.cs (4)

491Assert.True(pageHandlerExecutedCalled); 884Assert.True(context.Canceled); 956Assert.True(context.Canceled); 1014Assert.True(context.Canceled);

Infrastructure\PageHandlerPageFilterTest.cs (1)

173Assert.True(invoked);

PageModelTest.cs (54)

PageTest.cs (54)

AttributeMatcherTest.cs (2)

60Assert.True(modeMatch); 89Assert.True(modeMatch);

CacheTagHelperTest.cs (20)

DefaultFileVersionProviderTest.cs (1)

189Assert.True(stream.Disposed);

DistributedCacheTagHelperTest.cs (14)

EnvironmentTagHelperTest.cs (4)

148Assert.True(output.Content.GetContent().Length == 0); 150Assert.True(output.IsContentModified); 181Assert.True(output.Content.GetContent().Length == 0); 183Assert.True(output.IsContentModified);

FormTagHelperTest.cs (11)

ImageTagHelperTest.cs (4)

157Assert.True(output.Content.GetContent().Length == 0); 209Assert.True(output.Content.GetContent().Length == 0); 252Assert.True(output.Content.GetContent().Length == 0); 284Assert.True(output.Content.GetContent().Length == 0);

InputTagHelperTest.cs (3)

959Assert.True(string.IsNullOrEmpty(HtmlContentUtilities.HtmlContentToString(output.PostElement))); 1079Assert.True(string.IsNullOrEmpty(HtmlContentUtilities.HtmlContentToString(output.PostElement))); 1382Assert.True(string.IsNullOrEmpty(HtmlContentUtilities.HtmlContentToString(output.PostElement)));

LinkTagHelperTest.cs (6)

319Assert.True(output.PostElement.IsModified); 405Assert.True(output.IsContentModified); 406Assert.True(output.Content.GetContent().Length == 0); 407Assert.True(output.PostElement.IsModified); 543Assert.True(output.PostElement.GetContent().Length == 0); 562Assert.True(output.PostElement.GetContent().Length == 0);

OptionTagHelperTest.cs (1)

410Assert.True(false);

PersistComponentStateTagHelperTest.cs (4)

102Assert.True(message.Length > 0); 132Assert.True(message.Length > 0); 163Assert.True(message.Length > 0); 216Assert.True(message.Length > 0);

RenderAtEndOfFormTagHelperTest.cs (1)

52Assert.True(viewContext.FormContext.CanRenderAtEndOfForm);

ScriptTagHelperTest.cs (6)

295Assert.True(output.PostElement.IsModified); 381Assert.True(output.IsContentModified); 382Assert.True(output.Content.GetContent().Length == 0); 383Assert.True(output.PostElement.IsModified); 471Assert.True(output.PostElement.GetContent().Length == 0); 491Assert.True(output.PostElement.GetContent().Length == 0);

Routing\ActionConstraintMatcherPolicyTest.cs (10)

36Assert.True(candidateSet.IsValidCandidate(0)); 37Assert.True(candidateSet.IsValidCandidate(1)); 69Assert.True(candidateSet.IsValidCandidate(0)); 175Assert.True(candidateSet.IsValidCandidate(0)); 215Assert.True(candidateSet.IsValidCandidate(2)); 249Assert.True(candidateSet.IsValidCandidate(1)); 289Assert.True(candidateSet.IsValidCandidate(0)); 330Assert.True(candidateSet.IsValidCandidate(0)); 368Assert.True(candidateSet.IsValidCandidate(0)); 433Assert.True(result);

AttributeDictionaryTest.cs (5)

94Assert.True(result); 128Assert.True(result); 221Assert.True(result); 266Assert.True(result); 313Assert.True(result);

ControllerTest.cs (2)

60Assert.True(method.IsDefined(typeof(NonActionAttribute))); 368Assert.True(controller.DisposeCalled);

CookieTempDataProviderTest.cs (4)

176Assert.True(cookieInfo.Options.HttpOnly); 211Assert.True(cookieInfo.Options.HttpOnly); 261Assert.True(cookieInfo.Options.HttpOnly); 290Assert.True(cookie.Expires.Value < DateTimeOffset.Now); // expired cookie

Infrastructure\TempDataSerializerTestBase.cs (1)

40Assert.True(values.ContainsKey(key));

RemoteAttributeBaseTest.cs (1)

29Assert.True(attribute.IsValid(value: null));

Rendering\HtmlHelperCheckboxTest.cs (2)

160Assert.True(helper.ViewContext.FormContext.HasEndOfFormContent); 226Assert.True(helper.ViewContext.FormContext.HasEndOfFormContent);

Rendering\TagBuilderTest.cs (1)

180Assert.True(tagBuilder.HasInnerHtml);

TempDataDictionaryTest.cs (6)

37Assert.True(tempData.ContainsKey("Bar")); 89Assert.True(tempData.ContainsKey("Foo")); 90Assert.True(tempData.ContainsKey("Bar")); 108Assert.True(tempData.ContainsKey("Foo")); 125Assert.True(tempData.ContainsKey("Bar")); 160Assert.True(tempData.ContainsKey("bar"));

ViewComponents\DefaultViewComponentActivatorTests.cs (1)

77Assert.True(instance.AsyncDisposed);

ViewComponents\DefaultViewComponentFactoryTest.cs (3)

55Assert.True(component.Disposed); 79Assert.True(component.Disposed); 103Assert.True(component.Disposed);

ViewDataDictionaryTest.cs (2)

366Assert.True(model); 392Assert.True(model);

ViewEngines\CompositeViewEngineTest.cs (6)

88Assert.True(result.Success); 122Assert.True(result.Success); 223Assert.True(result.Success); 260Assert.True(result.Success); 355Assert.True(result.Success); 389Assert.True(result.Success);

ViewExecutorTest.cs (1)

210Assert.True(delegateHit);

ViewResultExecutorTest.cs (1)

230Assert.True(listener.ViewFound.IsMainPage);

AdditionalTextsTests.Schemas.cs (1)

224Assert.True(booleanTypeExample.GetValue<bool>());

OperationTests.MinimalApis.cs (2)

439Assert.True(idParam.Deprecated); 494Assert.True(path19.Parameters[3].Example.GetValue<bool>());

SchemaTests.cs (8)

221Assert.True(booleanTypeExample.GetValue<bool>()); 389Assert.True(JsonNode.DeepEquals(JsonNode.Parse("""{ "street": "ModelWithSummaryClass" }"""), modelWithSummary.Example)); 402Assert.True(JsonNode.DeepEquals(JsonNode.Parse("""{ "street": "ModelWithSummary1Prop" }"""), modelWithSummary1Prop.Examples[0])); 406Assert.True(JsonNode.DeepEquals(JsonNode.Parse("""{ "street": "ModelWithSummary2Prop" }"""), modelWithSummary2Prop.Examples[0])); 410Assert.True(JsonNode.DeepEquals(JsonNode.Parse("""{ "street": "ModelWithoutSummary1Prop" }"""), modelWithoutSummary1Prop.Examples[0])); 414Assert.True(JsonNode.DeepEquals(JsonNode.Parse("""{ "street": "ModelWithoutSummary2Prop" }"""), modelWithoutSummary2Prop.Examples[0])); 418Assert.True(JsonNode.DeepEquals(JsonNode.Parse("""{ "street": "ModelInline1Prop" }"""), modelInline1Prop.Example)); 422Assert.True(JsonNode.DeepEquals(JsonNode.Parse("""{ "street": "ModelInline2Prop" }"""), modelInline2Prop.Example));

SnapshotTestHelper.cs (1)

140Assert.True(result.Success);

Extensions\OpenApiRouteHandlerBuilderExtensionTests.cs (2)

145Assert.True(defaultOperation.Content.ContainsKey("text/plain")); 149Assert.True(annotatedOperation.Content.ContainsKey("application/json"));

Services\CreateSchemaReferenceIdTests.cs (3)

38Assert.True(requestBody.TryGetValue("application/json", out var mediaType)); 52Assert.True(document.Components.Schemas.TryGetValue("MyShapeMyTriangle", out var triangleSchema)); 55Assert.True(document.Components.Schemas.TryGetValue("MyShapeMySquare", out var squareSchema));

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.Parameters.cs (8)

57Assert.True(pathParameter.Required); 60Assert.True(guidParameter.Required); 63Assert.True(isCompletedParameter.Required); 83Assert.True(queryParameter.Required); 109Assert.True(headerParameter.Required); 138Assert.True(pathParameter.Required); 141Assert.True(guidParameter.Required); 144Assert.True(isCompletedParameter.Required);

Services\OpenApiDocumentService\OpenApiDocumentServiceTests.RequestBody.cs (4)

39Assert.True(operation.RequestBody.Required); 77Assert.True(operation.RequestBody.Required); 116Assert.True(operation.RequestBody.Required); 155Assert.True(operation.RequestBody.Required);

Services\OpenApiGeneratorTests.cs (16)

141Assert.True(request.Required); 456Assert.True(fooParam.Required); 462Assert.True(barParam.Required); 469Assert.True(fromBodyParam.Required); 484Assert.True(param.Required); 491Assert.True(param.Required); 516Assert.True(fooParam.Required); 540Assert.True(barParam.Required); 722Assert.True(requestBody.Required); 770Assert.True(requestBody.Required); 802Assert.True(requestBody.Required); 840Assert.True(fromFileParam0.Required); 881Assert.True(requestBody.Required); 989param => Assert.True(param.Required), 991param => Assert.True(param.Required), 1009param => Assert.True(param.Required),

Services\OpenApiSchemaService\OpenApiSchemaService.ParameterSchemas.cs (7)

162[(bool id = true) => { }, (JsonNode defaultValue) => Assert.True(defaultValue.GetValue<bool>())], 169[([DefaultValue(true)] bool id) => { }, (JsonNode defaultValue) => Assert.True(defaultValue.GetValue<bool>())], 172[([DefaultValue(null)] int? id) => { }, (JsonNode defaultValue) => Assert.True(defaultValue is null)], 174[([DefaultValue(null)] string? id) => { }, (JsonNode defaultValue) => Assert.True(defaultValue is null)], 176[([DefaultValue(null)] TaskStatus? status) => { }, (JsonNode defaultValue) => Assert.True(defaultValue is null)], 449Assert.True(parameter.Required); 782Assert.True(response.Content.TryGetValue("application/json", out var mediaType));

Services\OpenApiSchemaService\OpenApiSchemaService.PolymorphicSchemas.cs (25)

Services\OpenApiSchemaService\OpenApiSchemaService.RequestBodySchemas.cs (7)

121Assert.True(property.Value.Default.GetValue<bool>()); 155Assert.True(GetRequestBodyForPath(document, "/required-poco").Required); 159Assert.True(GetRequestBodyForPath(document, "/required-form").Required); 160Assert.True(GetRequestBodyForPath(document, "/non-required-form").Required); 329Assert.True(requestBody.TryGetValue("application/json", out var mediaType)); 369Assert.True(requestBody.TryGetValue("application/json", out var mediaType)); 839Assert.True(schema.AdditionalPropertiesAllowed);

Services\OpenApiSchemaService\OpenApiSchemaService.ResponseSchemas.cs (22)

Transformers\CustomSchemaTransformerTests.cs (26)

Transformers\DocumentTransformerTests.cs (2)

276Assert.True(transformerCalled); 277Assert.True(exceptionThrown);

Transformers\OperationTransformerTests.cs (3)

567Assert.True(operation.Deprecated); 607Assert.True(transformerCalled); 608Assert.True(exceptionThrown);

Transformers\SchemaTransformerTests.cs (16)

138Assert.True(cancellationToken.IsCancellationRequested); 339Assert.True(requestSchema.Extensions.ContainsKey("x-my-extension")); 342Assert.True(responseSchema.Extensions.ContainsKey("x-my-extension")); 349Assert.True(requestSchema.Extensions.ContainsKey("x-my-extension")); 352Assert.True(responseSchema.Extensions.ContainsKey("x-my-extension")); 512Assert.True(triangleSubschema.Extensions.TryGetValue("x-my-extension", out var _)); 589Assert.True(triangleSubschema.Extensions.TryGetValue("x-my-extension", out var triangleExtension)); 595Assert.True(squareSubschema.Extensions.TryGetValue("x-my-extension", out var squareExtension)); 631Assert.True(triangleSubschema.Extensions.TryGetValue("x-my-extension", out var triangleExtension)); 637Assert.True(squareSubschema.Extensions.TryGetValue("x-my-extension", out var squareExtension)); 673Assert.True(triangleSubschema.Extensions.TryGetValue("x-my-extension", out var triangleExtension)); 679Assert.True(squareSubschema.Extensions.TryGetValue("x-my-extension", out var squareExtension)); 752Assert.True(((JsonNodeExtension)responseSchema.Not.Extensions["modified-by-not-schema-transformer"]).Node.GetValue<bool>()); 758Assert.True(((JsonNodeExtension)triangleSchema.Not.Extensions["modified-by-not-schema-transformer"]).Node.GetValue<bool>()); 892Assert.True(transformerCalled); 893Assert.True(exceptionThrown);

CachedResponseBodyTests.cs (1)

21Assert.True(body.IsEmpty);

OutputCacheAttributeTests.cs (6)

30Assert.True(context.EnableOutputCaching); 56Assert.True(context.EnableOutputCaching); 84Assert.True(context.EnableOutputCaching); 99Assert.True(context.EnableOutputCaching); 118Assert.True(context.EnableOutputCaching); 131Assert.True(context.EnableOutputCaching);

OutputCacheEntryFormatterTests.cs (2)

84Assert.True(result.TryFindHeader(HeaderNames.Accept, out values)); 171Assert.True(SequenceEqual(expected.Body, actual.Body));

OutputCacheMiddlewareTests.cs (12)

45Assert.True(await middleware.TryServeFromCacheAsync(context, policies)); 89Assert.True(await middleware.TryServeFromCacheAsync(context, policies)); 118Assert.True(await middleware.TryServeFromCacheAsync(context, policies)); 147Assert.True(await middleware.TryServeFromCacheAsync(context, policies)); 188Assert.True(middleware.ContentIsNotModified(context)); 193Assert.True(middleware.ContentIsNotModified(context)); 230Assert.True(middleware.ContentIsNotModified(context)); 235Assert.True(middleware.ContentIsNotModified(context)); 264Assert.True(middleware.ContentIsNotModified(context)); 329Assert.True(middleware.ContentIsNotModified(context)); 361Assert.True(middleware.ContentIsNotModified(context)); 543Assert.True(StringValues.IsNullOrEmpty(context.HttpContext.Response.Headers.Date));

OutputCachePoliciesTests.cs (5)

18Assert.True(context.EnableOutputCaching); 29Assert.True(context.CacheVaryByRules.VaryByHost); 40Assert.True(context.AllowLocking); 97Assert.True(context.AllowLocking); 160Assert.True(context.EnableOutputCaching);

OutputCachePolicyBuilderTests.cs (14)

OutputCachePolicyProviderTests.cs (26)

OutputCacheTests.cs (4)

1013Assert.True(Guid.TryParse(s, out value)); 1017Assert.True(Guid.TryParse(s.Substring(s.Length - 36), out value)); 1058Assert.True(subsequentResponse.Headers.Contains(HeaderNames.Age)); 1072Assert.True(initialResponse.Headers.Contains("X-Value"));

OwinEnvironmentTests.cs (5)

170Assert.True(env1.Remove("owin.RequestProtocol")); 180Assert.True(env2.ContainsKey("owin.RequestProtocol")); 193Assert.True(owinEnvironment2.FeatureMaps.ContainsKey("owin.RequestProtocol")); 207Assert.True(owinEnvironment2.Count != 0); 216Assert.True(owinEnvironment.TryGetValue("owin.ResponseBody", out var responseBody));

OwinExtensionTests.cs (4)

82Assert.True(builderExecuted); 84Assert.True(applicationExecuted); 115Assert.True(builderExecuted); 117Assert.True(applicationExecuted);

RateLimitingMetricsTests.cs (1)

319Assert.True(measurement.Value > 0);

RateLimitingMiddlewareTests.cs (8)

81Assert.True(flag); 105Assert.True(onRejectedInvoked); 130Assert.True(onRejectedInvoked); 212Assert.True(onRejectedInvoked); 248Assert.True(onRejectedInvoked); 311Assert.True(globalOnRejectedInvoked); 375Assert.True(globalOnRejectedInvoked); 503Assert.True(globalOnRejectedInvoked);

Runtime\TagHelpers\TagHelperExecutionContextTest.cs (2)

33Assert.True(calledEnd); 57Assert.True(calledEnd);

Runtime\TagHelpers\TagHelperRunnerTest.cs (2)

147Assert.True(executableTagHelper1.Processed); 148Assert.True(executableTagHelper2.Processed);

TagHelpers\DefaultTagHelperContentTest.cs (21)

TagHelpers\TagHelperOutputTest.cs (6)

83Assert.True(passedUseCacheResult.HasValue); 84Assert.True(passedUseCacheResult.Value); 125Assert.True(passedUseCacheResult.HasValue); 126Assert.True(passedUseCacheResult.Value); 154Assert.True(passedUseCacheResult.HasValue); 199Assert.True(passedUseCacheResult.HasValue);

ResponseCachingMiddlewareTests.cs (15)

29Assert.True(await middleware.TryServeFromCacheAsync(context)); 68Assert.True(await middleware.TryServeFromCacheAsync(context)); 96Assert.True(await middleware.TryServeFromCacheAsync(context)); 145Assert.True(await middleware.TryServeFromCacheAsync(context)); 169Assert.True(await middleware.TryServeFromCacheAsync(context)); 199Assert.True(ResponseCachingMiddleware.ContentIsNotModified(context)); 204Assert.True(ResponseCachingMiddleware.ContentIsNotModified(context)); 231Assert.True(ResponseCachingMiddleware.ContentIsNotModified(context)); 237Assert.True(ResponseCachingMiddleware.ContentIsNotModified(context)); 265Assert.True(ResponseCachingMiddleware.ContentIsNotModified(context)); 324Assert.True(ResponseCachingMiddleware.ContentIsNotModified(context)); 352Assert.True(ResponseCachingMiddleware.ContentIsNotModified(context)); 412Assert.True(context.ShouldCacheResponse); 627Assert.True(StringValues.IsNullOrEmpty(context.HttpContext.Response.Headers.Date)); 922Assert.True(responseCachingFeatureAdded);

ResponseCachingPolicyProviderTests.cs (14)

ResponseCachingTests.cs (2)

962Assert.True(subsequentResponse.Headers.Contains(HeaderNames.Age)); 976Assert.True(initialResponse.Headers.Contains("X-Value"));

ResponseCompressionMiddlewareTest.cs (13)

ApacheModRewrite\ConditionPatternParserTest.cs (5)

21Assert.True(CompareConditions(expected, results)); 31Assert.True(CompareConditions(expected, results)); 49Assert.True(CompareConditions(expected, results)); 67Assert.True(CompareConditions(expected, results)); 82Assert.True(CompareConditions(expected, results));

ApacheModRewrite\CookieActionFactoryTest.cs (5)

20Assert.True(cookie.Secure); 21Assert.True(cookie.HttpOnly); 34Assert.True(action.Secure); 35Assert.True(action.HttpOnly); 49Assert.True(action.HttpOnly);

ApacheModRewrite\FlagParserTest.cs (4)

18Assert.True(DictionaryContentsEqual(expected.FlagDictionary, results.FlagDictionary)); 31Assert.True(DictionaryContentsEqual(expected.FlagDictionary, results.FlagDictionary)); 44Assert.True(DictionaryContentsEqual(expected.FlagDictionary, results.FlagDictionary)); 73Assert.True(results.GetValue(FlagType.Cookie, out value));

IISUrlRewrite\FileParserTests.cs (1)

145Assert.True(rules[0].Global);

IISUrlRewrite\UrlRewriteApplicationTests.cs (1)

67Assert.True(rules[0].Conditions.TrackAllCaptures);

RouteHandlerTest.cs (2)

106Assert.True(testDisposeDataSource.IsDisposed); 107Assert.True(testGroupDisposeDataSource.IsDisposed);

ShortCircuitTests.cs (1)

54Assert.True(response.Headers.Contains("Set"));

Builder\EndpointRoutingApplicationBuilderExtensionsTest.cs (2)

339Assert.True(app.Properties.TryGetValue("__EndpointRouteBuilder", out var local)); 340Assert.True(app.Properties.TryGetValue("__GlobalEndpointRouteBuilder", out var global));

Builder\GroupTest.cs (6)

229Assert.True(mapGetCalled); 233Assert.True(mapGetCalled); 292Assert.True(replacementCalled); 350Assert.True(routeEndpoint.Metadata.Count >= 1); 356Assert.True(routeEndpoint.Metadata.Count >= 1); 380Assert.True(groupChangeToken.HasChanged);

Builder\RequestDelegateEndpointRouteBuilderExtensionsTest.cs (2)

220Assert.True((bool)httpContext.Items["First"]!); 221Assert.True((bool)httpContext.Items["Second"]!);

Builder\RouteHandlerEndpointRouteBuilderExtensionsTest.cs (2)

766Assert.True(routeEndpointBuilder.RoutePattern.Parameters[0].IsCatchAll); 1010Assert.True(filterFactoryRan);

Builder\RoutingEndpointConventionBuilderExtensionsTest.cs (3)

59Assert.True(chainedBuilder.TestProperty); 86Assert.True(chainedBuilder.TestProperty); 133Assert.True(chainedBuilder.TestProperty);

CompositeEndpointDataSourceTest.cs (6)

176Assert.True(changeToken1.HasChanged); // old token is expected to be changed 189Assert.True(changeToken2.HasChanged); // old token is expected to be changed 215Assert.True(changeToken1.HasChanged); 225Assert.True(changeToken2.HasChanged); 250Assert.True(changeToken1.HasChanged); 261Assert.True(changeToken2.HasChanged);

ConstraintMatcherTest.cs (3)

92Assert.True(RouteConstraintMatcher.Match( 112Assert.True(RouteConstraintMatcher.Match( 184Assert.True(RouteConstraintMatcher.Match(

Constraints\FileNameRouteConstraintTest.cs (1)

41Assert.True(result);

Constraints\HttpMethodRouteConstraintTests.cs (2)

29Assert.True(result); 70Assert.True(result);

Constraints\NonFIleNameRouteConstraintTest.cs (2)

39Assert.True(result); 54Assert.True(result);

Constraints\RegexRouteConstraintTests.cs (1)

61Assert.True(match);

Constraints\RequiredRouteConstraintTests.cs (1)

89Assert.True(result);

Constraints\StringRouteConstraintTest.cs (2)

28Assert.True(match); 48Assert.True(match);

DataSourceDependentCacheTest.cs (1)

27Assert.True(called);

DefaultLinkGeneratorProcessTemplateTest.cs (47)

DefaultLinkGeneratorTest.cs (1)

549Assert.True(constraint.HasHttpContext);

EndpointMiddlewareTest.cs (9)

38Assert.True(calledNext); 62Assert.True(calledNext); 92Assert.True(calledEndpoint); 184Assert.True(calledEndpoint); 218Assert.True(calledEndpoint); 281Assert.True(calledEndpoint); 315Assert.True(calledEndpoint); 379Assert.True(calledEndpoint); 413Assert.True(calledEndpoint);

EndpointRoutingMiddlewareFormOptionsTest.cs (2)

83Assert.True(formOptions.BufferBody); 157Assert.True(formOptions.BufferBody);

EndpointRoutingMiddlewareTest.cs (3)

89Assert.True(eventFired); 178Assert.True((bool)httpContext.Items["ShortCircuit"]); 200Assert.True((bool)httpContext.Items["ShortCircuit"]);

InlineRouteParameterParserTests.cs (9)

113Assert.True(templatePart.IsOptional); 128Assert.True(templatePart.IsOptional); 143Assert.True(templatePart.IsOptional); 157Assert.True(templatePart.IsOptional); 171Assert.True(templatePart.IsOptional); 299Assert.True(param3.IsOptional); 516Assert.True(templatePart.IsOptional); 796Assert.True(templatePart.IsOptional); 826Assert.True(templatePart.IsOptional);

MatcherPolicyTest.cs (1)

26Assert.True(result);

Matching\AcceptsMatcherPolicyTest.cs (13)

Matching\CandidateSetTest.cs (3)

34Assert.True(candidateSet.IsValidCandidate(i)); 73Assert.True(candidateSet.IsValidCandidate(i)); 359Assert.True(candidateSet.IsValidCandidate(i));

Matching\ContentEncodingNegotiationMatcherPolicyTest.cs (14)

Matching\DfaMatcherBuilderTest.cs (12)

Matching\DfaMatcherTest.cs (6)

654Assert.True(cs.IsValidCandidate(0)); 659Assert.True(cs.IsValidCandidate(1)); 700Assert.True(cs.IsValidCandidate(0)); 705Assert.True(cs.IsValidCandidate(1)); 747Assert.True(cs.IsValidCandidate(0)); 752Assert.True(cs.IsValidCandidate(1));

Matching\EndpointComparerTest.cs (2)

88Assert.True(result > 0); 184Assert.True(result);

Matching\HostMatcherPolicyTest.cs (4)

60Assert.True(result); 115Assert.True(result); 133Assert.True(result); 152Assert.True(result);

Matching\HttpMethodMatcherPolicyTest.cs (4)

61Assert.True(result); 95Assert.True(result); 113Assert.True(result); 132Assert.True(result);

Patterns\InlineRouteParameterParserTest.cs (21)

RouteCollectionTest.cs (1)

155Assert.True(pathData.DataTokens.ContainsKey(dataToken.Key));

RouteEndpointBuilderTest.cs (2)

95Assert.True(httpMethodMetadata.AcceptCorsPreflight); 116(metadata) => Assert.True(metadata.AcceptCorsPreflight));

RouteHandlerOptionsTests.cs (1)

54Assert.True(options.ThrowOnBadRequest);

RouterMiddlewareTest.cs (3)

42Assert.True(routingFeature.RouteData.Values.ContainsKey("id")); 43Assert.True(context.Request.RouteValues.ContainsKey("id")); 60Assert.True(routeHandlerExecuted);

RouteTest.cs (19)

90Assert.True(routeValues.ContainsKey("country")); 92Assert.True(routeValues.ContainsKey("id")); 95Assert.True(context.RouteData.Values.ContainsKey("country")); 97Assert.True(context.RouteData.Values.ContainsKey("id")); 146Assert.True(routeValues.ContainsKey("country")); 148Assert.True(routeValues.ContainsKey("id")); 151Assert.True(constraint.Values.ContainsKey("country")); 153Assert.True(constraint.Values.ContainsKey("id")); 156Assert.True(context.RouteData.Values.ContainsKey("country")); 158Assert.True(context.RouteData.Values.ContainsKey("id")); 200Assert.True(routeValues.ContainsKey("id")); 203Assert.True(context.RouteData.Values.ContainsKey("id")); 242Assert.True(routeValues.ContainsKey("ssn")); 245Assert.True(context.RouteData.Values.ContainsKey("ssn")); 334Assert.True(routeValues.ContainsKey("id")); 337Assert.True(context.RouteData.Values.ContainsKey("id")); 791Assert.True(pathData.DataTokens.ContainsKey(dataToken.Key)); 830Assert.True(pathData.DataTokens.ContainsKey(dataToken.Key)); 1581Assert.True(templateRoute.DataTokens.ContainsKey(expectedKey));

RouteValuesAddressSchemeTest.cs (3)

25Assert.True(addressScheme.State.NamedMatches.TryGetValue("named", out var namedMatches)); 45Assert.True(addressScheme.State.NamedMatches.TryGetValue("named", out var namedMatches)); 65Assert.True(addressScheme.State.NamedMatches.TryGetValue("named", out var namedMatches));

Template\RoutePatternPrecedenceTests.cs (1)

38Assert.True(requiredValueParameterPrecedence < parameterPrecedence);

Template\RoutePrecedenceTestsBase.cs (2)

64Assert.True(xPrededence < yPrededence); 95Assert.True(xPrecedence > yPrecedence);

Template\TemplateBinderTests.cs (4)

725Assert.True(templateValuesResult.CombinedValues.TryGetValue("controller", out routeValue)); 727Assert.True(templateValuesResult.CombinedValues.TryGetValue("action", out routeValue)); 1184Assert.True(actualParts.Parameters.TryGetValue(kvp.Key, out value)); 1219Assert.True(TemplateBinder.RoutePartsEqual(left, right));

Tree\LinkGenerationDecisionTreeTest.cs (1)

139Assert.True(match.IsFallbackMatch);

AuthenticationTests.cs (10)

Http2Tests.cs (3)

117Assert.True(HttpMethods.Equals(method, httpContext.Request.Method)); 167Assert.True(HttpMethods.Equals(method, httpContext.Request.Method)); 231Assert.True(HttpMethods.Equals(method, httpContext.Request.Method));

Http3Tests.cs (6)

30Assert.True(httpContext.Request.IsHttps); 56Assert.True(httpContext.Request.IsHttps); 96Assert.True(httpContext.Request.IsHttps); 133Assert.True(httpContext.Request.IsHttps); 162Assert.True(httpContext.Request.IsHttps); 190Assert.True(httpContext.Request.IsHttps);

HttpsTests.cs (5)

212Assert.True(requestInfoFeature.RequestInfo.Count > 0); 274Assert.True(requestTimingFeature.Timestamps.Length > (int)HttpSysRequestTimingType.Http3HeaderDecodeEnd); 275Assert.True(requestTimingFeature.TryGetTimestamp(HttpSysRequestTimingType.RequestHeaderParseStart, out var headerStart)); 276Assert.True(requestTimingFeature.TryGetTimestamp(HttpSysRequestTimingType.RequestHeaderParseEnd, out var headerEnd)); 277Assert.True(requestTimingFeature.TryGetElapsedTime(HttpSysRequestTimingType.RequestHeaderParseStart, HttpSysRequestTimingType.RequestHeaderParseEnd, out var elapsed));

Listener\AuthenticationOnExistingQueueTests.cs (2)

162Assert.True(context.User.Identity.IsAuthenticated); 185Assert.True(context.User.Identity.IsAuthenticated);

Listener\RequestBodyTests.cs (2)

35Assert.True(context.AllowSynchronousIO); 60Assert.True(task.IsCanceled);

Listener\RequestHeaderTests.cs (7)

33Assert.True(StringValues.IsNullOrEmpty(headers["Connection"])); 34Assert.True(StringValues.IsNullOrEmpty(headers.Connection)); 37Assert.True(removed); 39Assert.True(StringValues.IsNullOrEmpty(headers["Custom-Header"])); 42Assert.True(headers.TryGetValue("Connection", out var connectionValue)); 49Assert.True(removed); 50Assert.True(removedAfterAssignValue);

Listener\ResponseBodyTests.cs (6)

71Assert.True(response.Headers.TransferEncodingChunked.HasValue); 87Assert.True(context.Response.HasStarted); 158Assert.True(writeTask.IsCanceled); 178Assert.True(writeTask.IsCanceled); 201Assert.True(writeTask.IsCanceled); 223Assert.True(writeTask.IsCanceled);

Listener\ResponseHeaderTests.cs (10)

Listener\ServerOnExistingQueueTests.cs (3)

223Assert.True(baseServer.Options.UrlPrefixes.Remove(address)); 224Assert.True(server.Options.UrlPrefixes.Remove(address)); 250Assert.True(statusCode == ErrorCodes.ERROR_SUCCESS);

Listener\ServerTests.cs (1)

193Assert.True(server.Options.UrlPrefixes.Remove(address));

OpaqueUpgradeTests.cs (9)

101Assert.True(upgradeThrew.Value); 115Assert.True(opaqueFeature.IsUpgradableRequest); 122Assert.True(await upgraded.Task.TimeoutAfter(TimeSpan.FromSeconds(1))); 142Assert.True(opaqueFeature.IsUpgradableRequest); 144Assert.True(feature.IsReadOnly); 154Assert.True(await upgraded.Task.TimeoutAfter(TimeSpan.FromSeconds(10))); 175Assert.True(opaqueFeature.IsUpgradableRequest); 182Assert.True(await upgraded.Task.TimeoutAfter(TimeSpan.FromSeconds(1))); 222Assert.True(opaqueFeature.IsUpgradableRequest);

RequestBodyLimitTests.cs (3)

371Assert.True(feature.IsReadOnly); 395Assert.True(feature.IsReadOnly); 434Assert.True(await Block.WaitAsync(TimeSpan.FromSeconds(10)));

RequestBodyTests.cs (2)

290Assert.True(requestWasProcessed); 368Assert.True(await Block.WaitAsync(TimeSpan.FromSeconds(10)));

RequestHeaderTests.cs (5)

29Assert.True(StringValues.IsNullOrEmpty(requestHeaders["Accept"])); 93Assert.True(requestHeaders.Contains(header)); 112Assert.True(request.HasEntityBody); 135Assert.True(request.HasEntityBody); 160Assert.True(request.HasEntityBody);

RequestTests.cs (1)

597Assert.True(wasCancelled);

ResponseBodyTests.cs (12)

26Assert.True(httpContext.Response.HasStarted); 27Assert.True(httpContext.Response.Headers.IsReadOnly); 55Assert.True(httpContext.Response.HasStarted); 56Assert.True(httpContext.Response.Headers.IsReadOnly); 85Assert.True(0 < (await response.Content.ReadAsByteArrayAsync()).Length); 104Assert.True(0 < (await response.Content.ReadAsByteArrayAsync()).Length); 160Assert.True(bytes.All(b => b == 0)); 276Assert.True(completed); 311Assert.True(await requestThrew.Task.WaitAsync(TimeSpan.FromSeconds(10))); 336Assert.True(onStartingCalled); 364Assert.True(onStartingCalled); 391Assert.True(onStartingCalled);

ResponseHeaderTests.cs (10)

33Assert.True(response.Headers.Date.HasValue); 132Assert.True(response.Headers.TryGetValues("Custom-Header1", out var header)); 151Assert.True(response.Headers.ConnectionClose.Value); 153Assert.True(response.Headers.TransferEncodingChunked.HasValue); 177Assert.True(response.Headers.ConnectionClose.Value); 204Assert.True(response.Headers.TransferEncodingChunked.HasValue); 206Assert.True(response.Headers.ConnectionClose.Value); 227Assert.True(response.HasStarted); 258Assert.True(response.HasStarted); 296Assert.True(headers.Contains(headerName));

ResponseSendFileTests.cs (14)

57Assert.True(await appThrew.Task.TimeoutAfter(TimeSpan.FromSeconds(10))); 113Assert.True(response.Headers.TransferEncodingChunked.Value); 133Assert.True(response.Headers.TransferEncodingChunked.Value); 152Assert.True(response.Headers.TransferEncodingChunked.Value); 172Assert.True(completed); 191Assert.True(completed); 209Assert.True(response.Headers.TransferEncodingChunked.Value); 297Assert.True(onStartingCalled); 316Assert.True(httpContext.Response.HasStarted); 323Assert.True(response.Headers.TransferEncodingChunked.HasValue); 380Assert.True(writeTask.IsCanceled); 408Assert.True(writeTask.IsCanceled); 437Assert.True(writeTask.IsCanceled); 464Assert.True(writeTask.IsCanceled);

ResponseTrailersTests.cs (3)

46Assert.True(httpContext.Response.SupportsTrailers()); 63Assert.True(httpContext.Response.SupportsTrailers()); 335Assert.True(headers.Contains(headerName));

ServerTests.cs (1)

54Assert.True(statusCode == ErrorCodes.ERROR_SUCCESS);

IISMiddlewareTests.cs (4)

56Assert.True(assertsExecuted); 427Assert.True(assertsExecuted); 484Assert.True(assertsExecuted); 529Assert.True(assertsExecuted);

AddressBinderTests.cs (3)

28Assert.True(AddressBinder.TryCreateIPEndPoint( 215Assert.True(bindTask.IsCompletedSuccessfully); 243Assert.True(bindTask.IsCompletedSuccessfully);

AsciiDecoding.cs (4)

40Assert.True(StringUtilities.BytesOrdinalEqualsStringAndAscii(s, asciiBytes)); 86Assert.True(StringUtilities.BytesOrdinalEqualsStringAndAscii(s, span)); 100Assert.True(StringUtilities.BytesOrdinalEqualsStringAndAscii(s, span)); 138Assert.True(StringUtilities.BytesOrdinalEqualsStringAndAscii(s, asciiBytes));

BufferWriterTests.cs (3)

57Assert.True(false); 61Assert.True(ex is ArgumentOutOfRangeException); 152Assert.True(writer.Span.Length > 10);

CertificatePathWatcherTests.cs (3)

162Assert.True(oldChangeToken.HasChanged); 165Assert.All(certificateConfigs, cc => Assert.True(cc.FileHasChanged)); 205Assert.True(oldChangeToken.HasChanged);

ConcurrentPipeWriterTests.cs (2)

381Assert.True((await flushTask0.DefaultTimeout()).IsCanceled); 382Assert.True((await flushTask1.DefaultTimeout()).IsCanceled);

ConnectionDispatcherTests.cs (2)

46Assert.True(pairs.ContainsKey("ConnectionId")); 54Assert.True(testLogger.Scopes.IsEmpty);

DiagnosticMemoryPoolTests.cs (1)

93Assert.True(threw);

Http1\Http1ConnectionTests.cs (19)

Http1\Http1OutputProducerTests.cs (5)

80Assert.True(completedResult.IsCompleted); 107Assert.True(cancelResult.IsCanceled); 156Assert.True(fakeMemory.Length >= bufferSize); 176Assert.True(fakeMemory.Length >= bufferSize); 198Assert.True(fakeMemory.Length >= bufferSize2);

Http2\Http2HeadersEnumeratorTests.cs (7)

93Assert.True(e.MoveNext()); 98Assert.True(e.MoveNext()); 103Assert.True(e.MoveNext()); 118Assert.True(e.MoveNext()); 123Assert.True(e.MoveNext()); 128Assert.True(e.MoveNext()); 133Assert.True(e.MoveNext());

Http2\Http2HPackEncoderTests.cs (1)

588Assert.True(integerDecoder.TryDecode(buffer[1], out var result));

Http3\Http3HeadersEnumeratorTests.cs (7)

93Assert.True(e.MoveNext()); 99Assert.True(e.MoveNext()); 105Assert.True(e.MoveNext()); 121Assert.True(e.MoveNext()); 127Assert.True(e.MoveNext()); 133Assert.True(e.MoveNext()); 139Assert.True(e.MoveNext());

Http3\Http3QPackEncoderTests.cs (7)

22Assert.True(QPackHeaderWriter.BeginEncodeHeaders(418, enumerator, buffer, ref totalHeaderSize, out var length)); 39Assert.True(QPackHeaderWriter.BeginEncodeHeaders(200, enumerator, buffer, ref totalHeaderSize, out var length)); 70Assert.True(QPackHeaderWriter.BeginEncodeHeaders(statusCode, enumerator, buffer, ref totalHeaderSize, out var length)); 88Assert.True(QPackHeaderWriter.BeginEncodeHeaders(enumerator, buffer, ref totalHeaderSize, out var length)); 107Assert.True(QPackHeaderWriter.BeginEncodeHeaders(enumerator, buffer, ref totalHeaderSize, out var length)); 126Assert.True(QPackHeaderWriter.BeginEncodeHeaders(enumerator, buffer, ref totalHeaderSize, out var length)); 145Assert.True(QPackHeaderWriter.BeginEncodeHeaders(enumerator, buffer, ref totalHeaderSize, out var length));

HttpHeadersTests.cs (5)

261Assert.True(headers.TryGetValue("Content-Length", out value)); 264Assert.True(httpHeaders.ContentLength.HasValue); 267Assert.True(headers.TryGetValue("Content-Length", out value)); 270Assert.True(httpHeaders.ContentLength.HasValue); 308Assert.True(httpHeaders.Keys.Contains("cache-control"));

HttpParserTests.cs (14)

41Assert.True(ParseRequestLine(parser, requestHandler, buffer, out var consumed, out var examined)); 48Assert.True(buffer.Slice(consumed).IsEmpty); 49Assert.True(buffer.Slice(examined).IsEmpty); 74Assert.True(buffer.Slice(examined).IsEmpty); 108Assert.True(ParseRequestLine(parser, requestHandler, buffer, out var consumed, out var examined)); 472Assert.True(parser.ParseHeaders(requestHandler, ref reader2)); 474Assert.True(buffer2.Slice(reader2.Position).IsEmpty); 648Assert.True(result); 694Assert.True(result); 710Assert.True(result); 733Assert.True(result); 852Assert.True(buffer.Slice(reader.Position).IsEmpty); 864Assert.True(parser.ParseHeaders(requestHandler, ref reader)); 871Assert.True(buffer.Slice(reader.Position).IsEmpty);

HttpRequestHeadersTests.cs (35)

HttpRequestStreamTests.cs (1)

22Assert.True(stream.CanRead);

HttpResponseStreamTests.cs (1)

36Assert.True(stream.CanWrite);

HttpUtilitiesTest.cs (1)

175Assert.True(HttpUtilities.IsHostHeaderValid(host));

KestrelServerTests.cs (2)

73Assert.True(server.Options.OptionsInUse.Any()); 74Assert.True(server.Options.OptionsInUse[0].IsTls);

ListenOptionsTests.cs (3)

44Assert.True(middlewareRan); 61Assert.True(localhostListenOptions.ProtocolsSetExplicitly); 64Assert.True(clone2.ProtocolsSetExplicitly);

MessageBodyTests.cs (28)

PinnedBlockMemoryPoolTests.cs (2)

204Assert.True(memoryPool.TryScheduleEviction(time.AddSeconds(10))); 219Assert.True(memoryPool.TryScheduleEviction(time.AddSeconds(20)));

ResourceCounterTests.cs (2)

25Assert.True(counter.TryLockOne()); 39Assert.True(counter.TryLockOne());

SniOptionsSelectorTests.cs (18)

src\Servers\Kestrel\shared\test\StreamExtensions.cs (1)

45Assert.True(offset >= buffer.Length);

src\Shared\test\Shared.Tests\runtime\Http2\DynamicTableTest.cs (6)

149Assert.True(table.Count > 0); 150Assert.True(table.Count < insertedHeaders.Count); 157Assert.True(expectedData.AsSpan().SequenceEqual(dynamicField.Name)); 158Assert.True(expectedData.AsSpan().SequenceEqual(dynamicField.Value)); 195Assert.True(headers[i].Name.AsSpan().SequenceEqual(dynamicTable[i].Name)); 196Assert.True(headers[i].Value.AsSpan().SequenceEqual(dynamicTable[i].Value));

src\Shared\test\Shared.Tests\runtime\Http2\HPackDecoderTest.cs (6)

514Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 530Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 546Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 562Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 578Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 594Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString));

src\Shared\test\Shared.Tests\runtime\Http2\HPackIntegerTest.cs (5)

19Assert.True(success); 21Assert.True(actualResult.Slice(0, bytesWritten).SequenceEqual(expectedResult)); 48Assert.True(finished); 65Assert.True(IntegerEncoder.Encode(i, prefixLength, integerBytes, out int length)); 75Assert.True(decodeResult);

src\Shared\test\Shared.Tests\runtime\Http3\QPackDecoderTest.cs (6)

192Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 208Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 224Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 240Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 256Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 272Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString));

src\Shared\test\Shared.Tests\runtime\Http3\VariableLengthIntegerHelperTests.cs (12)

35Assert.True(isSuccess); 51Assert.True(isSuccess); 84Assert.True(isSuccess); 116Assert.True(isSuccess); 147Assert.True(isSuccess); 183Assert.True(isSuccess); 199Assert.True(isSuccess); 229Assert.True(result); 270Assert.True(isSuccess); 286Assert.True(isSuccess); 314Assert.True(isSuccess); 342Assert.True(isSuccess);

StartLineTests.cs (15)

ThrowingWasUpgradedWriteOnlyStreamTests.cs (1)

18Assert.True(stream.CanWrite);

VariableIntHelperTests.cs (1)

18Assert.True(result);

ConfigurationReaderTests.cs (7)

60Assert.True(fileCert.IsFileCert); 67Assert.True(storeCert.IsStoreCert); 88Assert.True(fileCert.IsFileCert); 198Assert.True(end3.Certificate.ConfigSection.Exists()); 200Assert.True(cert3.IsFileCert); 211Assert.True(end4.Certificate.ConfigSection.Exists()); 214Assert.True(cert4.IsStoreCert);

HttpsConfigurationTests.cs (1)

236Assert.True(host.Services.GetRequiredService<IHttpsConfigurationService>().IsInitialized);

KestrelConfigurationLoaderTests.cs (50)

QuicConnectionContextTests.cs (7)

183Assert.True(read.IsCompleted); 231Assert.True(read.IsCompleted); 336Assert.True(readResult.IsCompleted); 379Assert.True(readResult.IsCompleted); 618Assert.True(readResult.IsCompleted); 691Assert.True(readResult1.IsCompleted); 719Assert.True(readResult2.IsCompleted);

QuicStreamContextTests.cs (10)

88Assert.True(quicStreamContext.CanWrite); 89Assert.True(quicStreamContext.CanRead); 194Assert.True(readResult.IsCompleted); 215Assert.True(quicStreamContext.CanWrite); 216Assert.True(quicStreamContext.CanRead); 318Assert.True(readResult.IsCompleted); 322Assert.True(quicStreamContext.CanRead); 395Assert.True(completeReadResult.IsCompleted); 430Assert.True(quicStreamContext.CanWrite); 474Assert.True(quicStreamContext.CanWrite);

QuicTestHelpers.cs (3)

160Assert.True(readResult.IsCompleted); 172Assert.True(quicStreamContext.CanWrite); 173Assert.True(quicStreamContext.CanRead);

src\Servers\Kestrel\shared\test\StreamExtensions.cs (1)

45Assert.True(offset >= buffer.Length);

WebHostTests.cs (2)

256Assert.True(response1.Headers.TryGetValues("alt-svc", out var altSvcValues1)); 270Assert.True(response2.Headers.TryGetValues("alt-svc", out var altSvcValues2));

SessionTests.cs (7)

94Assert.True(response.Headers.TryGetValues("Set-Cookie", out var values)); 96Assert.True(!string.IsNullOrWhiteSpace(values.First())); 149Assert.True(response.Headers.TryGetValues("Set-Cookie", out var values)); 181Assert.True(value.HasValue); 233Assert.True(value.HasValue); 292Assert.True(value.HasValue); 573Assert.True(exceptionThrown);

CommandLineApplicationTests.cs (11)

31Assert.True(called); 293Assert.True(option.HasValue()); 306Assert.True(option.HasValue()); 361Assert.True(option.HasValue()); 376Assert.True(option.HasValue()); 480Assert.True(option.HasValue()); 495Assert.True(option.HasValue()); 566Assert.True(option.HasValue()); 581Assert.True(option.HasValue()); 785Assert.True(commandRan); 1132Assert.True(optVerbose.HasValue());

CopyOnWriteDictionaryHolderTest.cs (3)

30Assert.True(holder.ContainsKey("test-key")); 60Assert.True(holder.HasBeenCopied); 87Assert.True(holder.HasBeenCopied);

CopyOnWriteDictionaryTest.cs (1)

52Assert.True(copyOnWriteDictionary.ContainsKey("test-key"));

ObjectMethodExecutorTest.cs (20)

PathNormalizerTests.cs (1)

84Assert.True(length >= 1);

QueryStringEnumerableTest.cs (2)

104Assert.True(kvp.EncodedName.Equals(kvp.DecodeName())); 105Assert.True(kvp.EncodedValue.Equals(kvp.DecodeValue()));

runtime\Http2\DynamicTableTest.cs (6)

149Assert.True(table.Count > 0); 150Assert.True(table.Count < insertedHeaders.Count); 157Assert.True(expectedData.AsSpan().SequenceEqual(dynamicField.Name)); 158Assert.True(expectedData.AsSpan().SequenceEqual(dynamicField.Value)); 195Assert.True(headers[i].Name.AsSpan().SequenceEqual(dynamicTable[i].Name)); 196Assert.True(headers[i].Value.AsSpan().SequenceEqual(dynamicTable[i].Value));

runtime\Http2\HPackDecoderTest.cs (6)

514Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 530Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 546Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 562Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 578Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString)); 594Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderNameString));

runtime\Http2\HPackIntegerTest.cs (5)

19Assert.True(success); 21Assert.True(actualResult.Slice(0, bytesWritten).SequenceEqual(expectedResult)); 48Assert.True(finished); 65Assert.True(IntegerEncoder.Encode(i, prefixLength, integerBytes, out int length)); 75Assert.True(decodeResult);

runtime\Http3\QPackDecoderTest.cs (6)

192Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 208Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 224Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 240Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 256Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString)); 272Assert.True(_handler.DecodedHeaders.ContainsKey(_literalHeaderFieldString));

runtime\Http3\VariableLengthIntegerHelperTests.cs (12)

35Assert.True(isSuccess); 51Assert.True(isSuccess); 84Assert.True(isSuccess); 116Assert.True(isSuccess); 147Assert.True(isSuccess); 183Assert.True(isSuccess); 199Assert.True(isSuccess); 229Assert.True(result); 270Assert.True(isSuccess); 286Assert.True(isSuccess); 314Assert.True(isSuccess); 342Assert.True(isSuccess);

SegmentWriteStreamTests.cs (3)

36Assert.True(stream.CanWrite); 69Assert.True(expectedSegment.SequenceEqual(segment)); 102Assert.True(expectedSegment.SequenceEqual(segment));

UrlDecoderTests.cs (9)

ValueStopwatchTest.cs (2)

21Assert.True(ValueStopwatch.StartNew().IsActive); 36Assert.True(stopwatch.GetElapsedTime().TotalMilliseconds > 0);

HubConnectionTests.cs (11)

624Assert.True(results.Count > 0 && results.Count < 1000); 908Assert.True(results.Count > 0 && results.Count < 1000); 909Assert.True(cts.IsCancellationRequested); 950Assert.True(results.Count > 0 && results.Count < 1000); 988Assert.True(results.Count > 0 && results.Count < 1000); 2014Assert.True(localPort > 0L); 2015Assert.True(remotePort > 0L); 2340Assert.True(connection.StartAsync().Wait(DefaultTimeout)); 2343Assert.True(invokeTask.Wait(DefaultTimeout)); 2346Assert.True(connection.DisposeAsync().AsTask().Wait(DefaultTimeout)); 2906Assert.True(ex is TaskCanceledException || ex is WebSocketException);

HubConnectionTests.Tracing.cs (6)

157Assert.True(a.HasRemoteParent); 169Assert.True(a.HasRemoteParent); 330Assert.True(a.HasRemoteParent); 331Assert.True(a.IsStopped); 352Assert.True(clientActivity.IsStopped); 417Assert.True(results.Count > 0 && results.Count < 1000);

HttpConnectionFactoryTests.cs (1)

43Assert.True(testHandler.Disposed);

HttpConnectionTests.cs (2)

201Assert.True(negotiateUrlTcs.Task.IsCompleted); 203Assert.True(headerWasFound);

HttpConnectionTests.Transport.cs (3)

74Assert.True(requestsExecuted); 149Assert.True(requestsExecuted); 189Assert.True(requestsExecuted);

HubClientProxyGeneratorTests.cs (4)

164Assert.True(noArgReg.IsDisposed); 165Assert.True(singleArgReg.IsDisposed); 166Assert.True(manyArgsReg.IsDisposed); 167Assert.True(returnTaskReg.IsDisposed);

HubConnectionTests.ConnectionLifecycle.cs (9)

46Assert.True(testConnection.Started.IsCompleted); 183Assert.True(testConnection.Started.IsCompleted); 280Assert.True(testConnection.Started.IsCompleted); 298Assert.True(testConnection.Started.IsCompleted); 325Assert.True(testConnection.Started.IsCompleted); 352Assert.True(testConnection.Started.IsCompleted); 370Assert.True(testConnection.Started.IsCompleted); 396Assert.True(testConnection.Started.IsCompleted); 435Assert.True(testConnection.Started.IsCompleted);

HubConnectionTests.cs (1)

693Assert.True(false);

HubConnectionTests.Reconnect.cs (4)

172Assert.True(TimeSpan.Zero <= retryContexts[1].ElapsedTime); 270Assert.True(TimeSpan.Zero <= retryContexts[1].ElapsedTime); 813Assert.True(TimeSpan.Zero <= retryContexts[0].ElapsedTime); 932Assert.True(TimeSpan.Zero <= retryContexts[0].ElapsedTime);

LongPollingTransportTests.cs (5)

87Assert.True(longPollingTransport.Input.TryRead(out var result)); 88Assert.True(result.IsCompleted); 312Assert.True(stopped); 556Assert.True(pollTcs.Task.IsCompleted); 747Assert.True(responseTaskCompletionSource.Task.IsCompleted);

ServerSentEventsTransportTests.cs (1)

436Assert.True(responseTaskCompletionSource.Task.IsCompleted);

TestServerTests.cs (1)

76Assert.True(webSocketFactoryCalled);

Internal\Formatters\BinaryMessageFormatterTests.cs (1)

128Assert.True(BinaryMessageParser.TryParseMessage(ref buffer, out var roundtripped));

Internal\Formatters\BinaryMessageParserTests.cs (2)

22Assert.True(BinaryMessageParser.TryParseMessage(ref span, out var message)); 57Assert.True(BinaryMessageParser.TryParseMessage(ref span, out var message));

Internal\Formatters\TextMessageParserTests.cs (5)

19Assert.True(TextMessageParser.TryParseMessage(ref message, out var payload)); 35Assert.True(TextMessageParser.TryParseMessage(ref message, out var payload)); 37Assert.True(TextMessageParser.TryParseMessage(ref message, out payload)); 45Assert.True(TextMessageParser.TryParseMessage(ref message, out var payload)); 47Assert.True(TextMessageParser.TryParseMessage(ref message, out payload));

Internal\Protocol\HandshakeProtocolTests.cs (5)

28Assert.True(HandshakeProtocol.TryParseRequestMessage(ref message, out var deserializedMessage)); 39Assert.True(HandshakeProtocol.TryParseRequestMessage(ref message, out var deserializedMessage)); 54Assert.True(HandshakeProtocol.TryParseResponseMessage(ref message, out var response)); 63Assert.True(HandshakeProtocol.TryParseResponseMessage(ref message, out var response)); 92Assert.True(HandshakeProtocol.TryParseRequestMessage(ref message, out _)));

Internal\Protocol\JsonHubProtocolTests.cs (4)

131Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var message)); 164Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var message)); 197Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var message)); 201Assert.True(completionMessage.HasResult);

Internal\Protocol\JsonHubProtocolTestsBase.cs (5)

236Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var message)); 442Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var message)); 455Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out message)); 474Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var hubMessage)); 490Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var hubMessage));

Internal\Protocol\MessagePackHubProtocolTestBase.cs (4)

230Assert.True(HubProtocol.TryParseMessage(ref data, new TestBinder(testData.Message), out var message)); 255Assert.True(HubProtocol.TryParseMessage(ref data, new TestBinder(expectedMessage), out var message)); 276Assert.True(BinaryMessageParser.TryParseMessage(ref byteSpan, out var unframed)); 480Assert.True(BinaryMessageParser.TryParseMessage(ref data, out var message));

Internal\Protocol\MessagePackHubProtocolTests.cs (4)

222Assert.True(HubProtocol.TryParseMessage(ref data, binder, out var message)); 235Assert.True(HubProtocol.TryParseMessage(ref data, binder, out message)); 252Assert.True(HubProtocol.TryParseMessage(ref data, binder, out var hubMessage)); 265Assert.True(HubProtocol.TryParseMessage(ref data, binder, out var hubMessage));

AddSignalRTests.cs (2)

116Assert.True(hubOptions.UserHasSetValues); 165Assert.True(globalOptions.DisableImplicitFromServicesParameters);

EndToEndTests.cs (4)

447Assert.True(false); 621Assert.True(false); 727Assert.True(QueryHelpers.ParseQuery(url.Query).TryGetValue("id", out var id)); 734Assert.True(_prevConnectionId != id);

HubConnectionHandlerTests.Activity.cs (3)

148Assert.True(invocationActivity.HasRemoteParent); 274Assert.True(invocationActivity.HasRemoteParent); 494Assert.True(activity.IsStopped);

HubConnectionHandlerTests.cs (14)

110Assert.True(state.TokenCallbackTriggered); 112Assert.True(state.TokenStateInDisconnected); 137Assert.True(firedOnConnected); 138Assert.True(firedOnDisconnected); 364Assert.True(task.IsCompleted); 438Assert.True(task.IsCompleted); 946Assert.True(hasErrorLog); 1028Assert.True(message.AllowReconnect); 1262Assert.True(false); 2294Assert.True(close.AllowReconnect); 2629Assert.True((bool)result); 4004Assert.True((bool)response.Result); 4679Assert.True(Assert.IsType<bool>(res.Result)); 4716Assert.True(Assert.IsType<bool>(res.Result));

HubConnectionHandlerTestUtils\Utils.cs (1)

46Assert.True((expectedInvocation.InvocationId == null && actualInvocation.InvocationId == null) ||

Internal\MessageBufferTests.cs (43)

MapSignalRTests.cs (1)

70Assert.True(executedConfigure);

WebSocketsTransportTests.cs (4)

85Assert.True(factoryWasUsed); 117Assert.True(webSocketsTransport.Input.TryRead(out var result)); 148Assert.True(webSocketsTransport.Input.TryRead(out var result)); 186Assert.True(webSocketsTransport.Input.TryRead(out var result));

StaticAssetsIntegrationTests.cs (1)

118Assert.True(response.Headers.CacheControl.NoCache);

FallbackStaticFileTest.cs (2)

126Assert.True(fileInfo.Exists); 132Assert.True(responseContent.SequenceEqual(fileContents));

StaticFileMiddlewareTests.cs (3)

164Assert.True(response.Content.Headers.ContentLength == fileInfo.Length); 171Assert.True(responseContent.SequenceEqual(fileContents)); 206Assert.True(response.Content.Headers.ContentLength == fileInfo.Length);

DefaultContentTypeProviderTests.cs (7)

20Assert.True(provider.TryGetContentType("known.txt", out var contentType)); 36Assert.True(provider.TryGetContentType("known.dvr-ms", out var contentType)); 44Assert.True(provider.TryGetContentType(@"/first/example.txt", out var contentType)); 46Assert.True(provider.TryGetContentType(@"\second\example.txt", out contentType)); 54Assert.True(provider.TryGetContentType(@"/first.css/example.txt", out var contentType)); 56Assert.True(provider.TryGetContentType(@"\second.css\example.txt", out contentType)); 65Assert.True(provider.TryGetContentType($"{new string(System.IO.Path.GetInvalidPathChars())}.txt", out contentType));

DefaultFilesMiddlewareTests.cs (1)

328Assert.True(new DefaultFilesOptions().RedirectToAppendTrailingSlash);

DirectoryBrowserMiddlewareTests.cs (3)

172Assert.True(response.Content.Headers.ContentLength > 0); 229Assert.True(response.Content.Headers.ContentLength > 0); 380Assert.True(new DirectoryBrowserOptions().RedirectToAppendTrailingSlash);

RangeHelperTests.cs (1)

104Assert.True(isRangeRequest);

StaticFileContextTest.cs (12)

30Assert.True(validateResult); 57Assert.True(validateResult); 58Assert.True(contentTypeResult); 59Assert.True(result); 82Assert.True(validateResult); 83Assert.True(contentTypeResult); 84Assert.True(result); 111Assert.True(validateResult); 112Assert.True(contentTypeResult); 139Assert.True(validateResult); 140Assert.True(contentTypeResult); 141Assert.True(result);

StaticFileMiddlewareTests.cs (16)

ClientHandlerTests.cs (2)

27Assert.True(features.Get<IHttpRequestLifetimeFeature>().RequestAborted.CanBeCanceled); 76Assert.True(features.Get<IHttpRequestLifetimeFeature>().RequestAborted.CanBeCanceled);

HttpContextBuilderTests.cs (2)

41Assert.True(context.RequestAborted.CanBeCanceled); 313Assert.True(c.RequestAborted.WaitHandle.WaitOne(TimeSpan.FromSeconds(10)));

ResponseFeatureTests.cs (4)

20Assert.True(responseInformation.HasStarted); 21Assert.True(responseInformation.Headers.IsReadOnly); 36Assert.True(responseInformation.HasStarted); 37Assert.True(responseInformation.Headers.IsReadOnly);

TestClientTests.cs (3)

431Assert.True(readCanceled); 775Assert.True(hello.SequenceEqual(buffer.Take(hello.Length))); 780Assert.True(world.SequenceEqual(buffer.Take(world.Length)));

TestServerTests.cs (3)

288Assert.True(response.IsSuccessStatusCode); 467Assert.True(testServer.AllowSynchronousIO); 468Assert.True(testServer.PreserveExecutionContext);

WebSocketClientTests.cs (2)

106Assert.True(res.EndOfMessage); 130Assert.True(webSocketFeature.IsWebSocketRequest);

FakeCertificateFactoryTests.cs (2)

21Assert.True(DateTime.Now > certificate.NotBefore + TimeSpan.FromHours(1)); 22Assert.True(DateTime.Now < certificate.NotAfter - TimeSpan.FromHours(1));

FakeCertificateHttpClientHandlerTests.cs (2)

25Assert.True(sut.ServerCertificateCustomValidationCallback!( 37Assert.True(sut.ServerCertificateCustomValidationCallback!(

WebApplicationTests.cs (10)

1210Assert.True(string.IsNullOrEmpty(app.Configuration["A"])); 1211Assert.True(string.IsNullOrEmpty(app.Configuration["C"])); 1254Assert.True(string.IsNullOrEmpty(app.Configuration["B"])); 2472Assert.True(helloEndpointCalled); 2473Assert.True(customMiddlewareExecuted); 2505Assert.True(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); 2510Assert.True(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); 2511Assert.True(app.Properties.ContainsKey("__AuthorizationMiddlewareSet")); 2528Assert.True(iHostApplicationBuilder.Environment.IsProduction()); 2943Assert.True((bool)val);

WebHostTests.cs (1)

125Assert.True(routeOptions.Value.ConstraintMap.ContainsKey("regex"));

HandshakeTests.cs (3)

24Assert.True(HandshakeHelpers.IsRequestKeyValid(key)); 52Assert.True(HandshakeHelpers.ParseDeflateOptions(clientHeader.AsSpan(), serverContextTakeover: true, serverMaxWindowBits: 15, 70Assert.True(HandshakeHelpers.ParseDeflateOptions(clientHeader.AsSpan(), serverContextTakeover: false, serverMaxWindowBits: 14,

Http2WebSocketTests.cs (1)

28Assert.True(httpContext.WebSockets.IsWebSocketRequest);

WebSocketCompressionMiddlewareTests.cs (4)

20Assert.True(context.WebSockets.IsWebSocketRequest); 52Assert.True(context.WebSockets.IsWebSocketRequest); 82Assert.True(context.WebSockets.IsWebSocketRequest); 115Assert.True(context.WebSockets.IsWebSocketRequest);

WebSocketMiddlewareTests.cs (39)

AspNetCoreTempDirectoryTests.cs (1)

13Assert.True(Directory.Exists(tempDirectory));

FileBufferingReadStreamTests.cs (33)

FileBufferingWriteStreamTests.cs (4)

258Assert.True(bufferingStream.Disposed); 274Assert.True(bufferingStream.Disposed); 302Assert.True(bufferingStream.Disposed); 318Assert.True(bufferingStream.Disposed);

FormPipeReaderTests.cs (12)

MultipartReaderTests.cs (2)

341Assert.True(stream1.CanSeek); 347Assert.True(stream2.CanSeek);

SdkManagedToolTests.cs (2)

34Assert.True(ManagedToolTask.IsSdkFrameworkToCoreBridgeTask); 40Assert.True(ManagedToolTask.IsBuiltinToolRunningOnCoreClr);

CopyRefAssemblyTests.cs (3)

75Assert.True(task.Execute()); 96Assert.True(task.Execute()); 127Assert.True(task.Execute());

GenerateMSBuildEditorConfigTests.cs (2)

376Assert.True(File.Exists(fileName)); 377Assert.True(configTask.WriteMSBuildEditorConfig());

IntegrationTests.cs (1)

541Assert.True(result.ExitCode != 0);

MapSourceRootTests.cs (6)

75Assert.True(result); 120Assert.True(result); 198Assert.True(result); 233Assert.True(result); 351Assert.True(result); 454Assert.True(result);

TargetTests.cs (19)

TestUtilities\DotNetSdkTestBase.cs (5)

177Assert.True(File.Exists(csharpCoreTargets)); 178Assert.True(File.Exists(visualBasicCoreTargets)); 196Assert.True(File.Exists(Path.Combine(ObjDir.Path, "project.assets.json"))); 197Assert.True(File.Exists(Path.Combine(ObjDir.Path, ProjectFileName + ".nuget.g.props"))); 198Assert.True(File.Exists(Path.Combine(ObjDir.Path, ProjectFileName + ".nuget.g.targets")));

src\Features\DiagnosticsTestUtilities\CodeActions\CodeFixVerifierHelper.cs (1)

121Assert.True(optionKey.Option.Definition.IsEditorConfigOption);

src\Analyzers\CSharp\Tests\UpdateProjectToAllowUnsafe\UpdateProjectToAllowUnsafeTests.cs (1)

39Assert.True(((CSharpCompilationOptions)newSolution.Projects.Single().CompilationOptions!).AllowUnsafe);

CommandLineIVTTests.cs (1)

342Assert.True(compiler.Arguments.ReportInternalsVisibleToAttributes);

CommandLineTests.cs (182)

ChangeSignature\RemoveParametersTests.cs (4)

255Assert.True(result.Succeeded); 342Assert.True(result.Succeeded); 385Assert.True(state.IsUnspecified); 388Assert.True(state.IsUnspecified);

CodeActions\ApplyChangesOperationTests.cs (1)

244Assert.True(workspace.TryApplyChanges(changedSolution));

CodeActions\InlineMethod\CSharpInlineMethodTests_CrossLanguage.cs (1)

26Assert.True(actions.IsEmpty);

CodeActions\PreviewExceptionTests.cs (4)

35Assert.True(errorReported); 48Assert.True(errorReported); 70Assert.True(extensionManager.IsDisabled(provider)); 78Assert.True(extensionManager.IsDisabled(provider));

CodeActions\PreviewTests.cs (3)

118Assert.True(preview is DifferenceViewerPreview); 127Assert.True(preview is string); 134Assert.True(preview is string);

CodeActions\PullMemberUp\CSharpPullMemberUpTests.cs (1)

55Assert.True(true);

CodeActions\SyncNamespace\CSharpSyncNamespaceTestsBase.cs (2)

91Assert.True(actualFolderPaths.Contains(expected)); 203Assert.True(changedDocumentIds.Contains(refDocumentId));

CodeGeneration\SyntaxGeneratorTests.cs (2)

84Assert.True(semanticModel.TryGetSpeculativeSemanticModel( 95Assert.True(constantValue.HasValue);

Completion\CompletionProviders\CrefCompletionProviderTests.cs (1)

412Assert.True(called);

Completion\CompletionProviders\DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs (1)

714Assert.True(expectedSymbolKinds.SequenceEqual(result.PossibleSymbolKinds));

Completion\CompletionProviders\OverrideCompletionProviderTests.cs (1)

3487Assert.True(completionList.ItemsList.Any(c => c.DisplayText == "Bar()"));

Completion\CompletionServiceTests.cs (5)

63Assert.True(provider is ThirdPartyCompletionProvider); 135Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions( 182Assert.True(performSort == completionList.ItemsList.SequenceEqual(completionListManuallySorted)); 210Assert.True(workspace.SetCurrentSolution(_ => project.Solution, WorkspaceChangeKind.SolutionChanged)); 232Assert.True(completionList.ItemsList.Select(item => item.DisplayText).Contains(expectedItem));

Debugging\ProximityExpressionsGetterTests.cs (1)

112Assert.True(actualTerms is null or { Count: > 0 });

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (3)

98Assert.True(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 111Assert.True(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 757Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences(

EditorConfigSettings\Updater\SettingsUpdaterTests.cs (3)

39Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution 58Assert.True(analyzerConfigDocument!.TryGetText(out var actualText)); 352Assert.True(workspace.TryApplyChanges(newSolution));

EncapsulateField\EncapsulateFieldCommandHandlerTests.cs (1)

208Assert.True(state.IsUnspecified);

Extensions\SyntaxTreeExtensionsTests.cs (1)

30Assert.True(tree.IsInInactiveRegion(pos, CancellationToken.None));

ExtractInterface\ExtractInterfaceTests.cs (1)

1218Assert.True(state.IsUnspecified);

ExtractMethod\ExtractMethodBase.cs (4)

144Assert.True(!result.Succeeded || result.Reasons.Length > 0); 174Assert.True(status.Failed || status.Reasons.Length > 0); 178Assert.True(status.Succeeded); 203Assert.True(status.Failed);

ExtractMethod\ExtractMethodTests.cs (1)

10085Assert.True(state.IsUnspecified);

Formatting\Indentation\SmartIndenterEnterOnTokenTests.cs (1)

1327Assert.True(

Interactive\BraceMatching\InteractiveBraceHighlightingTests.cs (17)

NavigateTo\NavigateToSearcherTests.cs (1)

356Assert.True(searchGeneratedDocumentsAsyncCalled);

OnTheFlyDocs\OnTheFlyDocsUtilitiesTests.cs (2)

46Assert.True(result.All(item => item == null)); 128Assert.True(result.All(item => item is not null));

Organizing\OrganizeTypeDeclarationTests.cs (2)

1083Assert.True(state.IsUnspecified); 1086Assert.True(state.IsUnspecified);

PdbSourceDocument\AbstractPdbSourceDocumentTests.cs (2)

146Assert.True(file.DocumentTitle.Contains($"[{FeaturesResources.external}]")); 150Assert.True(file.DocumentTitle.Contains($"[{FeaturesResources.embedded}]"));

PdbSourceDocument\ImplementationAssemblyLookupServiceTests.cs (3)

88Assert.True(service.TryFindImplementationAssemblyPath(GetDllPath(packDir), out var implementationDll)); 126Assert.True(service.TryFindImplementationAssemblyPath(GetDllPath(packDir), out var implementationDll)); 543Assert.True(_logs.Add(message));

PdbSourceDocument\PdbSourceDocumentLoaderServiceTests.cs (1)

49Assert.True(result.FromRemoteLocation);

PdbSourceDocument\PdbSourceDocumentTests.cs (5)

873Assert.True(result); 892Assert.True(openResult); 895Assert.True(closeResult); 914Assert.True(result); 935Assert.True(openResult);

RawStringLiteral\RawStringLiteralCommandHandlerTests.cs (1)

71Assert.True(TextView.Caret.InVirtualSpace);

SplitStringLiteral\SplitStringLiteralCommandHandlerTests.cs (1)

148Assert.True(notHandled);

StringCopyPaste\StringCopyPasteCommandHandlerTests.cs (2)

79Assert.True(TextView.Caret.InVirtualSpace); 104Assert.True(copyEditorOperations.CopySelection());

SymbolKey\SymbolKeyTestBase.cs (1)

88Assert.True(comparer.Equals(sid, deserialized));

Workspaces\WorkspaceTests_EditorFeatures.cs (2)

695Assert.True(foundTheError); 1489Assert.True(workspace1.TryApplyChanges(newSolution));

EmbeddedLanguages\Json\CSharpJsonParserTests.cs (2)

37Assert.True(token.Kind() == SyntaxKind.StringLiteralToken); 183Assert.True(allChars.IsDefault);

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (5)

128Assert.True(allChars.IsDefault); 152Assert.True(result); 168Assert.True(regex.GetGroupNumbers().OrderBy(v => v).SequenceEqual( 171Assert.True(regex.GetGroupNames().Where(v => !int.TryParse(v, out _)).OrderBy(v => v).SequenceEqual( 379Assert.True(RegexLexer.IsEscapeCategoryChar(VirtualChar.Create(new Rune(ch), new TextSpan(0, 1))));

CodeGen\CodeGenAsyncIteratorTests.cs (4)

963Assert.True(m.IsAsync); 964Assert.True(m.IsIterator); 1126Assert.True(m.IsAsync); 2073Assert.True(m.IsAsync);

CodeGen\CodeGenAsyncMethodBuilderOverrideTests.cs (4)

134Assert.True(method.IsAsync); 135Assert.True(method.IsAsyncEffectivelyReturningTask(compilation)); 137Assert.True(method.IsAsync); 138Assert.True(method.IsAsyncEffectivelyReturningGenericTask(compilation));

CodeGen\CodeGenAsyncTests.cs (1)

98Assert.True(options.EnableEditAndContinue);

CodeGen\CodeGenAwaitForeachTests.cs (14)

CodeGen\CodeGenAwaitUsingTests.cs (3)

3622Assert.True(first.Equals(first)); 3623Assert.True(first.Equals((object)first)); 3626Assert.True(first.GetHashCode() == another.GetHashCode());

CodeGen\CodeGenCapturing.cs (1)

121Assert.True(numSubsets > 0);

CodeGen\CodeGenDeconstructTests.cs (18)

1678Assert.True(x.Type.GetSymbol().TupleElementNames.IsDefault); 3584Assert.True(model.LookupNames(decl.SpanStart).Contains(decl.Identifier.ValueText)); 3604Assert.True(model.LookupNames(reference.SpanStart).Contains(decl.Identifier.ValueText)); 3617Assert.True(model.LookupNames(decl.SpanStart).Contains(decl.Identifier.ValueText)); 3623Assert.True(model.LookupNames(reference.SpanStart).Contains(decl.Identifier.ValueText)); 5124Assert.True(nodes.Any(n => n.Kind() == SyntaxKind.SimpleAssignmentExpression)); 5608Assert.True(xType.Type.IsErrorType()); 5618Assert.True(yType.IsErrorType()); 5649Assert.True(x1Type.IsErrorType()); 5658Assert.True(x2Type.IsErrorType()); 5693Assert.True(x1Type.IsErrorType()); 5702Assert.True(x2Type.IsErrorType()); 6977Assert.True(model.GetSymbolInfo(discard1).IsEmpty); 6986Assert.True(model.GetSymbolInfo(discard2).IsEmpty); 7004Assert.True(model.GetSymbolInfo(discard4).IsEmpty); 7070Assert.True(symbol.TypeWithAnnotations.Type.IsErrorType()); 7867Assert.True(comp2.Compilation.GetMember<IEventSymbol>("C.E").IsWindowsRuntimeEvent); 7930Assert.True(comp2.Compilation.GetMember<IEventSymbol>("S.E").IsWindowsRuntimeEvent);

CodeGen\CodeGenDynamicTests.cs (4)

593Assert.True(container.IsStatic); 602Assert.True(field.IsStatic); 828Assert.True(d.IsSealed); 852Assert.True(member.IsVirtual);

CodeGen\CodeGenFunctionPointersTests.cs (31)

CodeGen\CodeGenImplicitImplementationTests.cs (1)

778Assert.True(typeSymbol.Interfaces().All(iface => iface.Name == "IBase" || iface.Name == "IBase1" || iface.Name == "IBase2"));

CodeGen\CodeGenIterators.cs (1)

2330Assert.True(expectedIL.IndexOf("<>_", StringComparison.Ordinal) < 0);

CodeGen\CodeGenLocalFunctionTests.cs (44)

2594Assert.True(goo.IsStatic); 2612Assert.True(goo.IsStatic); 3135Assert.True(goo.IsStatic); 3137Assert.True(goo.Parameters[0].Type.IsValueType); 3164Assert.True(goo.Parameters[0].Type.IsValueType); 3165Assert.True(bar.Parameters[0].Type.IsValueType); 3166Assert.True(bar.Parameters[1].Type.IsValueType); 3208Assert.True(inner.IsStatic); 3209Assert.True(middle.IsStatic); 3210Assert.True(outer.IsStatic); 3217Assert.True(inner.Parameters[0].Type.IsValueType); 3218Assert.True(inner.Parameters[1].Type.IsValueType); 3219Assert.True(middle.Parameters[0].Type.IsValueType); 3278Assert.True(goo.IsStatic); 3280Assert.True(goo.Parameters[0].Type.IsValueType); 3314Assert.True(goo.IsStatic); 3315Assert.True(bar.IsStatic); 3321Assert.True(goo.Parameters[1].Type.IsValueType); 3322Assert.True(bar.Parameters[1].Type.IsValueType); 3323Assert.True(bar.Parameters[2].Type.IsValueType); 4240Assert.True(goo.IsStatic); 5770Assert.True(localFunction.IsExtern); 5842Assert.True(localFunction.IsExtern); 5849Assert.True(importData.SetLastError); 5850Assert.True(importData.ExactSpelling); 5965Assert.True(localFn1.HasSpecialName); 5999Assert.True(methodParam.IsMetadataIn); 6000Assert.True(methodParam.IsMetadataOut); 6003Assert.True(localFunctionParam.IsMetadataIn); 6004Assert.True(localFunctionParam.IsMetadataOut); 6009Assert.True(methodParam.IsMetadataIn); 6010Assert.True(methodParam.IsMetadataOut); 6013Assert.True(localFunctionParam.IsMetadataIn); 6014Assert.True(localFunctionParam.IsMetadataOut); 6055Assert.True(methodParam.IsMetadataIn); 6059Assert.True(localFunctionParam.IsMetadataIn); 6065Assert.True(methodParam.IsMetadataIn); 6069Assert.True(localFunctionParam.IsMetadataIn); 6113Assert.True(methodParam.IsMetadataOut); 6117Assert.True(localFunctionParam.IsMetadataOut); 6123Assert.True(methodParam.IsMetadataOut); 6127Assert.True(localFunctionParam.IsMetadataOut); 6165Assert.True(param.IsMetadataIn); 6172Assert.True(synthesizedParam.IsMetadataOut);

CodeGen\CodeGenOperators.cs (1)

5711Assert.True(passed);

CodeGen\CodeGenOverridingAndHiding.cs (10)

3784Assert.True(methodA.IsVirtual); 3785Assert.True(methodB.IsVirtual); 3786Assert.True(methodC.IsOverride); 3857Assert.True(methodA.IsVirtual); 3858Assert.True(methodB.IsVirtual); 3859Assert.True(methodC.IsOverride); 3952Assert.True(derivedMethod.IsOverride); 3955Assert.True(overrideMethod.IsOverride); 4006Assert.True(methodA.IsVirtual); 4009Assert.True(methodC.IsOverride);

CodeGen\CodeGenReadonlyStructTests.cs (29)

CodeGen\CodeGenScriptTests.cs (6)

220Assert.True(s2.AnonymousTypeManager.AreTemplatesSealed); 223Assert.True(s1.AnonymousTypeManager.AreTemplatesSealed); 226Assert.True(s0.AnonymousTypeManager.AreTemplatesSealed); 246Assert.True(s1.AnonymousTypeManager.AreTemplatesSealed); 250Assert.True(s0.AnonymousTypeManager.AreTemplatesSealed); 527Assert.True(((MethodSymbol)methodData.Method).ReturnsVoid);

CodeGen\CodeGenTests.cs (2)

13061Assert.True(type.CanBeReferencedByName); 14661Assert.True(result.Success);

CodeGen\CodeGenTupleEqualityTests.cs (1)

4282Assert.True(left.Type.IsTupleType);

CodeGen\CodeGenTupleTest.cs (474)

CodeGen\DestructorTests.cs (11)

CodeGen\EventTests.cs (5)

218Assert.True((addMethod.ImplementationAttributes & System.Reflection.MethodImplAttributes.Synchronized) == 0); 224Assert.True((removeMethod.ImplementationAttributes & System.Reflection.MethodImplAttributes.Synchronized) == 0); 230Assert.True(@event.HasAssociatedField); 791Assert.True((addMethod.ImplementationAttributes & System.Reflection.MethodImplAttributes.Synchronized) == 0); 794Assert.True((removeMethod.ImplementationAttributes & System.Reflection.MethodImplAttributes.Synchronized) == 0);

CodeGen\FixedSizeBufferTests.cs (2)

590Assert.True(f.IsFixedSizeBuffer); 1169Assert.True(retargetingField.IsFixedSizeBuffer);

CodeGen\ForeachTest.cs (1)

1689Assert.True(local.IsVar);

CodeGen\IndexAndRangeTests.cs (1)

1001Assert.True(property.IsIndexer);

CodeGen\IndexerTests.cs (2)

157Assert.True(indexer.MustCallMethodsDirectly); //since has parameters, but isn't an indexer 258Assert.True(indexer.IsIndexer);

CodeGen\WinMdDelegateTests.cs (1)

268Assert.True(isWinRt(fieldSymbol));

Emit\CompilationEmitTests.cs (51)

Emit\DeterministicTests.cs (1)

88Assert.True(resultNonDeterministic.Success);

Emit\DynamicAnalysis\DynamicInstrumentationTests.cs (1)

2460Assert.True(false);

Emit\EmitCustomModifiers.cs (3)

608Assert.True(parameter.RefCustomModifiers.IsEmpty); 664Assert.True(baseParameter.RefCustomModifiers.IsEmpty); 672Assert.True(derivedParameter.RefCustomModifiers.IsEmpty);

Emit\EmitErrorTests.cs (1)

255Assert.True(result.Success);

Emit\EmitMetadataTests.cs (80)

Emit\GeneratedNamesTests.cs (2)

29Assert.True(GeneratedNames.TryParseSynthesizedDelegateName(name, out var actualByRefs, out var actualReturnsVoid, out var actualGeneration, out var actualParameterCount)); 71Assert.True(CommonGeneratedNames.TryParseDebugIds(metadataName.AsSpan(), GeneratedNameConstants.IdSeparator, isMethodIdOptional, out var actualMethodId, out var actualEntityId));

Emit\InAttributeModifierTests.cs (4)

4512Assert.True(interfaceMethod.IsMetadataVirtual()); 4517Assert.True(proxyMethod.IsMetadataVirtual()); 4553Assert.True(interfaceMethod.IsMetadataVirtual()); 4558Assert.True(proxyMethod.IsMetadataVirtual());

Emit\NoPiaEmbedTypes.cs (28)

146Assert.True(result.Success); 1178Assert.True(itest1.IsComImport); 1202Assert.True(test2.IsSealed); 1220Assert.True(itest3.IsComImport); 1233Assert.True(test5.IsSerializable); 1234Assert.True(test5.IsSealed); 1262Assert.True(test9.IsSealed); 1284Assert.True(value__.HasSpecialName); 1285Assert.True(value__.HasRuntimeSpecialName); 1295Assert.True(f1.IsStatic); 1311Assert.True(((MethodSymbol)test9.GetMembers()[2]).IsDefaultValueTypeConstructor()); 1328Assert.True(f3.IsNotSerialized); 1335Assert.True(((MethodSymbol)test10.GetMembers()[2]).IsDefaultValueTypeConstructor()); 1482Assert.True(paramInfo[0].CustomModifiers.IsDefault); 1578Assert.True(p1.HasSpecialName); 1620Assert.True(e1.HasSpecialName); 1759Assert.True(t5.HasConstructorConstraint); 1767Assert.True(t6.HasValueTypeConstraint); 1775Assert.True(t7.HasReferenceTypeConstraint); 3323Assert.True(m1.Parameters[0].IsParams); 3324Assert.True(m1.Parameters[0].IsParamsArray); 4799Assert.True(isNoPiaLocalType); 4817Assert.True(isNoPiaLocalType); 6023Assert.True(((PEParameterSymbol)parameters[0]).Handle.IsNil); 6026Assert.True(p1.IsMetadataOptional); 6028Assert.True(((PEModuleSymbol)p1.ContainingModule).Module.MetadataReader.GetParameter(p1.Handle).Name.IsNil); 6033Assert.True(p2.Handle.IsNil); 6037Assert.True(((PEModuleSymbol)p2.ContainingModule).Module.MetadataReader.GetParameter(p2.Handle).Name.IsNil);

Emit\ResourceTests.cs (11)

420Assert.True(result.Success); 508Assert.True(result.Success); 518Assert.True(result2.Success); 558Assert.True(result.Success); 566Assert.True(result3.Success); 614Assert.True(result.Success); 628Assert.True(result4.Success); 667Assert.True(result5.Success); 713Assert.True(result6.Success); 732Assert.True(result6.Success); 753Assert.True(result6.Success);

CodeGen\CodeGenMethodGroupConversionCachingTests.cs (1)

2197Assert.True(m.IsValueType);

Emit\EditAndContinue\EditAndContinueClosureTests.cs (2)

519Assert.True(((Symbol)localFunction0).IsStatic); 522Assert.True(((Symbol)localFunction1).IsStatic);

Emit\EditAndContinue\EditAndContinueTests.cs (3)

360Assert.True(md0.MetadataReader.IsAssembly); 9181Assert.True(diff1.MetadataDelta.IsIncluded("Write")); 12992Assert.True(diff1.EmitResult.Success);

Emit\EditAndContinue\LocalSlotMappingTests.cs (1)

2006Assert.True(source.IndexOf(tooManyCommas, StringComparison.Ordinal) > 0);

Emit\EditAndContinue\SymbolMatcherTests.cs (1)

89Assert.True(members.Length > 10);

Emit\NumericIntPtrTests.cs (8)

2897Assert.True(value.IsIntegral); 2898Assert.True(value.IsNumeric); 6049Assert.True(opType is "System.IntPtr" or "System.UIntPtr" or "System.IntPtr?" or "System.UIntPtr?"); 6268Assert.True(opType is "System.IntPtr" or "System.UIntPtr" or "System.IntPtr?" or "System.UIntPtr?"); 6644Assert.True(opType is "System.IntPtr" or "System.UIntPtr" or "System.IntPtr?" or "System.UIntPtr?"); 10403Assert.True(type.IsDefinition); 11184Assert.True(nintSymbol.IsNativeIntegerType); 11600Assert.True(count == 65);

Emit\UnmanagedTypeModifierTests.cs (50)

PDB\CSharpPDBTestBase.cs (1)

33Assert.True(hasBreakpoint);

PDB\PDBAsyncTests.cs (1)

2041Assert.True(result.Success);

PDB\PDBIteratorTests.cs (1)

1635Assert.True(result.Success);

PDB\PDBTests.cs (3)

74Assert.True(result.Success); 115Assert.True(result.Success); 12886Assert.True(result.Success);

Attributes\AttributeTests.cs (50)

56Assert.True(predefined.IsPossibleMatch(typeForwardedTo, QuickAttributes.TypeForwardedTo)); 61Assert.True(predefined.IsPossibleMatch(typeIdentifier, QuickAttributes.TypeIdentifier)); 66Assert.True(checker1.IsPossibleMatch(alias1, QuickAttributes.TypeForwardedTo)); 70Assert.True(checker1a.IsPossibleMatch(alias1, QuickAttributes.TypeForwardedTo)); 71Assert.True(checker1a.IsPossibleMatch(alias1, QuickAttributes.TypeIdentifier)); 75Assert.True(checker1b.IsPossibleMatch(alias1, QuickAttributes.TypeForwardedTo)); 78Assert.True(checker1b.IsPossibleMatch(alias2, QuickAttributes.TypeIdentifier)); 82Assert.True(checker3.IsPossibleMatch(alias3, QuickAttributes.TypeForwardedTo)); 83Assert.True(checker3.IsPossibleMatch(alias3, QuickAttributes.TypeIdentifier)); 589Assert.True(attributeData.ConstructorArgumentsSourceIndices.IsDefault); 650Assert.True(attributeData.ConstructorArgumentsSourceIndices.IsDefault); 651Assert.True(attributeData.HasErrors); 754Assert.True(semanticModel.TryGetSpeculativeSemanticModel(attrSyntax.ArgumentList.Position, newAttrSyntax, out var speculativeModel)); 775Assert.True(result.OpenParenToken.IsMissing); 777Assert.True(result.CloseParenToken.IsMissing); 785Assert.True(result.OpenParenToken.IsMissing); 787Assert.True(result.CloseParenToken.IsMissing); 819Assert.True(semanticModel.TryGetSpeculativeSemanticModel(interpolationSyntax.Position, newAttrSyntax, out var speculativeModel)); 860Assert.True(semanticModel.TryGetSpeculativeSemanticModel(attrSyntax.ArgumentList.Position, newAttrSyntax, out var speculativeModel)); 901Assert.True(semanticModel.TryGetSpeculativeSemanticModel(attrSyntax.ArgumentList.Position, newAttrSyntax, out var speculativeModel)); 940Assert.True(semanticModel.TryGetSpeculativeSemanticModel(attrSyntax.Position, newAttrSyntax, out var speculativeModel)); 1910Assert.True(field1.HasSpecialName); 1972Assert.True(field1.IsNotSerialized); 1991Assert.True(field3.IsNotSerialized); 2347Assert.True(field2.ObsoleteAttributeData.IsError); 3454Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParams); 3455Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParamsArray); 3593Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParams); 3594Assert.True(attrs.First().AttributeConstructor.Parameters.Last().IsParamsArray); 5425Assert.True(typesym.HasSpecialName); 5429Assert.True(idxsym.HasSpecialName); 5433Assert.True(etsym.HasSpecialName); 5757Assert.True(args[0].IsNull); 5761Assert.True(args[1].IsNull); 5767Assert.True(named["P"].IsNull); 5771Assert.True(named["F"].IsNull); 8687Assert.True(method.TestIsExtensionBitSet); 8688Assert.True(method.TestIsExtensionBitTrue); 8689Assert.True(method.IsExtensionMethod); 8730Assert.True(method.TestIsExtensionBitSet); 8731Assert.True(method.TestIsExtensionBitTrue); 8732Assert.True(method.IsExtensionMethod); 8777Assert.True(method.TestIsExtensionBitSet); 8817Assert.True(yParam.IsParams); 8818Assert.True(yParam.IsParamsArray); 9916Assert.True(typeInAttribute.IsUnboundGenericType); 9917Assert.True(((NamedTypeSymbol)type.GetAttributes()[0].ConstructorArguments.First().ValueInternal).IsUnboundGenericType); 9926Assert.True(typeInAttribute.IsUnboundGenericType); 9927Assert.True(((NamedTypeSymbol)type.GetAttributes()[0].ConstructorArguments.First().ValueInternal).IsUnboundGenericType); 9999Assert.True(cc.TypeParameters.Single().GetAttributes().IsEmpty);

Attributes\AttributeTests_Assembly.cs (11)

307VerifyAssemblyTable(comp, r => { Assert.True(r.Culture.IsNil); }); 311VerifyAssemblyTable(comp, r => { Assert.True(r.Culture.IsNil); }); 324VerifyAssemblyTable(comp, r => { Assert.True(r.Culture.IsNil); }); 328VerifyAssemblyTable(comp, r => { Assert.True(r.Culture.IsNil); }); 478Assert.True(naturalRef.IsMissing); 941Assert.True(compilation.Emit(stream).Success); 1043Assert.True(uniqueAttributes.Add(attr)); 1118Assert.True(token.IsNil); //could the type ref be located? If not then the attribute's not there. 1139Assert.True(token.IsNil); //could the type ref be located? If not then the attribute's not there. 1233Assert.True(token.IsNil); //could the type ref be located? If not then the attribute's not there. 1254Assert.True(token.IsNil); //could the type ref be located? If not then the attribute's not there.

Attributes\AttributeTests_Conditional.cs (2)

627Assert.True(classGoo.IsConditional); 633Assert.True(paramY.IsOptional);

Attributes\AttributeTests_Dynamic.cs (6)

173Assert.True(_derivedClass.BaseType().ContainsDynamic()); 179Assert.True(_outerClass.BaseType().ContainsDynamic()); 185Assert.True(_innerClass.BaseType().ContainsDynamic()); 191Assert.True(_innerInnerClass.BaseType().ContainsDynamic()); 197Assert.True(_outer2Class.BaseType().ContainsDynamic()); 441Assert.True(_unsafeClass.BaseType().ContainsDynamic());

Attributes\AttributeTests_Embedded.cs (1)

430Assert.True(embeddedAttribute.HasCodeAnalysisEmbeddedAttribute);

Attributes\AttributeTests_IsByRefLike.cs (8)

45Assert.True(peModule.Module.HasIsByRefLikeAttribute(((PENamedTypeSymbol)type).Handle)); 102Assert.True(peModule.Module.HasIsByRefLikeAttribute(((PENamedTypeSymbol)type).Handle)); 670Assert.True(type.IsRefLikeType); 682Assert.True(peModule.Module.HasIsByRefLikeAttribute(peType.Handle)); 757Assert.True(type.IsRefLikeType); 808Assert.True(type.IsRefLikeType); 1040Assert.True(peType.IsRefLikeType); 1053Assert.True(obsoleteAttribute.IsError);

Attributes\AttributeTests_IsUnmanaged.cs (38)

Attributes\AttributeTests_NativeInteger.cs (1)

1469Assert.True(attributeUsage.HasValidAttributeTargets);

Attributes\AttributeTests_Nullable.cs (7)

182Assert.True(interfaceHandles.IsEmpty()); 1672Assert.True(typeParameter.HasReferenceTypeConstraint); 1743Assert.True(typeParameter.HasReferenceTypeConstraint); 1799Assert.True(typeParameter.HasNotNullConstraint); 4214Assert.True(underlyingType.ApplyNullableTransforms(0, actualBytes, ref position, out updated)); 4215Assert.True(updated.Equals(type, TypeCompareKind.ConsiderEverything)); 4977Assert.True(attributeUsage.HasValidAttributeTargets);

Attributes\AttributeTests_NullableContext.cs (1)

212Assert.True(attributeUsage.HasValidAttributeTargets);

Attributes\AttributeTests_NullablePublicOnly.cs (1)

508Assert.True(attributeUsage.HasValidAttributeTargets);

Attributes\AttributeTests_ReadOnlyStruct.cs (8)

40Assert.True(type.IsReadOnly); 44Assert.True(peModule.Module.HasIsReadOnlyAttribute(((PENamedTypeSymbol)type).Handle)); 59Assert.True(type.IsReadOnly); 77Assert.True(type.IsReadOnly); 95Assert.True(type.IsReadOnly); 113Assert.True(type.IsReadOnly); 139Assert.True(type.IsReadOnly); 435Assert.True(type.IsReadOnly);

Attributes\AttributeTests_RefReadOnly.cs (26)

Attributes\AttributeTests_Security.cs (2)

46Assert.True(type.HasDeclarativeSecurity); 1652Assert.True(emitResult.Success);

Attributes\AttributeTests_StructLayout.cs (4)

647Assert.True(badLayout); 651Assert.True(hasClassLayout); 659Assert.True(hasClassLayout); 702Assert.True(layout.IsDefault);

Attributes\AttributeTests_Tuples.cs (11)

345Assert.True(delegate1.IsDelegateType()); 414Assert.True(_outerClass.BaseType().ContainsTuple()); 489Assert.True(firstTuple.IsTupleType); 490Assert.True(firstTuple.TupleElementNames.IsDefault); 493Assert.True(secondTuple.IsTupleType); 494Assert.True(secondTuple.TupleElementNames.IsDefault); 500Assert.True(field7.Type.IsTupleType); 633Assert.True(tupleAttr.CommonConstructorArguments.IsEmpty); 647Assert.True(constant.Type.SpecialType == SpecialType.System_String); 941Assert.True(typeArg.IsTupleType); 1041Assert.True(typeArg.IsTupleType);

Attributes\AttributeTests_WellKnownAttributes.cs (23)

524Assert.True(attributeInfo.HasValue); 527Assert.True(peModule.Module.TryExtractLongValueFromAttribute(attributeInfo.Handle, out attributeValue)); 932Assert.True(ps[0].IsOptional); 1021Assert.True(ps[0].IsOptional); 1065Assert.True(ps[0].IsOptional); 2730Assert.True(info.ExactSpelling); 2731Assert.True(info.SetLastError); 3675Assert.True(typeA.IsComImport); 3680Assert.True(((Cci.IMethodDefinition)ctorA.GetCciAdapter()).IsExternal); 3683Assert.True(methodGoo.IsExternal); 3689Assert.True(typeA.IsComImport); 4902Assert.True(typeC.IsSerializable); 4978Assert.True(((NamedTypeSymbol)substitutedNestedS).IsSerializable); 4981Assert.True(valueTupleS.IsTupleType); 4982Assert.True(((NamedTypeSymbol)valueTupleS).IsSerializable); 4990Assert.True(((NamedTypeSymbol)constructedS).IsSerializable); 5169Assert.True(attributeUsage.AllowMultiple); 5170Assert.True(attributeUsage.Inherited); 5754Assert.True(method.RequiresSecurityObject); 5770Assert.True(localFunctionSymbol.RequiresSecurityObject); 9743Assert.True(param.IsParams); 9744Assert.True(param.IsParamsArray); 13544Assert.True(attribute.AttributeClass.IsStructType());

Attributes\InternalsVisibleToAndStrongNameTests.cs (68)

Diagnostics\CompilationEventTests.cs (2)

33Assert.True(te.IsCompleted); 72Assert.True(false);

Diagnostics\DiagnosticAnalyzerTests.cs (11)

327Assert.True(effectiveDiag.Severity == DiagnosticSeverity.Error); 356Assert.True(diagIds.Remove(effectiveDiag.Id)); 527Assert.True(fullyDisabledAnalyzer.IsDiagnosticAnalyzerSuppressed(options)); 536Assert.True(partiallyDisabledAnalyzer.IsDiagnosticAnalyzerSuppressed(options)); 542Assert.True(fullyDisabledAnalyzer.IsDiagnosticAnalyzerSuppressed(options)); 3573Assert.True(first.Concurrent); 3575Assert.True(first.Append(second).Concurrent); 3577Assert.True(first.Concurrent); 3579Assert.True(second.Append(first).Concurrent); 3717Assert.True(diagnostics.ContainsKey(analyzer)); 4406Assert.True(analyzer.AnalyzerInvoked);

Diagnostics\GetDiagnosticsTests.cs (37)

FieldKeywordTests.cs (190)

FirstClassSpanTests.cs (2)

2833Assert.True(argConv.IsSpan); 2834Assert.True(argConv.IsImplicit);

FlowAnalysis\IterationJumpYieldStatementTests.cs (16)

FlowAnalysis\RegionAnalysisTests.cs (96)

FlowAnalysis\TryLockUsingStatementTests.cs (21)

PartialEventsAndConstructorsTests.cs (41)

RefReadonlyParameterTests.cs (5)

95Assert.True(method.HasUnsupportedMetadata); 96Assert.True(method.HasUseSiteError); 1075Assert.True(m.IsOptional); 1445Assert.True(mod.IsOptional); 6696Assert.True(m1 is not RetargetingMethodSymbol);

RefStructInterfacesTests.cs (188)

Semantics\CollectionExpressionTests.cs (66)

Semantics\ExperimentalAttributeTests.cs (2)

911Assert.True(missingType.ContainingAssembly is MissingAssemblySymbol); 913Assert.True(missingType.ContainingModule is MissingModuleSymbol);

Semantics\ExtensionOperatorsTests.cs (9)

451Assert.True(method.IsStatic); 490Assert.True(method.IsStatic); 531Assert.True(method.IsStatic); 4583Assert.True(method.IsStatic); 4619Assert.True(method.IsStatic); 4630Assert.True(method.IsStatic); 11276Assert.True(method.IsStatic); 11348Assert.True(method.IsStatic); 20176Assert.True(method.IsStatic);

Semantics\ExtensionTests.cs (70)

Semantics\ExtensionTests2.cs (26)

818Assert.True(module.Module.HasParamCollectionAttribute(parameterSymbol.Handle)); 928Assert.True(module.Module.HasIsReadOnlyAttribute(parameterSymbol.Handle)); 4137Assert.True(extension.IsExtension); 4254Assert.True(extension.IsExtension); 4311Assert.True(extension.IsExtension); 4384Assert.True(extension.IsExtension); 4447Assert.True(extension.IsExtension); 4529Assert.True(extension.IsExtension); 4625Assert.True(extension.IsExtension); 4739Assert.True(extension.IsExtension); 4838Assert.True(extension.IsExtension); 21152Assert.True(comp.Assembly.RuntimeSupportsNumericIntPtr); 26301Assert.True(ExtensionGroupingInfo.HaveSameILSignature((SourceNamedTypeSymbol)extensions[0], (SourceNamedTypeSymbol)extensions[1])); 26842() => Assert.True(extension1.ComputeExtensionGroupingRawName() == extension2.ComputeExtensionGroupingRawName()), 26843() => Assert.True(extension1.ComputeExtensionMarkerRawName() == extension2.ComputeExtensionMarkerRawName()), 26878() => Assert.True(extension1.ComputeExtensionGroupingRawName() == extension2.ComputeExtensionGroupingRawName()), 26879() => Assert.True(extension1.ComputeExtensionMarkerRawName() == extension2.ComputeExtensionMarkerRawName()), 26967() => Assert.True(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)), 27004() => Assert.True(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)), 27005() => Assert.True(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)) 27037() => Assert.True(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)), 27038() => Assert.True(ExtensionGroupingInfo.HaveSameCSharpSignature(extension1, extension2)) 27104() => Assert.True(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)), 27151() => Assert.True(ExtensionGroupingInfo.HaveSameILSignature(extension1, extension2)), 27275Assert.True(extension1.ComputeExtensionGroupingRawName() == extension2.ComputeExtensionGroupingRawName()); 27276Assert.True(extension1.ComputeExtensionMarkerRawName() == extension2.ComputeExtensionMarkerRawName());

Semantics\InlineArrayTests.cs (56)

Semantics\OutVarTests.cs (74)

Semantics\ParamsCollectionTests.cs (25)

178Assert.True(model.GetConversion(argument).IsNumeric); 234Assert.True(model.GetConversion(expression).IsIdentity); 240Assert.True(attributeData1.HasErrors); 350Assert.True(model.GetConversion(expression).IsIdentity); 356Assert.True(attributeData1.HasErrors); 533Assert.True(model.GetConversion(expression).IsIdentity); 539Assert.True(attributeData1.HasErrors); 678Assert.True(model.GetConversion(expression).IsIdentity); 684Assert.True(attributeData1.HasErrors); 1422Assert.True(model.GetConversion(expression).IsIdentity); 1428Assert.True(attributeData1.HasErrors); 2546Assert.True(model.GetConversion(expression).IsIdentity); 2552Assert.True(attributeData1.HasErrors); 2682Assert.True(model.GetConversion(expression).IsIdentity); 2688Assert.True(attributeData1.HasErrors); 4210Assert.True(m.GlobalNamespace.GetTypeMember("<>f__AnonymousDelegate0").DelegateInvokeMethod.Parameters.Last().IsParams); 9041Assert.True(module.FindTargetAttribute(p1.Handle, AttributeDescription.ScopedRefAttribute).HasValue); 9318Assert.True(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 9322Assert.True(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams); 10174Assert.True(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 10178Assert.True(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams); 10216Assert.True(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 10220Assert.True(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams); 10258Assert.True(comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().IsParams); 10262Assert.True(comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().IsParams);

Semantics\PatternMatchingTestBase.cs (20)

Semantics\PatternMatchingTests.cs (3)

3269Assert.True(symbolInfo.CandidateSymbols.IsDefaultOrEmpty); 3482Assert.True(((ITypeSymbol)compilation.GetSemanticModel(tree).GetTypeInfo(x1Ref).Type).IsErrorType()); 3488Assert.True(((ITypeSymbol)compilation.GetSemanticModel(tree).GetTypeInfo(x2Ref).Type).IsErrorType());

Semantics\PatternMatchingTests_Global.cs (2)

6323Assert.True(x1Decl.Parent is VarPatternSyntax); 6352Assert.True(x1Decl.Parent is VarPatternSyntax);

Semantics\PatternMatchingTests_ListPatterns.cs (1)

3453Assert.True(used.Any(r => r.Display == "range"));

Semantics\PatternMatchingTests_Scope.cs (16)

Semantics\PatternMatchingTests2.cs (2)

2025Assert.True(gotModel); 2066Assert.True(gotModel);

Semantics\PatternSwitchTests.cs (6)

40Assert.True(compilation.GetDiagnostics().HasAnyErrors()); 69Assert.True(compilation.GetDiagnostics().HasAnyErrors()); 126Assert.True(compilation.GetDiagnostics().HasAnyErrors()); 162Assert.True(compilation.GetDiagnostics().HasAnyErrors()); 190Assert.True(compilation.GetDiagnostics().HasAnyErrors()); 246Assert.True(compilation.GetDiagnostics().HasAnyErrors());

Semantics\PrimaryConstructorTests.cs (103)

Semantics\RecordTests.cs (157)

Symbols\UserDefinedCompoundAssignmentOperatorsTests.cs (150)

EndToEndTests.cs (2)

583Assert.True(typeParameter.IsReferenceType); 834step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C1" }));

EditAndContinue\BreakpointSpansTests.cs (3)

46Assert.True(hasBreakpoint); 47Assert.True(breakpointSpan.Length == 0); 55Assert.True(hasBreakpoint);

EditAndContinue\CSharpEditAndContinueAnalyzerTests.cs (11)

324Assert.True(result.HasChanges); 327Assert.True(syntaxMaps.HasMap); 368Assert.True(result.HasChanges); 369Assert.True(result.AnalysisBlocked); 469Assert.True(result.RudeEdits.IsEmpty); 514Assert.True(result.HasChanges); 515Assert.True(result.AnalysisBlocked); 584Assert.True(result.HasChanges); 624Assert.True(result.HasChanges); 678Assert.True(result.IsSingle()); 724Assert.True(result.IsSingle());

EditAndContinue\SyntaxUtilitiesTests.cs (8)

ExtractClass\ExtractClassTests.cs (1)

2968Assert.True(_isClassDeclarationSelection);

src\Analyzers\CSharp\Tests\UpdateProjectToAllowUnsafe\UpdateProjectToAllowUnsafeTests.cs (1)

39Assert.True(((CSharpCompilationOptions)newSolution.Projects.Single().CompilationOptions!).AllowUnsafe);

IOperation\IOperationTests.cs (1)

622Assert.True(success);

IOperation\IOperationTests_IAnonymousFunctionExpression.cs (1)

493Assert.True(lambdaOperation.Symbol.IsStatic);

IOperation\IOperationTests_IArgument.cs (1)

4101Assert.True(conversion.Conversion.IsNullable);

IOperation\IOperationTests_IConversionExpression.cs (1)

178Assert.True(initializerSyntax.IsMissing);

IOperation\IOperationTests_IFieldReferenceExpression.cs (1)

714Assert.True(fieldSym.Equals(fieldReferenceOperation.Field));

CsiTests.cs (3)

98Assert.True(result.Errors.StartsWith("error CS0006", StringComparison.Ordinal)); 99Assert.True(result.ContainsErrors); 154Assert.True(result.ContainsErrors);

InteractiveSessionReferencesTests.cs (5)

768Assert.True(exceptionSeen); 836Assert.True(exceptionSeen); 904Assert.True(exceptionSeen); 972Assert.True(exceptionSeen); 1040Assert.True(exceptionSeen);

CommandLineRunnerTests.cs (2)

777Assert.True(Array.IndexOf(acceptableSurroundingChar, actual[foundIndex - 1]) >= 0); 778Assert.True(Array.IndexOf(acceptableSurroundingChar, actual[foundIndex + version.Length]) >= 0);

InteractiveSessionTests.cs (14)

281Assert.True(dllImport.BestFitMapping); 284Assert.True(dllImport.ExactSpelling); 285Assert.True(dllImport.SetLastError); 286Assert.True(dllImport.PreserveSig); 287Assert.True(dllImport.ThrowOnUnmappableChar); 492Assert.True(compilation2.IsSymbolAccessibleWithin(c2C1, c2C2)); 493Assert.True(compilation2.IsSymbolAccessibleWithin(c2C2, c2C1)); 494Assert.True(compilation2.IsSymbolAccessibleWithin(c2X, c2C2)); // access not enforced among submission symbols 503Assert.True(compilation3.IsSymbolAccessibleWithin(c3C3, c3C1)); 652Assert.True(state1.ReturnValue); 670Assert.True(state1.ReturnValue); 1192Assert.True(import.NamespaceOrType is INamespaceSymbol { Name: "System", ContainingNamespace.IsGlobalNamespace: true }); 1845Assert.True(result); 1909Assert.True(result);

ScriptTests.cs (7)

231Assert.True(exceptionThrown); 280Assert.True(exceptionThrown); 441Assert.True(state.GetVariable("y").IsReadOnly); 442Assert.True(state.GetVariable("z").IsReadOnly); 1015Assert.True(exceptionThrown); 1040Assert.True(exceptionThrown); 1063Assert.True(exceptionThrown);

Semantics\AccessCheckTests.cs (54)

Semantics\AccessibilityTests.cs (2)

59Assert.True( 71Assert.True(

Semantics\AmbiguousOverrideTests.cs (6)

779Assert.True(baseProperty1.IsIndexer); 780Assert.True(baseProperty2.IsIndexer); 785Assert.True(derivedProperty.IsIndexer); 853Assert.True(baseProperty1.IsIndexer); 854Assert.True(baseProperty2.IsIndexer); 859Assert.True(derivedProperty.IsIndexer);

Semantics\AnonymousFunctionTests.cs (4)

685Assert.True(method.IsStatic); 991Assert.True(anonymousMethod.IsStatic); 992Assert.True(simpleLambda.IsStatic); 993Assert.True(parenthesizedLambda.IsStatic);

Semantics\AwaitExpressionTests.cs (1)

469Assert.True(info.IsDynamic);

Semantics\BindingAsyncTasklikeMoreTests.cs (16)

Semantics\BindingAsyncTasklikeTests.cs (6)

37Assert.True(methodf.IsAsync); 38Assert.True(methodg.IsAsync); 189Assert.True(diagnostics.Length == 1); 190Assert.True(diagnostics.First().Code == (int)ErrorCode.ERR_AmbigCall); 312Assert.True(methodf.IsAsync); 313Assert.True(methodg.IsAsync);

Semantics\BindingAsyncTests.cs (4)

35Assert.True(method.IsAsync); 59Assert.True(((IMethodSymbol)model.GetSymbolInfo(simple).Symbol).IsAsync); 65Assert.True(((IMethodSymbol)model.GetSymbolInfo(paren).Symbol).IsAsync); 88Assert.True(((IMethodSymbol)model.GetSymbolInfo(del).Symbol).IsAsync);

Semantics\BindingTests.cs (9)

3385Assert.True(names.Contains("MathMax")); 3386Assert.True(names.Contains("F1")); 3391Assert.True(model.LookupSymbols(node1.SpanStart, name: "MathMin").IsEmpty); 3394Assert.True(model.LookupSymbols(node1.SpanStart, name: "F2").IsEmpty); 3395Assert.True(model.LookupSymbols(node1.SpanStart, name: "MathMax2").IsEmpty); 3396Assert.True(model.LookupSymbols(node1.SpanStart, name: "MathMax3").IsEmpty); 3400Assert.True(symbols.Where(s => s.Name == "MathMax").Any()); 3401Assert.True(symbols.Where(s => s.Name == "F1").Any()); 3746Assert.True(symbolInfo1.CandidateSymbols.IsEmpty);

Semantics\ColorColorTests.cs (1)

1763Assert.True(analyzer.ActionFired);

Semantics\ConstantTests.cs (1)

2926Assert.True(constantValue.HasValue);

Semantics\DeconstructionTests.cs (79)

Semantics\DelegateTypeTests.cs (24)

Semantics\DynamicTests.cs (11)

Semantics\ExpressionBodiedMemberTests.cs (6)

48Assert.True(gooDef.IsPartial); 49Assert.True(gooDef.IsPartialDefinition); 56Assert.True(gooImpl.IsPartial); 57Assert.True(gooImpl.IsPartialImplementation); 59Assert.True(gooImpl.IsExpressionBodied); 106Assert.True(semanticInfo.IsCompileTimeConstant);

Semantics\ForEachTests.cs (15)

Semantics\FunctionPointerTests.cs (13)

Semantics\GenericConstraintsTests.cs (43)

Semantics\ImplicitObjectCreationTests.cs (7)

1873Assert.True(model.GetConversion(def).IsObjectCreation); 1903Assert.True(model.GetConversion(def).IsObjectCreation); 1933Assert.True(model.GetConversion(def).IsObjectCreation); 1934Assert.True(model.GetConversion(def).IsImplicit); 2225Assert.True(model.GetConversion(def).IsObjectCreation); 4164Assert.True(symbolInfo.IsEmpty); 4191Assert.True(success);

Semantics\InheritanceBindingTests.cs (21)

Semantics\InitOnlyMemberTests.cs (71)

Semantics\InterceptorsTests.cs (7)

6788Assert.True(interceptor!.IsDefinition); 6834Assert.True(interceptor.GetSymbol()!.HasComplete(CompletionPart.Attributes)); 6842Assert.True(EM.HasComplete(CompletionPart.Attributes)); 6934Assert.True(interceptor.GetSymbol()!.HasComplete(CompletionPart.Attributes)); 6939Assert.True(EM.HasComplete(CompletionPart.Attributes)); 6943Assert.True(EM.HasComplete(CompletionPart.Attributes)); 7222Assert.True(comp.InterceptorsDiscoveryComplete);

Semantics\InterpolationTests.cs (51)

Semantics\IteratorTests.cs (9)

41Assert.True(i.IsIterator); 42Assert.True(publicI.IsIterator); 47Assert.True(i.IsIterator); 48Assert.True(publicI.IsIterator); 90Assert.True(i.IsIterator); 91Assert.True(i.GetPublicSymbol().IsIterator); 379Assert.True(emitResult.Success); 718Assert.True(model.GetConversion(node).IsIdentity); 756Assert.True(model.GetConversion(node).IsIdentity);

Semantics\LambdaDiscardParametersTests.cs (1)

116Assert.True(symbol1.IsDiscard);

Semantics\LambdaTests.cs (35)

Semantics\LocalFunctionTests.cs (31)

Semantics\LookupPositionTests.cs (1)

2274Assert.True(symbols.IsEmpty);

Semantics\LookupTests.cs (5)

450Assert.True(lookupResult.IsMultiViable || lookupResult.Kind == LookupResultKind.NotReferencable); 589Assert.True(lookupResult.IsMultiViable); 1843Assert.True(symbols.Any(s => s.Kind == SymbolKind.TypeParameter)); 1955Assert.True(symbols.Any(s => s.Kind == SymbolKind.TypeParameter)); 1986Assert.True(symbols.Any(s => s.Kind == SymbolKind.TypeParameter));

Semantics\MultiDimensionalArrayTests.cs (18)

Semantics\NamedAndOptionalTests.cs (41)

Semantics\NameOfTests.cs (10)

1001Assert.True(model.TryGetSpeculativeSemanticModel(initializer.Position, initializer, out var model2)); 1007Assert.True(model.GetSpeculativeSymbolInfo(argument2.Position, argument2, SpeculativeBindingOption.BindAsTypeOrNamespace).IsEmpty); 1072Assert.True(model.TryGetSpeculativeSemanticModel(initializer.Position, initializer, out var model2)); 1078Assert.True(model.GetSpeculativeSymbolInfo(argument2.Position, argument2, SpeculativeBindingOption.BindAsTypeOrNamespace).IsEmpty); 1158Assert.True(model.TryGetSpeculativeSemanticModel(initializer.Position, initializer, out var model2)); 1164Assert.True(model.GetSpeculativeSymbolInfo(argument2.Position, argument2, SpeculativeBindingOption.BindAsTypeOrNamespace).IsEmpty); 1236Assert.True(model.TryGetSpeculativeSemanticModel(initializer.Position, initializer, out var model2)); 1242Assert.True(model.GetSpeculativeSymbolInfo(argument2.Position, argument2, SpeculativeBindingOption.BindAsTypeOrNamespace).IsEmpty); 3060Assert.True(nameofType.IsDefinition); 3064Assert.True(typeofType.IsUnboundGenericType());

Semantics\NativeIntegerTests.cs (38)

276Assert.True(underlyingType.Equals(nativeIntegerType, TypeCompareKind.IgnoreNativeIntegers)); 291Assert.True(underlyingInterface.Equals(nativeIntegerInterface, TypeCompareKind.IgnoreNativeIntegers)); 384Assert.True(underlyingType.Equals(nativeIntegerType, TypeCompareKind.IgnoreNativeIntegers)); 385Assert.True(nativeIntegerType.Equals(underlyingType, TypeCompareKind.IgnoreNativeIntegers)); 400Assert.True(underlyingInterface.Equals(nativeIntegerInterface, TypeCompareKind.IgnoreNativeIntegers)); 557Assert.True(member.Equals(underlyingMember, TypeCompareKind.IgnoreNativeIntegers)); 598Assert.True(fromMember.Equals(fromUnderlyingMember, TypeCompareKind.IgnoreNativeIntegers)); 819Assert.True(type.IsNativeIntegerWrapperType); 932Assert.True(type.IsNativeIntegerWrapperType); 1039Assert.True(type.IsNativeIntegerWrapperType); 1111Assert.True(type.IsNativeIntegerWrapperType); 1159Assert.True(type1.IsNativeIntegerWrapperType); 1179Assert.True(type2.ContainingAssembly.IsMissing); 1181Assert.True(type2.IsErrorType()); 1234Assert.True(typeA.IsNativeIntegerWrapperType); 1251Assert.True(typeB.ContainingAssembly.IsMissing); 1253Assert.True(typeB.IsErrorType()); 1552Assert.True(type.IsNativeIntegerWrapperType); 1808Assert.True(type.IsNativeIntegerWrapperType); 1973Assert.True(type.IsNativeIntegerWrapperType); 2143Assert.True(type.IsNativeIntegerWrapperType); 2239Assert.True(type.IsNativeIntegerWrapperType); 2366Assert.True(type.IsNativeIntegerWrapperType); 2486Assert.True(type.IsNativeIntegerWrapperType); 2495Assert.True(member.GetExplicitInterfaceImplementations().IsEmpty); 2642Assert.True(type.IsNativeIntegerWrapperType); 2744Assert.True(type.IsNativeIntegerWrapperType); 2884Assert.True(type.IsNativeIntegerWrapperType); 3651Assert.True(underlyingType1.IsNativeIntegerWrapperType); 3727Assert.True(underlyingType1.IsNativeIntegerWrapperType); 3761Assert.True(underlyingType1.IsNativeIntegerWrapperType); 4083Assert.True(type.IsNativeIntegerType); 7060Assert.True(value.IsIntegral); 7061Assert.True(value.IsNumeric); 14744Assert.True(TypeUnification.CanUnify(type1, type3)); 14745Assert.True(TypeUnification.CanUnify(type4, type5)); 15327Assert.True(nintSymbol.IsNativeIntegerType); 15749Assert.True(count == 65);

Semantics\NullableContextTests.cs (9)

112Assert.True(NullableContextOptions.Enable.AnnotationsEnabled()); 113Assert.True(NullableContextOptions.Enable.WarningsEnabled()); 115Assert.True(NullableContextOptions.Annotations.AnnotationsEnabled()); 119Assert.True(NullableContextOptions.Warnings.WarningsEnabled()); 143Assert.True(warningsInherited.WarningsInherited()); 150Assert.True(annotationsInherited.AnnotationsInherited()); 155Assert.True(contextInherited.WarningsInherited()); 156Assert.True(contextInherited.AnnotationsInherited()); 2230Assert.True(model.TryGetSpeculativeSemanticModel(typeOf.Type.SpanStart, type, out model, SpeculativeBindingOption.BindAsTypeOrNamespace));

Semantics\NullableConversionTests.cs (1)

817Assert.True(conversion.IsExplicit && conversion.IsNullable);

Semantics\NullableReferenceTypesTests.cs (223)

Semantics\OperatorTests.cs (24)

Semantics\QueryTests.cs (5)

2360Assert.True(symbols.All(s => ReferenceEquals(s, null))); 3425Assert.True(success); 3469Assert.True(success); 3555Assert.True(success); 3603Assert.True(success);

Semantics\RawInterpolationTests.cs (8)

Semantics\RawInterpolationTests_Handler.cs (34)

Semantics\ReadOnlyStructsTests.cs (22)

389Assert.True(method.IsDeclaredReadOnly); 390Assert.True(method.IsEffectivelyReadOnly); 452Assert.True(method.IsDeclaredReadOnly); 453Assert.True(method.IsEffectivelyReadOnly); 1154Assert.True(method.IsDeclaredReadOnly); 1155Assert.True(method.IsEffectivelyReadOnly); 1194Assert.True(getMethod(s1, "M2").IsReadOnly); 1196Assert.True(getProperty(s1, "P1").GetMethod.IsReadOnly); 1199Assert.True(getProperty(s1, "P2").GetMethod.IsReadOnly); 1201Assert.True(getProperty(s1, "P3").GetMethod.IsReadOnly); 1203Assert.True(getProperty(s1, "P4").SetMethod.IsReadOnly); 1208Assert.True(getEvent(s1, "E").AddMethod.IsReadOnly); 1209Assert.True(getEvent(s1, "E").RemoveMethod.IsReadOnly); 1212Assert.True(getMethod(s2, "M1").IsReadOnly); 1215Assert.True(getProperty(s2, "P1").GetMethod.IsReadOnly); 1217Assert.True(getProperty(s2, "P2").GetMethod.IsReadOnly); 1219Assert.True(getProperty(s2, "P3").SetMethod.IsReadOnly); 1224Assert.True(getEvent(s2, "E").AddMethod.IsReadOnly); 1225Assert.True(getEvent(s2, "E").RemoveMethod.IsReadOnly); 1324Assert.True(property.IsReadOnly); 1459Assert.True(method.IsDeclaredReadOnly); 1619Assert.True(dllGetter.IsDeclaredReadOnly);

Semantics\RecordStructTests.cs (72)

Semantics\RefEscapingTests.cs (3)

48Assert.True(comp.GetDiagnostics().All(d => d.Severity != DiagnosticSeverity.Error)); 52Assert.True(getLocalType("span").IsRefLikeType); 54Assert.True(getLocalType("s2").IsRefLikeType);

Semantics\RefExtensionMethodsTests.cs (4)

2144Assert.True(parameter.IsNode); 2163Assert.True(parameter.IsNode); 2182Assert.True(parameter.IsNode); 2201Assert.True(parameter.IsNode);

Semantics\RefFieldTests.cs (48)

Semantics\ScriptSemanticsTests.cs (2)

428Assert.True(methods.All(m => m is MethodSymbol)); 594Assert.True(symbols.Length > 0);

Semantics\SemanticErrorTests.cs (9)

Semantics\SimpleLambdaParametersWithModifiersTests.cs (31)

Semantics\StructConstructorTests.cs (10)

3553Assert.True(g1.Parameters[0].HasExplicitDefaultValue); 3555Assert.True(g1.Parameters[0].ExplicitDefaultConstantValue.IsNull); 3558Assert.True(g2.Parameters[0].HasExplicitDefaultValue); 3560Assert.True(g2.Parameters[0].ExplicitDefaultConstantValue.IsNull); 3580Assert.True(g1.Parameters[0].HasExplicitDefaultValue); 3585Assert.True(g2.Parameters[0].HasExplicitDefaultValue); 4888Assert.True(members.SequenceEqual(constructors)); 4889Assert.True(constructors.All(c => c is { IsStatic: false, IsImplicitConstructor: false })); 4897Assert.True(members.SequenceEqual(constructors)); 4898Assert.True(constructors.All(c => c is { IsStatic: false, IsImplicitlyDeclared: false }));

Semantics\StructsTests.cs (1)

397Assert.True(method.IsDefaultValueTypeConstructor());

Semantics\SuppressAccessibilityChecksTests.cs (1)

224Assert.True(success);

Semantics\SyntaxTreeRootTests.cs (2)

38Assert.True(tree.HasCompilationUnitRoot); 47Assert.True(tree.TryGetRoot(out root));

Semantics\SynthesizedStaticConstructorTests.cs (12)

Semantics\TargetTypedDefaultTests.cs (20)

Semantics\TopLevelStatementsTests.cs (44)

Semantics\UnsafeTests.cs (67)

Semantics\UseSiteErrorTests.cs (2)

2443Assert.True(diagnostics.Any(d => d.Code == (int)ErrorCode.ERR_NoTypeDef)); 2762Assert.True(s3.IsManagedType(ref managedKindUseSiteInfo));

Semantics\Utf8StringsLiteralsTests.cs (10)

Semantics\ValueTupleTests.cs (8)

SourceGeneration\AdditionalSourcesCollectionTests.cs (5)

55Assert.True(asc.Contains(expectedName)); 59Assert.True(source.HintName.EndsWith(".cs")); 71Assert.True(asc.Contains(hintName)); 75Assert.True(sources[0].HintName.EndsWith(".vb")); 201Assert.True(asc.Contains(checkHintName));

SourceGeneration\GeneratorDriverTests.cs (27)

141Assert.True(generatedClass.Locations.Single().IsInSource); 199Assert.True(false); 567Assert.True(result.Diagnostics.IsDefault); 568Assert.True(result.GeneratedSources.IsDefault); 868Assert.True(passedIn!.GlobalOptions.TryGetValue("a", out var item1)); 871Assert.True(passedIn!.GlobalOptions.TryGetValue("b", out var item2)); 1147Assert.True(tree.TryGetRoot(out var rootFromTryGetRoot)); 2606Assert.True(generatorCancelled); 2703Assert.True(driver.GetRunResult().Diagnostics.IsEmpty); 2713Assert.True(driver.GetRunResult().Diagnostics.IsEmpty); 2720Assert.True(compilation.SyntaxTrees.Contains(node.SyntaxTree)); 3409Assert.True(capacity >= builder.Capacity); 3566Assert.True(timing.ElapsedTime >= generatorTiming.ElapsedTime); 3607Assert.True(timing.ElapsedTime >= timing1.ElapsedTime); 3612Assert.True(timing.ElapsedTime >= timing2.ElapsedTime); 3614Assert.True(timing.ElapsedTime >= timing1.ElapsedTime + timing2.ElapsedTime); 3646Assert.True(timing.ElapsedTime >= generatorTiming.ElapsedTime); 3653Assert.True(timing.ElapsedTime > timing2.ElapsedTime); 3658Assert.True(generatorTiming.ElapsedTime > generatorTiming2.ElapsedTime); 4090Assert.True(wasCalled); 4128Assert.True(wasCalled); 4157Assert.True(gen1Called); 4176Assert.True(gen2Called); 4432Assert.True(executeCalled); 4529Assert.True(result.Results[1].GeneratedSources.IsDefault); 4547Assert.True(stepRan); 4583Assert.True(initWasCalled);

SourceGeneration\GeneratorDriverTests_Attributes_FullyQualifiedName.cs (67)

SourceGeneration\GeneratorDriverTests_Attributes_SimpleName.cs (43)

SourceGeneration\StateTableTests.cs (13)

SourceGeneration\SyntaxAwareGeneratorTests.cs (9)

378onExecute: (e) => { Assert.True(false); } 559onExecute: (e) => { Assert.True(false); } 631onExecute: (e) => { Assert.True(false); } 2026Assert.True(generatorCancelled); 2108Assert.True(timing.ElapsedTime >= timing1.ElapsedTime); 2109Assert.True(timing1.ElapsedTime.TotalMilliseconds >= sleepTimeInMs); 2115Assert.True(timing.ElapsedTime >= timing2.ElapsedTime); 2116Assert.True(timing2.ElapsedTime.TotalMilliseconds >= sleepTimeInMs * 2); 2119Assert.True(timing2.ElapsedTime > timing1.ElapsedTime);

Utilities\ValueSetTests.cs (74)

Compilation\CompilationAPITests.cs (58)

Compilation\CSharpCompilationOptionsTests.cs (3)

62Assert.True(newOpt1.Equals(newOpt2)); 204Assert.True(actual1.SequenceEqual(new[] { "A", "B" })); 207Assert.True(actual2.SequenceEqual(Enumerable.Repeat("A", 1)));

Compilation\GetImportScopesTests.cs (78)

Compilation\GetSemanticInfoBrokenCodeTests.cs (1)

181Assert.True(type.IsImplicitlyDeclared);

Compilation\GetSemanticInfoTests.cs (111)

Compilation\ReferenceManagerTests.cs (8)

906Assert.True(dr1.Properties.Aliases.IsEmpty); 907Assert.True(dr2.Properties.Aliases.IsEmpty); 908Assert.True(dr3.Properties.Aliases.IsEmpty); 1291Assert.True(resolver.resolved1); 1292Assert.True(resolver.resolved2); 1452Assert.True(withCircularReference1.ReferenceManagerEquals(withCircularReference2)); 1455Assert.True(withCircularReference1.ReferenceManagerEquals(withCircularReference2)); 2159Assert.True(corlib1.ReferenceManagerEquals(corlib2));

Compilation\SemanticModelAPITests.cs (81)

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (38)

Compilation\SemanticModelGetSemanticInfoTests.cs (79)

Compilation\SemanticModelGetSemanticInfoTests_LateBound.cs (31)

Compilation\UsedAssembliesTests.cs (3)

282Assert.True(diagnostics.Any(d => d.DefaultSeverity == DiagnosticSeverity.Error)); 639Assert.True(comp2.References.Count() > 1); 2328Assert.True(comp.References.Count() > 1);

DeclarationTests.cs (36)

DocumentationComments\CrefTests.cs (4)

3254Assert.True(((IPropertySymbol)info.CandidateSymbols[0]).IsIndexer); 6189Assert.True(parameterTypeSymbol.IsDefinition); 6290Assert.True(success); 6865Assert.True(model.GetSymbolInfo(cref).IsEmpty);

DocumentationComments\DocumentationCommentCompilerTests.cs (2)

4405Assert.True(char.IsWhiteSpace(ch)); 4406Assert.True(SyntaxFacts.IsWhitespace(ch));

SymbolDisplay\SymbolDisplayTests.cs (11)

4995Assert.True(eventSymbol.IsWindowsRuntimeEvent); 5434Assert.True(new FormattedSymbol(sA, f1).Equals(new FormattedSymbol(sA, f1))); 5440Assert.True(new FormattedSymbol(sC.Construct(sA), f1).Equals(new FormattedSymbol(sC.Construct(sA), f1))); 5444Assert.True(new FormattedSymbol(sA, f1).GetHashCode().Equals(new FormattedSymbol(sA, f1).GetHashCode())); 5501Assert.True(((ITypeSymbol)firstPart.Symbol).IsTupleType); 6188Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(position, methodDecl, out model)); 6439Assert.True(formatWithAllowDefaultLiteral.MiscellaneousOptions.IncludesOption(SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral)); 6566Assert.True(formatWithAllowDefaultLiteral.MiscellaneousOptions.IncludesOption(SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral)); 6610Assert.True(formatWithAllowDefaultLiteral.MiscellaneousOptions.IncludesOption(SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral)); 7015Assert.True(local.IsRef); 7062Assert.True(local.IsRef);

Symbols\AccessorOverriddenOrHiddenMembersTests.cs (1)

1037Assert.True(methodDispose.ReturnsVoid);

Symbols\AnonymousTypesSemanticsTests.cs (4)

722Assert.True(type.IsDefinition); 741Assert.True(type.IsDefinition); 1988Assert.True(type.IsAnonymousType); 2119Assert.True(added);

Symbols\AnonymousTypesSymbolTests.cs (7)

1022Assert.True(fieldsCount == 0 ? !type.IsGenericType : type.IsGenericType); 1025Assert.True(type.IsSealed); 1100Assert.True(property.IsReadOnly); 1646Assert.True(sym.Symbol.Locations[0].IsInSource); 1655Assert.True(m.Locations[0].IsInSource); 1702Assert.True(statement1.Span.Contains(typeA3.Locations[0].SourceSpan)); 1703Assert.True(statement2.Span.Contains(typeA4.Locations[0].SourceSpan));

Symbols\AssemblyAndNamespaceTests.cs (7)

220Assert.True(constituents.Contains(comp.SourceAssembly.GlobalNamespace.GetMembers("N1").Single() as NamespaceSymbol)); 221Assert.True(constituents.Contains(comp.GetReferencedAssemblySymbol(compRef1).GlobalNamespace.GetMembers("N1").Single() as NamespaceSymbol)); 222Assert.True(constituents.Contains(comp.GetReferencedAssemblySymbol(compRef2).GlobalNamespace.GetMembers("N1").Single() as NamespaceSymbol)); 268Assert.True(constituents.Contains(comp.SourceAssembly.GlobalNamespace.GetMembers("N1").Single() as NamespaceSymbol)); 269Assert.True(constituents.Contains(comp.GetReferencedAssemblySymbol(compRef1).GlobalNamespace.GetMembers("N1").Single() as NamespaceSymbol)); 270Assert.True(constituents.Contains(comp.GetReferencedAssemblySymbol(compRef2).GlobalNamespace.GetMembers("N1").Single() as NamespaceSymbol)); 688Assert.True(comp.Assembly.Identity.IsRetargetable);

Symbols\CheckedUserDefinedOperatorsTests.cs (6)

57Assert.True(opSymbol.IsStatic); 58Assert.True(opSymbol.HasSpecialName); 1299Assert.True(opSymbol.IsStatic); 1300Assert.True(opSymbol.HasSpecialName); 2533Assert.True(opSymbol.IsStatic); 2534Assert.True(opSymbol.HasSpecialName);

Symbols\CompilationCreationTests.cs (53)

Symbols\ConversionTests.cs (29)

Symbols\CorLibrary\Choosing.cs (1)

73Assert.True(consumer.GetSpecialType(SpecialType.System_Object).IsErrorType());

Symbols\CorLibrary\CorTypes.cs (7)

109Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 151Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 170Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 204Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 216Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 362Assert.True(comp1.GetSpecialType(InternalSpecialType.System_Type).IsErrorType()); 543Assert.True(comp1.GetSpecialType(InternalSpecialType.System_Type).IsErrorType());

Symbols\CovariantReturnTests.cs (13)

263Assert.True(method.IsOverride); 265Assert.True(method.IsMetadataVirtual(MethodSymbol.IsMetadataVirtualOption.IgnoreInterfaceImplementationChanges)); 286Assert.True(overriddenMember.Equals(explicitlyOverriddenClassMethod)); 295Assert.True(overriddenMember.Equals(explicitlyOverriddenClassMethod)); 306Assert.True(getMethod.GetOverriddenMember().Equals(overriddenGetMethod)); 341Assert.True(false); 471Assert.True(sourceAssembly is SourceAssemblySymbol); 523Assert.True(retargetingAssembly is RetargetingAssemblySymbol); 3785Assert.True(derivedMethod.IsOverride); 3788Assert.True(overrideMethod.IsOverride); 4880Assert.True(useMethodImpl); 4944Assert.True(useMethodImpl); 5008Assert.True(useMethodImpl);

Symbols\CSharpCompilerFeatureRequiredTests.cs (26)

Symbols\CustomModifiersTests.cs (19)

74Assert.True(nullable.GetTypeArgumentCustomModifiers(0).IsEmpty); 84Assert.True(nullable.GetTypeArgumentCustomModifiers(0).IsEmpty); 139Assert.True(type.GetTypeArgumentCustomModifiers(0).IsEmpty); 149Assert.True(dictionary.GetTypeArgumentCustomModifiers(0).IsEmpty); 150Assert.True(dictionary.GetTypeArgumentCustomModifiers(1).IsEmpty); 157Assert.True(dictionary.GetTypeArgumentCustomModifiers(0).IsEmpty); 158Assert.True(dictionary.GetTypeArgumentCustomModifiers(1).IsEmpty); 296Assert.True(HasTypeArgumentsCustomModifiers(withModifiers)); 298Assert.True(withoutModifiers.Equals(withModifiers, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 1235Assert.True(test.GetMethod.ReturnTypeWithAnnotations.CustomModifiers.SequenceEqual(test.SetMethod.Parameters.First().TypeWithAnnotations.CustomModifiers)); 1463Assert.True(HasTypeArgumentsCustomModifiers(base1)); 1464Assert.True(HasTypeArgumentsCustomModifiers(base2)); 1465Assert.True(base1.Equals(base2, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 1468Assert.True(HasTypeArgumentsCustomModifiers(base3)); 1469Assert.True(base1.Equals(base3, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2490Assert.True(t1.Equals(t2, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2491Assert.True(t2.Equals(t1, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2492Assert.True(t1.Type.Equals(t2.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 2493Assert.True(t2.Type.Equals(t1.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds));

Symbols\DefaultInterfaceImplementationTests.cs (1017)

Symbols\ErrorTypeSymbolTests.cs (2)

78Assert.True(type.IsErrorType()); 79Assert.True(constructedFrom.IsErrorType());

Symbols\ExtendedPartialMethodsTests.cs (15)

1159Assert.True(method.IsExtern); 1162Assert.True(method.IsPartialDefinition()); 1163Assert.True(implementation.IsExtern); 1239Assert.True(method.IsPartialDefinition()); 1265Assert.True(method.IsPartialDefinition()); 1267Assert.True(method.PartialImplementationPart.IsAsync); 1289Assert.True(method.IsPartialDefinition()); 1291Assert.True(method.PartialImplementationPart.IsAsync); 1321Assert.True(method.IsPartialDefinition()); 1323Assert.True(method.PartialImplementationPart.IsAsync); 2122Assert.True(m.ContainingModule is not SourceModuleSymbol || m.IsPartialMember()); 2261Assert.True(m.IsStatic); 2265Assert.True(m.ContainingModule is not SourceModuleSymbol || m.IsPartialMember()); 2316Assert.True(definitionPart.IsPartialDefinition()); 2321Assert.True(implementationPart.IsPartialImplementation());

Symbols\ExtensionMethodTests.cs (26)

Symbols\FunctionPointerTypeSymbolTests.cs (9)

447Assert.True(type.Signature.ReturnsVoid); 680Assert.True(signature.Parameters.Single().Type.IsVoidType()); 922Assert.True(ret1.Equals(ret2, TypeCompareKind.AllNullableIgnoreOptions)); 934Assert.True(((FunctionPointerParameterSymbol)param1).MethodEqualityChecks((FunctionPointerParameterSymbol)param2, 957Assert.True(s1.Equals(s2, TypeCompareKind.AllNullableIgnoreOptions)); 1067Assert.True(param1.Type.Equals(param2.Type, TypeCompareKind.ConsiderEverything)); 1070Assert.True(param1.Type.Equals(param2.Type, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 1269Assert.True(((IFunctionPointerTypeSymbol)typeInfo.Type!).Signature.ReturnType.IsErrorType()); 1965Assert.True(FunctionPointerTypeSymbol.IsCallingConventionModifier(testConvention));

Symbols\GenericConstraintTests.cs (30)

Symbols\ImplicitClassTests.cs (3)

36Assert.True(implicitClass.IsImplicitlyDeclared); 65Assert.True(scriptClass.IsImplicitlyDeclared); 68Assert.True(scriptClass.IsScriptClass);

Symbols\IndexedPropertyTests.cs (17)

Symbols\IndexerTests.cs (31)

152Assert.True(bridgeMethods.Select(GetPairForSynthesizedExplicitImplementation).SetEquals(new[] 163Assert.True(bridgeMethods.Select(GetPairForSynthesizedExplicitImplementation).SetEquals(new[] 179Assert.True(property.IsIndexer); 200Assert.True(setter.ReturnsVoid); 351Assert.True(interface1Getter == interface1GetterImpl ^ interface1Getter == interface2GetterImpl); 352Assert.True(interface2Getter == interface1GetterImpl ^ interface2Getter == interface2GetterImpl); 433Assert.True(interface1Getter == interface1GetterImpl ^ interface1Getter == interface2GetterImpl); 434Assert.True(interface2Getter == interface1GetterImpl ^ interface2Getter == interface2GetterImpl); 554Assert.True(indexer0Impl == classIndexer ^ indexer1Impl == classIndexer); 555Assert.True(indexer0Impl == null ^ indexer1Impl == null); 1152Assert.True(@interface.IsFromCompilation(compilation)); 1159Assert.True(interfaceEvent.CanBeReferencedByName); 1160Assert.True(interfaceProperty.CanBeReferencedByName); 1168Assert.True(@class.IsFromCompilation(compilation)); 1183Assert.True(classEvent.CanBeReferencedByName); 1184Assert.True(classProperty.CanBeReferencedByName); 1235Assert.True(classCIndexer.IsIndexer()); //since declared with IndexerDeclarationSyntax 1516Assert.True(derivedType.Indexers.All(i => i.MetadataName == "A")); 2130Assert.True(indexer.IsIndexer); 2132Assert.True(indexer.GetAttributes().Single().IsTargetAttribute(AttributeDescription.IndexerNameAttribute)); 2137Assert.True(peIndexer.IsIndexer); 2170Assert.True(loopResult.IsCompleted); 2201Assert.True(loopResult.IsCompleted); 2560Assert.True(((TypeSymbol)compilation.GlobalNamespace.GetTypeMembers("C").Single()).GetMembers().Any(x => x.IsIndexer())); 2564Assert.True(((TypeSymbol)compilation.GlobalNamespace.GetTypeMembers("C").Single()).GetMembers().Any(x => x.IsIndexer())); 2648Assert.True(indexerGroup.SetEquals(baseIndexerGroup.GetPublicSymbols(), EqualityComparer<IPropertySymbol>.Default)); 2652Assert.True(indexerGroup.SetEquals(derivedIndexerGroup.GetPublicSymbols(), EqualityComparer<IPropertySymbol>.Default)); 2724Assert.True(model.GetIndexerGroup(receiverSyntaxes[0]).SetEquals( 2729Assert.True(model.GetIndexerGroup(receiverSyntaxes[1]).SetEquals( 2734Assert.True(model.GetIndexerGroup(receiverSyntaxes[2]).SetEquals( 2958Assert.True(a.Parameters[1].HasExplicitDefaultValue);

Symbols\InterfaceImplementationTests.cs (18)

586Assert.True(class1.Interfaces().Contains(@interface)); 635Assert.True(class1.Interfaces().Contains(@interface)); 745Assert.True(baseClassMethodVirtual.IsVirtual); 761Assert.True(class1MethodVirtual.IsOverride); 779Assert.True(class2MethodVirtual.IsOverride); 836Assert.True(declaring1.InterfacesAndTheirBaseInterfacesNoUseSiteDiagnostics.ContainsKey(@interface)); 846Assert.True(declaring2.InterfacesAndTheirBaseInterfacesNoUseSiteDiagnostics.ContainsKey(@interface)); 875Assert.True(baseClass.Interfaces().Contains(@interface)); 880Assert.True(derivedClass.AllInterfaces().Contains(@interface)); 931Assert.True(derivedClass.Interfaces().Contains(@interface)); 938Assert.True(((Cci.IMethodDefinition)baseClassMethod.GetCciAdapter()).IsVirtual); 939Assert.True(((Cci.IMethodDefinition)baseClassPropertyGetter.GetCciAdapter()).IsVirtual); 940Assert.True(((Cci.IMethodDefinition)baseClassPropertySetter.GetCciAdapter()).IsVirtual); 1000Assert.True(derivedClass.Interfaces().Contains(@interface)); 1015Assert.True(synthesizedExplicitImpls.All(s => ReferenceEquals(derivedClass, s.ContainingType))); 1151Assert.True(type.Interfaces().Any(@interface => @interface.Name == "I1")); 1769Assert.True(interfaceProperty.MustCallMethodsDirectly); 2707Assert.True(derivedType.GetSynthesizedExplicitImplementations(cancellationToken: default).ForwardingMethods.IsEmpty);

Symbols\LocalFunctionTests.cs (1)

58Assert.True(local.IsStatic);

Symbols\Metadata\MetadataMemberTests.cs (9)

166Assert.True(ctor.IsDefinition); 171Assert.True(ctor.ReturnsVoid); 207Assert.True(member1.IsDefinition); 209Assert.True(member1.IsStatic); 267Assert.True(p2.IsDefinition); 315Assert.True(member2.IsDefinition); 318Assert.True(member1.IsAbstract); 327Assert.True(member1.ReturnsVoid); 365Assert.True(p2.IsDefinition);

Symbols\Metadata\MetadataTypeTests.cs (24)

Symbols\Metadata\PE\BaseTypeResolution.cs (2)

374Assert.True(m3.BaseType().IsErrorType()); 376Assert.True(m4.BaseType().BaseType().IsErrorType());

Symbols\Metadata\PE\DynamicTransformsTests.cs (8)

70Assert.True(_derivedClass.BaseType().ContainsDynamic()); 90Assert.True(_outerClass.BaseType().ContainsDynamic()); 96Assert.True(_innerClass.BaseType().ContainsDynamic()); 102Assert.True(_innerInnerClass.BaseType().ContainsDynamic()); 107Assert.True(_outer2Class.BaseType().ContainsDynamic()); 330Assert.True(unsafeClass.BaseType().ContainsDynamic()); 371Assert.True(field.Type.ContainsDynamic()); 407Assert.True(f0.Type.ContainsDynamic());

Symbols\Metadata\PE\HasUnsupportedMetadata.cs (6)

372Assert.True(f1.HasUnsupportedMetadata); 376Assert.True(m1.HasUnsupportedMetadata); 380Assert.True(x.HasUnsupportedMetadata); 384Assert.True(e1.HasUnsupportedMetadata); 388Assert.True(p1.HasUnsupportedMetadata); 398Assert.True(begin.HasUnsupportedMetadata);

Symbols\Metadata\PE\LoadCustomModifiers.cs (14)

40Assert.True(f0Mod.IsOptional); 62Assert.True(p1Mod.IsOptional); 69Assert.True(p2Mod.IsOptional); 76Assert.True(p4.HasUnsupportedMetadata); 77Assert.True(p4.ContainingSymbol.HasUnsupportedMetadata); 79Assert.True(m5.ReturnsVoid); 83Assert.True(m5Mod.IsOptional); 95Assert.True(p5TypeMod.IsOptional); 107Assert.True(p6TypeMod.IsOptional); 114Assert.True(m7Mod.IsOptional); 164Assert.True(propertyTypeCustomModifier.IsOptional); 172Assert.True(arrayPropertyTypeCustomModifiers.IsOptional); 238Assert.True(@class.GetMember<EventSymbol>("Event11").Type.IsErrorType()); //Can't have modopt on event type 240Assert.True(@class.GetMember<EventSymbol>("Event01").Type.IsErrorType()); //Can't have modopt on event type

Symbols\Metadata\PE\LoadInAttributeModifier.cs (16)

Symbols\Metadata\PE\LoadingEvents.cs (9)

85Assert.True(staticEvent.IsStatic); 136Assert.True(mismatchedAddEvent.MustCallMethodsDirectly); 139Assert.True(mismatchedRemoveEvent.MustCallMethodsDirectly); 159Assert.True(noParamAddEvent.MustCallMethodsDirectly); 162Assert.True(noParamRemoveEvent.MustCallMethodsDirectly); 202Assert.True(@class.Interfaces().Contains(@interface)); 297Assert.True(refInterface.Interfaces().Contains(defInterface)); 472Assert.True(@event.HasAssociatedField); 526Assert.True(@event.HasAssociatedField);

Symbols\Metadata\PE\LoadingFields.cs (6)

49Assert.True(f1.IsDefinition); 54Assert.True(f1.IsStatic); 67Assert.True(f2.IsReadOnly); 90Assert.True(f5.IsConst); 92Assert.True(f5.IsStatic); 101Assert.True(f6.IsVolatile);

Symbols\Metadata\PE\LoadingGenericTypeParameters.cs (9)

64Assert.True(varC1_T.IsDefinition); 71Assert.True(varC1_T.IsType); 141Assert.True(varT.HasConstructorConstraint); 150Assert.True(varT.HasReferenceTypeConstraint); 159Assert.True(varT.HasValueTypeConstraint); 165Assert.True(varT.HasConstructorConstraint); 166Assert.True(varT.HasReferenceTypeConstraint); 172Assert.True(varT.HasConstructorConstraint); 173Assert.True(varT.HasReferenceTypeConstraint);

Symbols\Metadata\PE\LoadingIndexers.cs (26)

606Assert.True(indexer.MustCallMethodsDirectly); 618Assert.True(staticIndexer.IsStatic); 710Assert.True(parameterCountIndexer.IsIndexer); 711Assert.True(parameterCountIndexer.MustCallMethodsDirectly); 715Assert.True(parameterTypesIndexer.IsIndexer); 716Assert.True(parameterTypesIndexer.MustCallMethodsDirectly); 720Assert.True(returnTypeIndexer.IsIndexer); 721Assert.True(returnTypeIndexer.MustCallMethodsDirectly); 725Assert.True(parameterModoptIndexer.IsIndexer); 730Assert.True(returnTypeModoptIndexer.IsIndexer); 918Assert.True(readWrite.IsIndexer); 920Assert.True(readWrite.Parameters.Last().IsParams); 921Assert.True(readWrite.Parameters.Last().IsParamsArray); 925Assert.True(readOnly.IsIndexer); 927Assert.True(readOnly.Parameters.Last().IsParams); 928Assert.True(readOnly.Parameters.Last().IsParamsArray); 932Assert.True(writeOnly.IsIndexer); 934Assert.True(writeOnly.Parameters.Last().IsParams); 935Assert.True(writeOnly.Parameters.Last().IsParamsArray); 1008Assert.True(readWrite.IsIndexer); 1009Assert.True(readWrite.MustCallMethodsDirectly); 1015Assert.True(readWrite.IsIndexer); 1016Assert.True(readOnly.MustCallMethodsDirectly); 1017Assert.True(readOnly.Parameters.Last().IsParams); //favour setter 1018Assert.True(readOnly.Parameters.Last().IsParamsArray); //favour setter 1173Assert.True(interfaceIndexer.IsIndexer);

Symbols\Metadata\PE\LoadingMethods.cs (63)

Symbols\Metadata\PE\LoadingNamespacesAndTypes.cs (3)

131Assert.True(globalNS.IsGlobalNamespace); 333Assert.True(constructor.IsImplicitlyDeclared); 365Assert.True(constructors[withoutParameterIndex].IsImplicitlyDeclared);

Symbols\Metadata\PE\LoadingProperties.cs (7)

36Assert.True(@class.Interfaces().Contains(@interface)); 131Assert.True(refInterface.Interfaces().Contains(defInterface)); 264Assert.True(implementedByProperty1.SetEquals(classProperty1.ExplicitInterfaceImplementations, ReferenceEqualityComparer.Instance)); 269Assert.True(implementedByGetter1.SetEquals(classProperty1.GetMethod.ExplicitInterfaceImplementations, ReferenceEqualityComparer.Instance)); 272Assert.True(implementedBySetter1.SetEquals(classProperty1.SetMethod.ExplicitInterfaceImplementations, ReferenceEqualityComparer.Instance)); 275Assert.True(implementedByGetter2.SetEquals(classProperty2.GetMethod.ExplicitInterfaceImplementations, ReferenceEqualityComparer.Instance)); 278Assert.True(implementedBySetter2.SetEquals(classProperty2.SetMethod.ExplicitInterfaceImplementations, ReferenceEqualityComparer.Instance));

Symbols\Metadata\PE\MissingTypeReferences.cs (17)

Symbols\Metadata\PE\NoPia.cs (24)

755Assert.True(pia1Link.Properties.EmbedInteropTypes); 757Assert.True(pia5Link.Properties.EmbedInteropTypes); 759Assert.True(library2Link.Properties.EmbedInteropTypes); 766Assert.True(pia5Asm1.IsLinked); 787Assert.True(pia5Asm3.IsLinked); 818Assert.True(pia1Asm5.IsLinked); 819Assert.True(pia5Asm5.IsLinked); 837Assert.True(pia5Asm6.IsLinked); 848Assert.True(pia5Asm7.IsLinked); 849Assert.True(library2Asm7.IsLinked); 899Assert.True(tc3.GetReferencedAssemblySymbol(varCRef).RepresentsTheSameAssemblyButHasUnresolvedReferencesByComparisonTo(varC1)); 936Assert.True(tc7.GetReferencedAssemblySymbol(varCRef).RepresentsTheSameAssemblyButHasUnresolvedReferencesByComparisonTo(varC4)); 1110Assert.True(pia5Link.Properties.EmbedInteropTypes); 1118Assert.True(pia1Link.Properties.EmbedInteropTypes); 1126Assert.True(library2Link.Properties.EmbedInteropTypes); 1133Assert.True(pia5Asm1.IsLinked); 1154Assert.True(pia5Asm3.IsLinked); 1185Assert.True(pia1Asm5.IsLinked); 1186Assert.True(pia5Asm5.IsLinked); 1204Assert.True(pia5Asm6.IsLinked); 1215Assert.True(pia5Asm7.IsLinked); 1216Assert.True(library2Asm7.IsLinked); 1304Assert.True(tc3.GetReferencedAssemblySymbol(varCRef).RepresentsTheSameAssemblyButHasUnresolvedReferencesByComparisonTo(varC1)); 1341Assert.True(tc7.GetReferencedAssemblySymbol(varCRef).RepresentsTheSameAssemblyButHasUnresolvedReferencesByComparisonTo(varC4));

Symbols\Metadata\PE\NoPiaInstantiationOfGenericClassAndStruct.cs (5)

446Assert.True(m.Parameters.Where(arg => arg.Name == "c1").Select(arg => arg).Single().Type.IsFromCompilation(localConsumer)); 451Assert.True(m.ReturnType.IsFromCompilation(localConsumer)); 469Assert.True(classLocalType.IsFromCompilation(localConsumer)); 470Assert.True(classLocalType.IsValueType); 506Assert.True(localField.Type is ArrayTypeSymbol);

Symbols\Metadata\PE\NoPiaLocalHideAndTypeSubstitutionTests.cs (1)

428Assert.True(localType2.Assembly.GetNoPiaResolutionAssemblies().First(arg => arg.Name == "Dummy1").IsLinked);

Symbols\Metadata\PE\TypeForwarders.cs (9)

66Assert.True(module1.TypeRefHandleToTypeMap.Values.Contains((TypeSymbol)base4.OriginalDefinition)); 67Assert.True(module1.TypeRefHandleToTypeMap.Values.Contains((TypeSymbol)base6.OriginalDefinition)); 429Assert.True(ilAssembly1.ResolveForwardedType("Base").IsErrorType()); 431Assert.True(ilAssembly2.ResolveForwardedType("Base").IsErrorType()); 1099Assert.True(actualNamespaces.SetEquals(expectedNamespaces, EqualityComparer<string>.Default)); 1163Assert.True(actualNamespaces.SetEquals(expectedNamespaces, EqualityComparer<string>.Default)); 1227Assert.True(actualNamespaces.SetEquals(expectedNamespaces, EqualityComparer<string>.Default)); 1663Assert.True(token.IsNil); //could the type ref be located? If not then the attribute's not there. 1736Assert.True(token.IsNil); //could the type ref be located? If not then the attribute's not there.

Symbols\Metadata\PE\TypeKindTests.cs (3)

81Assert.True(@enum.IsAbstract); 86Assert.True(func.IsSealed); 93Assert.True(console.IsStatic);

Symbols\MethodEqualityTests.cs (1)

223Assert.True(invokedMethods.All(m => m.Equals(m)));

Symbols\MissingSpecialMember.cs (2)

681Assert.True(wkt.IsValueTupleType()); 919Assert.True(type <= WellKnownType.CSharp7Sentinel);

Symbols\MockSymbolTests.cs (4)

30Assert.True(ats1.IsSZArray); 33Assert.True(ats1.IsReferenceType); 41Assert.True(ats2.IsReferenceType); 59Assert.True(pts1.IsValueType);

Symbols\PartialPropertiesTests.cs (48)

Symbols\PEParameterSymbolTests.cs (7)

111Assert.True(x.IsMetadataOptional); 115Assert.True(y.IsMetadataOptional); 118Assert.True(z.IsOptional); 119Assert.True(z.IsMetadataOptional); 126Assert.True(x1.IsMetadataOptional); 132Assert.True(y2.IsOptional); 133Assert.True(y2.IsMetadataOptional);

Symbols\RequiredMembersTests.cs (10)

42Assert.True(member.IsRequired()); 67Assert.True(type.HasAnyRequiredMembers); 93Assert.True(obsoleteAttribute.IsError); 7176Assert.True(c.HasDeclaredRequiredMembers); 7177Assert.True(field1.IsRequired); 7178Assert.True(property1.IsRequired); 7650Assert.True(tupleType.HasDeclaredRequiredMembers); 7654Assert.All(tupleType.TupleElements, field => Assert.True(field.IsRequired)); 7655Assert.True(tupleType.GetMember<PropertySymbol>("Property").IsRequired); 7983Assert.True(constructor.ShouldCheckRequiredMembers());

Symbols\Retargeting\RetargetCustomAttributes.cs (4)

307Assert.True(args[0].IsNull); 311Assert.True(args[1].IsNull); 317Assert.True(named["P"].IsNull); 321Assert.True(named["F"].IsNull);

Symbols\Retargeting\RetargetCustomModifiers.cs (10)

53Assert.True(f0Mod.IsOptional); 74Assert.True(p1Mod.IsOptional); 82Assert.True(p2Mod.IsOptional); 87Assert.True(m5.ReturnsVoid); 91Assert.True(m5Mod.IsOptional); 104Assert.True(p5TypeMod.IsOptional); 117Assert.True(p6TypeMod.IsOptional); 125Assert.True(m7Mod.IsOptional); 177Assert.True(volatileFld.IsVolatile); 195Assert.True(!m1.ExplicitInterfaceImplementations.IsDefault);

Symbols\Retargeting\RetargetExplicitInterfaceImplementation.cs (1)

99Assert.True(false);

Symbols\Retargeting\RetargetingTests.cs (1)

472Assert.True(retargetingTypeS.IsSerializable);

Symbols\Source\BaseClassTests.cs (11)

468Assert.True(c.Interfaces().Single().TypeArguments().Single().IsErrorType()); //can't see base of C while evaluating C.B 535Assert.True(m.BaseType().IsErrorType()); 671Assert.True(b.BaseType().IsErrorType()); 688Assert.True(z.BaseType().IsErrorType()); 1022Assert.True(B1.IsFromCompilation(comp)); 1137Assert.True(B1.IsFromCompilation(comp)); 1347Assert.True(carr2.IsSZArray); 1533Assert.True(baseY.IsErrorType()); 1545Assert.True(baseY.IsErrorType()); 1572Assert.True(@class.AllInterfaces().SetEquals(bothInterfaces, EqualityComparer<NamedTypeSymbol>.Default)); 1580Assert.True(cciInterfaces.SetEquals(bothInterfaces, EqualityComparer<NamedTypeSymbol>.Default));

Symbols\Source\ClsComplianceTests.cs (2)

2114Assert.True(accessor.Name[0] == '_'); 3324Assert.True(@event.IsWindowsRuntimeEvent);

Symbols\Source\CompletionTests.cs (9)

Symbols\Source\DeclaringSyntaxNodeTests.cs (4)

95Assert.True(symbol.IsImplicitlyDeclared); 193Assert.True(comp.SourceModule.GlobalNamespace.IsImplicitlyDeclared); 266Assert.True(localA1Type.IsAnonymousType); 330Assert.True(localType.IsAnonymousType);

Symbols\Source\DelegateTests.cs (6)

131Assert.True(v.IsReferenceType); 133Assert.True(v.IsSealed); 781Assert.True(d.DelegateInvokeMethod.ReturnsByRef); 799Assert.True(d.DelegateInvokeMethod.ReturnsByRefReadonly); 831Assert.True(lambda.ReturnsByRefReadonly); 838Assert.True(lambda.ReturnsByRefReadonly);

Symbols\Source\EventTests.cs (7)

85Assert.True(@event.IsVirtual); 98Assert.True(@event.HasAssociatedField); 124Assert.True(@event.IsStatic); 136Assert.True(@event.HasAssociatedField); 141Assert.True(associatedField.IsStatic); 198Assert.True(@event.IsStatic); 848Assert.True(eventSymbol.RequiresInstanceReceiver);

Symbols\Source\ExpressionBodiedMethodTests.cs (10)

39Assert.True(gooDef.IsPartial); 40Assert.True(gooDef.IsPartialDefinition); 47Assert.True(gooImpl.IsPartial); 48Assert.True(gooImpl.IsPartialImplementation); 50Assert.True(gooImpl.IsExpressionBodied); 206Assert.True(m.IsExpressionBodied); 210Assert.True(pp.IsExpressionBodied); 214Assert.True(conv.IsExpressionBodied); 295Assert.True(method.IsExplicitInterfaceImplementation); 300Assert.True(method.IsExplicitInterfaceImplementation);

Symbols\Source\ExpressionBodiedPropertyTests.cs (19)

263Assert.True(p.IsExpressionBodied); 269Assert.True(indexer.IsExpressionBodied); 270Assert.True(indexer.IsIndexer); 393Assert.True(prop.IsReadOnly); 398Assert.True(prop.IsReadOnly); 399Assert.True(prop.IsExplicitInterfaceImplementation); 402Assert.True(prop.IsReadOnly); 403Assert.True(prop.IsExplicitInterfaceImplementation); 406Assert.True(prop.IsReadOnly); 510Assert.True(p.IsExpressionBodied); 533Assert.True(p.IsExpressionBodied); 537Assert.True(p.ReturnsByRefReadonly); 538Assert.True(p.GetMethod.ReturnsByRefReadonly); 560Assert.True(p.IsExpressionBodied); 565Assert.True(p.ReturnsByRefReadonly); 566Assert.True(p.GetMethod.ReturnsByRefReadonly); 588Assert.True(p.IsExpressionBodied); 593Assert.True(p.ReturnsByRefReadonly); 594Assert.True(p.GetMethod.ReturnsByRefReadonly);

Symbols\Source\ExternAliasTests.cs (2)

420Assert.True(targets.All(target => ReferenceEquals(firstTarget, target))); 445Assert.True(targets.All(target => ReferenceEquals(firstTarget, target)));

Symbols\Source\FieldTests.cs (7)

145Assert.True(n1.IsConst); 147Assert.True(n1.IsStatic); 152Assert.True(n2.IsVolatile); 162Assert.True(n3.IsStatic); 258Assert.True(mem.IsConst); 500Assert.True(goo.IsFixedSizeBuffer); 547Assert.True(field.RequiresInstanceReceiver);

Symbols\Source\FileModifierTests.cs (34)

Symbols\Source\LocalTests.cs (7)

37Assert.True(symbol.IsForEach); 65Assert.True(local.IsForEach); 66Assert.True(local.IsForEach()); 91Assert.True(symbol.IsForEach); 116Assert.True(symbol.IsUsing); 141Assert.True(symbol.IsUsing); 164Assert.True(symbol.IsUsing);

Symbols\Source\MethodTests.cs (69)

Symbols\Source\ModifierTests.cs (16)

52Assert.True(m1.ReturnsVoid); 63Assert.True(m5_1.IsAbstract); 66Assert.True(m5_2.IsAbstract); 70Assert.True(m7.IsExtern); 72Assert.True(m8.IsOverride); 73Assert.True(m8.IsSealed); 76Assert.True(m8_1.IsOverride); 77Assert.True(m8_1.IsSealed); 80Assert.True(m8_2.IsOverride); 81Assert.True(m8_2.IsSealed); 84Assert.True(m9.IsAbstract); 87Assert.True(m10.IsOverride); 90Assert.True(m11.IsVirtual); 93Assert.True(m12.IsStatic); 126Assert.True(m7.IsExtern); 128Assert.True(m12.IsStatic);

Symbols\Source\NamedTypeTests.cs (13)

Symbols\Source\NullablePublicAPITests.cs (28)

Symbols\Source\PropertyTests.cs (22)

722Assert.True(badStatic.MustCallMethodsDirectly); 723Assert.True(mismatchedStatic.MustCallMethodsDirectly); 739Assert.True(badInstance.MustCallMethodsDirectly); 740Assert.True(mismatchedInstance.MustCallMethodsDirectly); 753Assert.True(staticAndInstance.MustCallMethodsDirectly); 759Assert.True(getUsedAsSet.MustCallMethodsDirectly); 1757Assert.True(@class.Interfaces().Contains(@interface)); 1791Assert.True(@class.Interfaces().Contains(@interface)); 1884Assert.True(getters.Any(getter => getter.Parameters[0].Type.SpecialType == SpecialType.System_Int32)); 1885Assert.True(getters.Any(getter => getter.Parameters[0].Type.SpecialType == SpecialType.System_String)); 1886Assert.True(getters.Any(getter => 2512Assert.True(explicitOverrides.All(@override => ReferenceEquals(@class, @override.ContainingType.GetInternalSymbol()))); 2550Assert.True(explicitOverrides.All(@override => ReferenceEquals(@class, @override.ContainingType.GetInternalSymbol()))); 2651Assert.True(comp.ExternalReferences[1].Properties.EmbedInteropTypes); 2656Assert.True(iap.Type.IsDynamic()); 2658Assert.True(iam.ReturnType.IsDynamic()); 2669Assert.True(comp.ExternalReferences[1].Properties.EmbedInteropTypes); 2674Assert.True(iap.Type.IsDynamic()); 2676Assert.True(iam.ReturnType.IsDynamic()); 2708Assert.True(comp.ExternalReferences[1].Properties.EmbedInteropTypes); 2726Assert.True(comp.ExternalReferences[1].Properties.EmbedInteropTypes); 3028Assert.True(property.RequiresInstanceReceiver);

Symbols\Source\RecordTests.cs (31)

139Assert.True(c.Equals(ctor.Parameters[0].Type, TypeCompareKind.ConsiderEverything)); 168Assert.True(backing.IsImplicitlyDeclared); 172Assert.True(getAccessor.IsImplicitlyDeclared); 179Assert.True(setAccessor.IsImplicitlyDeclared); 183Assert.True(setAccessor.IsInitOnly); 202Assert.True(backing.IsImplicitlyDeclared); 206Assert.True(getAccessor.IsImplicitlyDeclared); 212Assert.True(setAccessor.IsImplicitlyDeclared); 216Assert.True(setAccessor.IsInitOnly); 750Assert.True(ctor.Parameters[0].Type.Equals(c, TypeCompareKind.ConsiderEverything)); 803Assert.True(ctor.Parameters[0].Type.Equals(c, TypeCompareKind.ConsiderEverything)); 900Assert.True(ctor.Parameters[0].Type.Equals(c, TypeCompareKind.ConsiderEverything)); 1432Assert.True(clone.IsVirtual); 1439Assert.True(clone2.IsOverride); 1444Assert.True(clone2.OverriddenMethod.Equals(clone, TypeCompareKind.ConsiderEverything)); 1476Assert.True(clone.IsAbstract); 1480Assert.True(clone.IsImplicitlyDeclared); 1484Assert.True(clone2.IsOverride); 1486Assert.True(clone2.IsAbstract); 1489Assert.True(clone2.OverriddenMethod.Equals(clone, TypeCompareKind.ConsiderEverything)); 1491Assert.True(clone2.IsImplicitlyDeclared); 1495Assert.True(clone3.IsOverride); 1500Assert.True(clone3.OverriddenMethod.Equals(clone2, TypeCompareKind.ConsiderEverything)); 1502Assert.True(clone3.IsImplicitlyDeclared); 1506Assert.True(clone4.IsOverride); 1508Assert.True(clone4.IsAbstract); 1511Assert.True(clone4.OverriddenMethod.Equals(clone3, TypeCompareKind.ConsiderEverything)); 1513Assert.True(clone4.IsImplicitlyDeclared); 1517Assert.True(clone5.IsOverride); 1522Assert.True(clone5.OverriddenMethod.Equals(clone4, TypeCompareKind.ConsiderEverything)); 1524Assert.True(clone5.IsImplicitlyDeclared);

Symbols\Source\SourcePlusMetadataTests.cs (2)

143Assert.True(types1.IsEmpty); 153Assert.True(types1.IsEmpty);

Symbols\Source\TypeMapTests.cs (1)

94Assert.True(type.IsDefinition);

Symbols\StaticAbstractMembersInInterfacesTests.cs (454)

Symbols\SymbolDistinguisherTests.cs (1)

701Assert.True(AreEqual(new SymbolDistinguisher(compilation, sA, sB), new SymbolDistinguisher(compilation, sA, sB)));

Symbols\SymbolEqualityTests.cs (22)

197Assert.True(member1.Equals(member1)); 198Assert.True(member2.Equals(member2)); 205Assert.True(field1.Equals(field1)); 206Assert.True(field2.Equals(field2)); 387Assert.True(SymbolEqualityComparer.Default.Equals(symbol2, symbol3)); 388Assert.True(SymbolEqualityComparer.Default.Equals(symbol3, symbol2)); 390Assert.True(SymbolEqualityComparer.ConsiderEverything.Equals(symbol2, symbol3)); 391Assert.True(SymbolEqualityComparer.ConsiderEverything.Equals(symbol3, symbol2)); 419Assert.True(member1.Equals(member1)); 420Assert.True(member2.Equals(member2)); 427Assert.True(field1.Equals(field1)); 428Assert.True(field2.Equals(field2)); 974Assert.True(symbol1.Equals(symbol1)); 975Assert.True(symbol2.Equals(symbol2)); 976Assert.True(symbol1.Equals(symbol2)); 977Assert.True(symbol2.Equals(symbol1)); 980Assert.True(symbol1.Equals(symbol1, SymbolEqualityComparer.Default)); 981Assert.True(symbol2.Equals(symbol2, SymbolEqualityComparer.Default)); 982Assert.True(symbol1.Equals(symbol2, SymbolEqualityComparer.Default)); 983Assert.True(symbol2.Equals(symbol1, SymbolEqualityComparer.Default)); 986Assert.True(symbol1.Equals(symbol1, SymbolEqualityComparer.IncludeNullability)); 987Assert.True(symbol2.Equals(symbol2, SymbolEqualityComparer.IncludeNullability));

Symbols\SymbolErrorTests.cs (5)

10308Assert.True(classAProp1.IsVirtual); 10309Assert.True(classAProp1.SetMethod.IsVirtual); 10362Assert.True(classAProp1.IsVirtual); 10363Assert.True(classAProp1.GetMethod.IsVirtual); 18525Assert.True(methods.Any(n => n.StartsWith("A..ctor", StringComparison.Ordinal)));

Symbols\SymbolExtensionTests.cs (5)

105Assert.True(anonymousType.ContainsTypeParameter()); 123Assert.True(anonymousType.ContainsTypeParameter()); 141Assert.True(anonymousType.ContainsTypeParameter()); 160Assert.True(anonymousType.ContainsTypeParameter()); 282Assert.True(Array.IndexOf(namespaceNames, expectedName) >= 0);

Symbols\TypeResolutionTests.cs (1)

84Assert.True(c3TestClass.ContainingAssembly.RepresentsTheSameAssemblyButHasUnresolvedReferencesByComparisonTo(c2TestClass.ContainingAssembly));

Symbols\TypeTests.cs (57)

Diagnostics\DiagnosticTest.cs (2)

219Assert.True(ErrorFacts.IsWarning(errorCode)); 257Assert.True(ErrorFacts.IsWarning(errorCode));

Diagnostics\LocationsTests.cs (3)

547Assert.True(mappedLineInfo.HasMappedPath); 570Assert.True(treeSpan.Contains(diagnostics[0].Location.SourceSpan)); 598Assert.True(treeSpan.Contains(diagnostics[0].Location.SourceSpan));

IncrementalParsing\BinaryExpression.cs (2)

217Assert.True(statementType.AttributeLists.Count == 0); 218Assert.True(statementType.Modifiers.Count == 0);

IncrementalParsing\CompoundAssignment.cs (2)

157Assert.True(statementType.AttributeLists.Count == 0); 158Assert.True(statementType.Modifiers.Count == 0);

IncrementalParsing\IncrementalParsingTests.cs (4)

491Assert.True(tree.GetRoot().DescendantNodesAndSelf().Any(n => n is AttributeSyntax)); 502Assert.True(tree.GetRoot().DescendantNodesAndSelf().Any(n => n is CollectionExpressionSyntax)); 524Assert.True(tree.GetRoot().DescendantNodesAndSelf().Any(n => n is CollectionExpressionSyntax)); 533Assert.True(tree.GetRoot().DescendantNodesAndSelf().Any(n => n is AttributeSyntax));

IncrementalParsing\UnaryExpression.cs (2)

100Assert.True(statementType.AttributeLists.Count == 0); 101Assert.True(statementType.Modifiers.Count == 0);

LexicalAndXml\DocumentationCommentLexerTestBase.cs (2)

50Assert.True(expectedHadNext); 55Assert.True(actualHadNext);

LexicalAndXml\LexicalTests.cs (158)

LexicalAndXml\PreprocessorTests.cs (16)

164Assert.True(dt.IsActive); 173Assert.True(((BranchingDirectiveTriviaSyntax)dt).BranchTaken); 182Assert.True(((ConditionalDirectiveTriviaSyntax)dt).ConditionValue); 261Assert.True(setting.IsMissing); 262Assert.True(target.IsMissing); 273Assert.True(target.Kind() == SyntaxKind.WarningsKeyword || target.Kind() == SyntaxKind.AnnotationsKeyword || 276Assert.True(setting.Kind() == SyntaxKind.EnableKeyword || setting.Kind() == SyntaxKind.DisableKeyword || 280Assert.True(SyntaxFacts.IsPreprocessorDirective(SyntaxKind.NullableDirectiveTrivia)); 281Assert.True(SyntaxFacts.IsPreprocessorKeyword(SyntaxKind.NullableKeyword)); 311Assert.True(pwd.WarningKeyword.IsMissing); 320Assert.True(pwd.DisableOrRestoreKeyword.IsMissing); 364Assert.True(pcd.File.IsMissing); 370Assert.True(pcd.Guid.IsMissing); 376Assert.True(pcd.Bytes.IsMissing); 1450Assert.True(node.DescendantTrivia().All(trivia => trivia.Width > 0)); 4425Assert.True(node.GetLoadDirectives().Single().File.IsMissing);

LexicalAndXml\RawStringLiteralLexingTests.cs (1)

185Assert.True(spans.Count == 0 || spans.Count == 1);

LexicalAndXml\XmlDocCommentTests.cs (58)

Parsing\CSharpParseOptionsTests.cs (2)

64Assert.True(options1.Equals(options2)); 151Assert.True(options1.Equals(options2));

Parsing\DeclarationParsingTests.cs (10)

67Assert.True(ud.StaticKeyword == default(SyntaxToken)); 106Assert.True(errors.Length > 0); 121Assert.True(errors.Length > 0); 136Assert.True(errors.Length > 0); 155Assert.True(ud.StaticKeyword == default(SyntaxToken)); 1481Assert.True(cs.ConstraintClauses[1].ColonToken.IsMissing); 1485Assert.True(bound.Type.IsMissing); 1524Assert.True(cs.ConstraintClauses[1].Name.IsMissing); 1525Assert.True(cs.ConstraintClauses[1].ColonToken.IsMissing); 1529Assert.True(bound.Type.IsMissing);

Parsing\DeconstructionTests.cs (2)

2028Assert.True(statement.HasErrors); 2039Assert.True(statement.Kind() == SyntaxKind.ForStatement);

Parsing\ExpressionParsingTests.cs (1)

38Assert.True(((IdentifierNameSyntax)expr).Identifier.IsMissing);

Parsing\ExtensionsParsingTests.cs (1)

4921Assert.True(SyntaxFacts.IsContextualKeyword(SyntaxKind.ExtensionKeyword));

Parsing\FunctionPointerTests.cs (3)

4065Assert.True(CSharp.SyntaxFacts.IsTypeSyntax(SyntaxKind.FunctionPointerType)); 4066Assert.True(CSharp.SyntaxFacts.IsContextualKeyword(SyntaxKind.ManagedKeyword)); 4067Assert.True(CSharp.SyntaxFacts.IsContextualKeyword(SyntaxKind.UnmanagedKeyword));

Parsing\IgnoredDirectiveParsingTests.cs (4)

123Assert.True(SyntaxFacts.IsPreprocessorDirective(trivia.Kind())); 124Assert.True(SyntaxFacts.IsTrivia(trivia.Kind())); 145Assert.True(SyntaxFacts.IsPreprocessorDirective(trivia.Kind())); 146Assert.True(SyntaxFacts.IsTrivia(trivia.Kind()));

Parsing\LocalFunctionParsingTests.cs (1)

1289Assert.True(file.DescendantNodes().Any(n => n.Kind() == SyntaxKind.LocalFunctionStatement && !n.ContainsDiagnostics));

Parsing\NameParsingTests.cs (19)

63Assert.True(((IdentifierNameSyntax)name).Identifier.IsMissing); 77Assert.True(name.IsMissing); 92Assert.True(name.IsMissing); 107Assert.True(name.IsMissing); 307Assert.True(gname.IsUnboundGenericName); 324Assert.True(gname.IsUnboundGenericName); 448Assert.True(gname.IsUnboundGenericName); 632Assert.True(arg.ContainsDiagnostics); 657Assert.True(arg.ContainsDiagnostics); 683Assert.True(arg.ContainsDiagnostics); 710Assert.True(arg.ContainsDiagnostics); 741Assert.True(arg.ContainsDiagnostics); 766Assert.True(arg.ContainsDiagnostics); 786Assert.True(SyntaxFacts.ContainsDroppedIdentifierCharacters(text)); 802Assert.True(SyntaxFacts.ContainsDroppedIdentifierCharacters(text)); 815Assert.True(SyntaxFacts.ContainsDroppedIdentifierCharacters("@")); 816Assert.True(SyntaxFacts.ContainsDroppedIdentifierCharacters("@a")); 817Assert.True(SyntaxFacts.ContainsDroppedIdentifierCharacters("\u200d")); 818Assert.True(SyntaxFacts.ContainsDroppedIdentifierCharacters("a\u200d"));

Parsing\ParsingErrorRecoveryTests.cs (48)

Parsing\ParsingTests.cs (5)

211Assert.True(_treeEnumerator!.MoveNext()); 240Assert.True(_treeEnumerator!.MoveNext()); 243Assert.True(current.IsMissing); 275Assert.True(_treeEnumerator!.MoveNext()); 279Assert.True(current.IsTrivia);

Parsing\ReadOnlyStructs.cs (15)

46Assert.True(s1.IsReadOnly); 52Assert.True(s2.IsReadOnly); 58Assert.True(s3.IsReadOnly); 154Assert.True(s1.IsRefLikeType); 155Assert.True(s1.IsReadOnly); 160Assert.True(s2.IsRefLikeType); 161Assert.True(s2.IsReadOnly); 188Assert.True(s1.IsReadOnly); 191Assert.True(s2.IsRefLikeType); 192Assert.True(s2.IsReadOnly); 221Assert.True(s1.IsRefLikeType); 222Assert.True(s1.IsReadOnly); 226Assert.True(s2.IsReadOnly); 229Assert.True(s3.IsRefLikeType); 230Assert.True(s3.IsReadOnly);

Parsing\ScriptParsingTests.cs (7)

191Assert.True(tree.GetCompilationUnitRoot().ContainsDiagnostics); 233Assert.True(tree.GetCompilationUnitRoot().ContainsDiagnostics); 10155Assert.True(root.ContainsDirectives); 10169Assert.True(root.ContainsDirectives); 10181Assert.True(root.ContainsDirectives); 10240Assert.True(trivia.IsDirective); 10242Assert.True(trivia.HasStructure);

Parsing\StatementParsingTests.cs (7)

911Assert.True(fs.Declaration.Type.IsVar); 1961Assert.True(fs.ForEachKeyword.IsMissing); 3414Assert.True(walker.Tokens > n); 3417Assert.True((tokens2.Length - tokens1.Length) > n); 3441Assert.True(walker.Tokens > n); 3443Assert.True(tokens.Length > n); 3469Assert.True(filterClause.WhenKeyword.HasStructuredTrivia);

Syntax\GreenNodeTests.cs (4)

70Assert.True(sw1.OpenParenToken == default); 71Assert.True(sw1.CloseParenToken == default); 73Assert.True(sw2.OpenParenToken == default); 74Assert.True(sw2.CloseParenToken == default);

Syntax\LambdaUtilitiesTests.cs (12)

Syntax\SeparatedSyntaxListTests.cs (3)

288Assert.True(list.Any(SyntaxKind.AddExpression)); 291Assert.True(list.Any(SyntaxKind.IdentifierName)); 294Assert.True(list.Any(SyntaxKind.NumericLiteralExpression));

Syntax\StructuredTriviaTests.cs (1)

149Assert.True(directives[0].File.IsMissing);

Syntax\SyntaxAnnotationTests.cs (12)

74Assert.True(annotatedToken.IsEquivalentTo(toToken)); 83Assert.True(annotatedToken.IsEquivalentTo(default(SyntaxToken))); 102Assert.True(toTrivia.IsEquivalentTo(annotatedTrivia)); 112Assert.True(default(SyntaxTrivia).IsEquivalentTo(annotatedTrivia)); 296Assert.True(firstNodeInNewTree.ContainsAnnotations); 362Assert.True(oldNode.IsEquivalentTo(annotatedNode)); 377Assert.True(oldTrivia.IsEquivalentTo(newTrivia)); 408Assert.True(sourceNodeOrTokenEnumerator.Current.IsEquivalentTo(destNodeOrTokenEnumerator.Current)); 422Assert.True(sourceTriviaEnumerator.Current.IsEquivalentTo(destTriviaEnumerator.Current)); 625Assert.True(oldNode.IsEquivalentTo(annotatedNode)); 639Assert.True(oldToken.IsEquivalentTo(annotatedToken)); 653Assert.True(oldTrivia.IsEquivalentTo(annotatedTrivia));

Syntax\SyntaxEquivalenceTests.cs (4)

18Assert.True(SyntaxFactory.AreEquivalent(tree1, tree2, topLevel)); 22Assert.True(SyntaxFactory.AreEquivalent(tree1, tree3, topLevel)); 36Assert.True(SyntaxFactory.AreEquivalent(node1, node2, ignoreChildNode)); 40Assert.True(SyntaxFactory.AreEquivalent(node1, tree3.GetRoot(), ignoreChildNode));

Syntax\SyntaxListTests.cs (13)

245Assert.True(declaration.AttributeLists.Count == 0); 246Assert.True(declaration.Modifiers.Count == 0); 256Assert.True(declaration.AttributeLists.Count == 1); 257Assert.True(declaration.Modifiers.Count == 0); 261Assert.True(declaration.AttributeLists.Count == 1); 262Assert.True(declaration.Modifiers.Count == 1); 275Assert.True(list.Any(SyntaxKind.AddExpression)); 278Assert.True(list.Any(SyntaxKind.IdentifierName)); 281Assert.True(list.Any(SyntaxKind.NumericLiteralExpression)); 303Assert.True(item.IsNode); 304Assert.True(item.IsKind(SyntaxKind.Argument)); 311Assert.True(item.IsToken); 312Assert.True(item.IsKind(SyntaxKind.CommaToken));

Syntax\SyntaxNodeTests.cs (55)

Syntax\SyntaxRewriterTests.cs (17)

89Assert.True(caught is InvalidOperationException); 113Assert.True(caught is InvalidOperationException); 294Assert.True(caught is InvalidOperationException); 561Assert.True(expr1.IsMissing); 562Assert.True(expr1.ContainsDiagnostics); 564Assert.True(token1.IsMissing); 579Assert.True(expr2.IsMissing); 583Assert.True(token2.IsMissing); 586Assert.True(IsStatementExpression(expr1)); 587Assert.True(IsStatementExpression(expr2)); 607Assert.True(expr1.IsMissing); 608Assert.True(expr1.ContainsDiagnostics); 610Assert.True(token1.IsMissing); 625Assert.True(expr2.IsMissing); 629Assert.True(token2.IsMissing); 632Assert.True(IsStatementExpression(expr1)); 633Assert.True(IsStatementExpression(expr2));

Syntax\SyntaxTests.cs (9)

27Assert.True(SyntaxFactory.IsCompleteSubmission(SyntaxFactory.ParseSyntaxTree(code, options: TestOptions.Script))); 215Assert.True(SyntaxFacts.IsLiteral(kind)); 229Assert.True(SyntaxFacts.IsAnyToken(kind)); 252Assert.True(SyntaxFacts.IsPunctuation(kind)); 316Assert.True(returnedKindsInts.Remove(i)); 333Assert.True(returnedKindsInts.Remove((int)SyntaxKind.TrueKeyword)); 334Assert.True(returnedKindsInts.Remove((int)SyntaxKind.FalseKeyword)); 335Assert.True(returnedKindsInts.Remove((int)SyntaxKind.DefaultKeyword)); 339Assert.True(returnedKindsInts.Remove(i));

Syntax\SyntaxTokenListTests.cs (3)

250Assert.True(list.Any(SyntaxKind.SizeOfKeyword)); 253Assert.True(list.Any(SyntaxKind.StringLiteralToken)); 256Assert.True(list.Any(SyntaxKind.DotToken));

Syntax\SyntaxTreeTests.cs (5)

164Assert.True(tree.DiagnosticOptions.IsEmpty); 180Assert.True(tree.DiagnosticOptions.IsEmpty); 203Assert.True(tree.DiagnosticOptions.IsEmpty); 212Assert.True(newTree.DiagnosticOptions.IsEmpty); 222Assert.True(newTree.DiagnosticOptions.IsEmpty);

Syntax\SyntaxTriviaListTests.cs (1)

235Assert.True(list.Any(SyntaxKind.MultiLineCommentTrivia));

CompilationTestUtils.cs (7)

122Assert.True(reducedFrom.IsExtensionMethod); 123Assert.True(reducedMethod.IsExtensionMethod); 343Assert.True(!useBaseReferenceAccessibility || (object)container == null); 344Assert.True(!useBaseReferenceAccessibility || !namespacesAndTypesOnly); 367Assert.True(isValidDeclaration(expression)); 428Assert.True(iop.Type?.NullableAnnotation == typeInfo.ConvertedType?.NullableAnnotation); 454Assert.True(compilation.IsNullableAnalysisEnabledIn((CSharpSyntaxTree)tree, new TextSpan(0, tree.Length)));

Extensions.cs (2)

407Assert.True(IsEqual(arg, v)); 416Assert.True(IsEqual(arg, v));

FunctionPointerUtilities.cs (12)

38Assert.True(symbol.IsTypeOrTypeAlias()); 40Assert.True(symbol.IsValueType); 41Assert.True(symbol.CanBeAssignedNull()); 88Assert.True(symbol.IsImplicitlyDeclared); 124Assert.True(symbol.IsImplicitlyDeclared); 284Assert.True(CustomModifierUtils.HasInAttributeModifier(signature.RefCustomModifiers)); 310Assert.True(CustomModifierUtils.HasOutAttributeModifier(parameter.RefCustomModifiers)); 315Assert.True(CustomModifierUtils.HasInAttributeModifier(parameter.RefCustomModifiers)); 332public static Action<TypeSymbol> IsVoidType() => typeSymbol => Assert.True(typeSymbol.IsVoidType()); 343Assert.True(typeSymbol.IsArray()); 348=> typeSymbol => Assert.True(typeSymbol is UnsupportedMetadataTypeSymbol); 354=> typeSymbol => Assert.True(typeSymbol.IsErrorType());

CodeGen\WinRTCollectionTests.cs (3)

7433Assert.True(model.LookupNames(add.SpanStart, jsonObjType).Contains("Add")); 7434Assert.True(model.LookupSymbols(add.SpanStart, jsonObjType, "Add").Contains(addMethod)); 7435Assert.True(model.LookupSymbols(add.SpanStart, jsonObjType).Contains(addMethod));

Metadata\WinMdEventTests.cs (23)

PdbTests.cs (17)

CSharpSyntaxFactsServiceTests.cs (20)

EmbeddedLanguages\VirtualChars\CSharpVirtualCharServiceTests.cs (2)

76Assert.True(virtualChars.IsDefault); 125Assert.True(virtualChars.IsDefault);

AutomaticCompletion\AbstractAutomaticBraceCompletionTests.cs (2)

70Assert.True(caret.Position < session.ClosingPoint.GetPosition(session.SubjectBuffer.CurrentSnapshot)); 132Assert.True(caret.Position < postClosingPoint.Position);

CodeLens\AbstractCodeLensTest.cs (2)

64Assert.True(result.HasValue); 90Assert.True(result.HasValue);

Debugging\AbstractDataTipInfoGetterTests.cs (1)

53Assert.True(result.IsDefault);

ExtractInterface\AbstractExtractInterfaceTests.cs (1)

105Assert.True(result.Succeeded);

Formatting\CoreFormatterTestsBase.cs (1)

222Assert.True(newRootNodeFromString.IsEquivalentTo(newRootNode));

RefactoringHelpers\RefactoringHelpersTestBase.cs (1)

47Assert.True(CodeRefactoringHelpers.IsNodeUnderselected(resultNode, selection));

Semantics\SpeculationAnalyzerTestsBase.cs (2)

32Assert.True(initialMatch.Success); 56Assert.True(CompilationSucceeded(compilation, temporaryStream));

Threading\TaskJoinExtensions.cs (1)

57Assert.True(cancellationToken.IsCancellationRequested);

CodeFixes\CodeFixServiceTests.cs (15)

66Assert.True(fixer1.Called); 67Assert.True(fixer2.Called); 118Assert.True(codeAction is AbstractConfigurationActionWithNestedActions); 119Assert.True(uniqueTitles.Add(codeAction.Title)); 146Assert.True(analyzerWithFix.ReceivedCallback); 153Assert.True(analyzerWithFix.ReceivedCallback); 154Assert.True(analyzerWithoutFix.ReceivedCallback); 182Assert.True(documentDiagnosticAnalyzer.ReceivedCallback); 212Assert.True(codeFix.Called); 284Assert.True(extensionManager.IsDisabled(codefix)); 306Assert.True(extensionManager.IsDisabled(codefix)); 308Assert.True(errorReported); 720Assert.True(actualDiagnosticIdsWithRegisteredCodeActionsByNuGetFixer.SetEquals(expectedDiagnosticIdsWithRegisteredCodeActionsByNuGetFixer)); 724Assert.True(actualDiagnosticIdsWithRegisteredCodeActionsByVsixFixer.SetEquals(expectedDiagnosticIdsWithRegisteredCodeActionsByVsixFixer)); 1052Assert.True(appliedChanges);

CodeFixes\ExtensionOrderingTests.cs (9)

45Assert.True(actualOrder.Length > 0); 46Assert.True(actualOrder.IndexOf(p => p.Metadata.Name == PredefinedCodeFixProviderNames.AddImport) < 52Assert.True(actualOrder.Length > 0); 53Assert.True(actualOrder.IndexOf(p => p.Metadata.Name == PredefinedCodeFixProviderNames.AddImport) < 105Assert.True(actualOrder.Length > 0); 110Assert.True(actualOrder.Length > 0); 136Assert.True(codeFixPriorityMap.Count > 0); 144Assert.True(currentIndex >= 0); 151Assert.True(nextIndex > currentIndex);

CodeRefactorings\CodeRefactoringServiceTest.cs (3)

54Assert.True(stubRefactoringAction is object); 112Assert.True(extensionManager.IsDisabled(codeRefactoring)); 115Assert.True(errorReported);

Collections\Immutable\Maps\BidirectionalMapTests.cs (32)

Completion\FileSystemCompletionHelperTests.cs (1)

25Assert.True(actual.All(i => i.Rules == TestFileSystemCompletionHelper.CompletionRules));

Completion\GlobalAssemblyCacheCompletionHelperTests.cs (1)

33Assert.True(completions.Any(c => c.DisplayText == completionItem));

Completion\TestFileSystemCompletionHelper.cs (2)

33Assert.True(drives.All(d => d.EndsWith(PathUtilities.DirectorySeparatorStr))); 34Assert.True(directories.All(d => !d.EndsWith(PathUtilities.DirectorySeparatorStr)));

Diagnostics\DiagnosticAnalyzerServiceTests.cs (6)

174Assert.True(applied); 334Assert.True(workspace.TryApplyChanges(solution)); 384Assert.True(applied); 478Assert.True(diagnostic != null); 484Assert.True(diagnostic == null); 950Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(new TestGeneratorReference(generator)).Solution));

Diagnostics\DiagnosticDataTests.cs (1)

231Assert.True(hostDocument.IsSourceGenerated);

Diagnostics\IDEDiagnosticIDConfigurationTests.cs (2)

60Assert.True(diagnosticIdAndOptions.All(tuple => tuple.diagnosticId != diagnosticId || tuple.options.SetEquals(options))); 99Assert.True(expectedLines.Length % 2 == 0);

EditAndContinue\EditAndContinueLanguageServiceTests.cs (7)

143Assert.True(sessionState.IsSessionActive); 157Assert.True(sessionState.IsSessionActive); 320Assert.True(sessionState.IsSessionActive); 329Assert.True(called); 338Assert.True(called); 341Assert.True(sessionState.IsSessionActive); 375Assert.True(workspace.SetCurrentSolution(_ => solution, WorkspaceChangeKind.SolutionAdded));

EmbeddedLanguages\Json\LanguageServices\JsonLanguageDetectorTests.cs (2)

25Assert.True(JsonLanguageDetector.CommentDetector.TryMatch(value, out _, out var captures)); 29Assert.True(EmbeddedLanguageCommentOptions<JsonOptions>.TryGetOptions(captures!, out var actualOptions));

EmbeddedLanguages\RegularExpressions\LanguageServices\RegexPatternDetectorTests.cs (2)

25Assert.True(RegexLanguageDetector.CommentDetector.TryMatch(value, out _, out var captures)); 29Assert.True(EmbeddedLanguageCommentOptions<RegexOptions>.TryGetOptions(captures!, out var actualOptions));

EmbeddedLanguages\StackFrame\StackFrameSyntaxFactory.cs (1)

107Assert.True(s.Contains('.'));

Emit\CompilationOutputFilesTests.cs (1)

45Assert.True(encReader.IsPortable);

Extensions\IProjectionBufferFactoryServiceExtensionsTests.cs (1)

47Assert.True(line.GetText().StartsWith("line", StringComparison.Ordinal));

Extensions\ITextLineExtensionsTests.cs (4)

75Assert.True(value); 82Assert.True(value); 89Assert.True(value); 96Assert.True(value);

Extensions\ITextSnapshotExtensionsTests.cs (1)

152Assert.True(snapshot.TryGetPosition(3, 2, out var point));

Extensions\ITextSnapshotLineExtensionsTests.cs (4)

134Assert.True(value); 141Assert.True(value); 148Assert.True(value); 155Assert.True(value);

Extensions\SetExtensionTests.cs (2)

20Assert.True(set.AddAll(["c", "d"])); 21Assert.True(set.AddAll(["e", "f"]));

InheritanceMargin\InheritanceMarginTests.cs (4)

133Assert.True(!actualItem.TargetItems.IsEmpty); 159Assert.True(actualTarget.DefinitionItem.Properties.ContainsKey("MetadataSymbolKey")); 160Assert.True(actualTarget.DefinitionItem.SourceSpans.IsEmpty); 335Assert.True(targetInfo.LocationTags != null);

MetadataAsSource\AbstractMetadataAsSourceTests.cs (1)

128Assert.True(SymbolKey.GetComparer(ignoreCase: true, ignoreAssemblyKeys: false).Equals(metadataSymbolId, generatedSymbol.GetSymbolKey()));

MetadataAsSource\AbstractMetadataAsSourceTests.TestContext.cs (1)

307Assert.True(_metadataAsSourceService.TryAddDocumentToWorkspace(file.FilePath, stringText.Container, out var _));

Preview\PreviewWorkspaceTests.cs (9)

RenameTracking\RenameTrackingTaggerProviderTests.cs (1)

873Assert.True(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(source.Task, out _));

Structure\StructureTaggerTests.cs (2)

91Assert.True(methodTag.IsImplementation); 303Assert.True(methodTag.IsImplementation);

SymbolFinder\SymbolFinderTests.cs (13)

452Assert.True(immediateDerived.All(d => d.BaseType.Equals(rootType))); 461Assert.True(transitiveDerived.Count() > immediateDerived.Count()); 499Assert.True(immediateDerived.All(d => d.Interfaces.Contains(rootType))); 510Assert.True(transitiveDerived.Count() > immediateDerived.Count()); 549Assert.True(immediateImpls.All(d => d.Interfaces.Contains(rootType))); 562Assert.True(transitiveImpls.Count() > immediateImpls.Count()); 712Assert.True(typesThatDerive.Any(t => t.Name == "T_DependProject_Class")); 719Assert.True(typesThatDerive.Any(t => t.Name == "T_DependProject_Class")); 726Assert.True(typesThatDerive.Any(t => t.Name == "T_DependProject_Class")); 825Assert.True(classInSource.Locations.Any(loc => loc.IsInMetadata)); 832Assert.True(sourceDefinition.Locations.Any(loc => loc.IsInSource)); 873Assert.True(classInSource.Locations.Any(loc => loc.IsInMetadata)); 880Assert.True(sourceDefinition.Locations.Any(loc => loc.IsInSource));

Tagging\AsynchronousTaggerTests.cs (3)

165Assert.True(callbackCounter <= 1); 169Assert.True(c.FrozenPartialSemantics); 222Assert.True(callbackCounter == 0);

Tagging\TagSpanIntervalTreeTests.cs (1)

145Assert.True(lastStart < tag.Span.Start.Position);

TextEditor\TryGetDocumentTests.cs (1)

46Assert.True(container == newSourceText.Container);

Utilities\BloomFilterTests.cs (6)

119Assert.True(BloomFilter.BloomFilterHash.TryGetCachedEntry(out var isCaseSensitive, out var value)); 120Assert.True(!isCaseSensitive); 124Assert.True(BloomFilter.BloomFilterHash.TryGetCachedEntry(out isCaseSensitive, out value)); 125Assert.True(isCaseSensitive); 144Assert.True(bloomFilter.IsEquivalent(rehydratedFilter)); 162Assert.True(bloomFilter.IsEquivalent(rehydratedFilter));

Utilities\PatternMatcherTests.cs (6)

231=> Assert.True(results.Any(r => r.Kind == type)); 320Assert.True(match.Select(m => m.Kind).SequenceEqual(new[] { PatternMatchKind.StartOfWordSubstring, PatternMatchKind.StartOfWordSubstring })); 328Assert.True(match.Select(m => m.Kind).SequenceEqual(new[] { PatternMatchKind.StartOfWordSubstring, PatternMatchKind.StartOfWordSubstring })); 387Assert.True(match.Select(m => m.Kind).SequenceEqual(new[] { PatternMatchKind.StartOfWordSubstring, PatternMatchKind.StartOfWordSubstring })); 429Assert.True(((PatternMatcher.SimplePatternMatcher)matcher).GetTestAccessor().LastCacheResultIs(areSimilar: true, candidateText: "Go")); 432Assert.True(((PatternMatcher.SimplePatternMatcher)matcher).GetTestAccessor().LastCacheResultIs(areSimilar: false, candidateText: "DefNotAMatch"));

Utilities\StackFrameUtils.cs (4)

220Assert.True(nodeOrToken.Token.IsMissing); 221Assert.True(nodeOrToken.Token.LeadingTrivia.IsDefault); 222Assert.True(nodeOrToken.Token.TrailingTrivia.IsDefault); 224Assert.True(nodeOrToken.Token.VirtualChars.IsDefault);

Utilities\SymbolEquivalenceComparerTests.cs (93)

ParsingTestBase.cs (3)

44Assert.True(typeArguments.Length > 0); 60Assert.True(typeArguments.Length > 0); 101Assert.True(actualSignature.Parameters.IsDefault);

VisualBasicParsingTests.cs (2)

33Assert.True(added); 56Assert.True(MemberSignatureParser.Keywords.Contains(keyword));

ResultProviderTestBase.cs (2)

235Assert.True(builder.Count <= enumContext.Count); 515Assert.True(

RazorAnalyzerAssemblyResolverTests.cs (1)

71Assert.True(result.Success);

EditAndContinue\EditAndContinueTestVerifier.cs (8)

140Assert.True(editScripts.Length == expectedResults.Length); 210Assert.True(expectedResult.SemanticEdits.IsEmpty); 211Assert.True(result.SemanticEdits.IsDefault); 217Assert.True(result.ExceptionRegions.IsDefault); 218Assert.True(result.ActiveStatements.IsDefault); 236Assert.True(result.LineEdits.IsDefault); 237Assert.True(expectedResult.LineEdits.IsDefaultOrEmpty); 286Assert.True(edit.NewSymbol is not null);

RelatedDocuments\AbstractRelatedDocumentsTests.cs (1)

45Assert.True(results.Distinct().Count() == results.Count);

EditAndContinue\CompileTimeSolutionProviderTests.cs (1)

65Assert.True(compileTimeSolution.ContainsDocument(documentId));

EditAndContinue\EditAndContinueCapabilitiesTests.cs (5)

20Assert.True(service.HasFlag(EditAndContinueCapabilities.Baseline)); 41Assert.True(service.HasFlag(EditAndContinueCapabilities.Baseline)); 42Assert.True(service.HasFlag(EditAndContinueCapabilities.NewTypeDefinition)); 52Assert.True(service.HasFlag(EditAndContinueCapabilities.Baseline)); 53Assert.True(service.HasFlag(EditAndContinueCapabilities.NewTypeDefinition));

EditAndContinue\EditAndContinueDiagnosticDescriptorsTests.cs (1)

57Assert.True(descriptors.All(d => d != null));

EditAndContinue\EditAndContinueMethodDebugInfoReaderTests.cs (1)

113Assert.True(reader.TryGetDocumentChecksum("/a/c.cs", out var actualChecksum, out var actualAlgorithm));

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (23)

EditAndContinue\EditSessionActiveStatementsTests.cs (3)

692Assert.True(s.IsNonLeaf); 697Assert.True(s.IsLeaf); 698Assert.True(s.IsNonLeaf);

EditAndContinue\RemoteEditAndContinueServiceTests.cs (3)

137Assert.True(reportDiagnostics); 262Assert.True(called); 296Assert.True(documentActiveSpans.IsDefault);

CodeLens\AbstractCodeLensTests.cs (1)

52Assert.True(resolvedCodeLens.Command.Title.StartsWith(expectedReferenceCountString));

Commands\ExecuteWorkspaceCommandTests.cs (1)

43Assert.True((bool)response);

Completion\CompletionFeaturesTests.cs (9)

345Assert.True(results.IsIncomplete); 350Assert.True(!someTextItem.Preselect && someTextItem.CommitCharacters != null && someTextItem.CommitCharacters.Length == 0); 355Assert.True(!someTextItem.Preselect && someTextItem.CommitCharacters == null); 776Assert.True(results.Items.All(item => item.CommitCharacters is null)); 807Assert.True(results.IsIncomplete); 862Assert.True(results.IsIncomplete); 1105Assert.True(results.IsIncomplete); 1119Assert.True(results.IsIncomplete); 1121Assert.True(results.Items.Any(i => i.Label == "if"));

Completion\CompletionResolveTests.cs (1)

383Assert.True(clientCompletionItem.VsResolveTextEditOnCommit);

Completion\CompletionTests.cs (35)

Configuration\DidChangeConfigurationNotificationHandlerTest.cs (3)

93Assert.True(clientCallbackTarget.WorkspaceDidChangeConfigurationRegistered); 174Assert.True(option.Definition.Serializer.TryParse(valueFromClient, out var result)); 341Assert.True(match.Success);

Definitions\GoToDefinitionTests.cs (4)

50Assert.True(results.Single().DocumentUri.GetRequiredParsedUri().OriginalString.StartsWith("file")); 338Assert.True(results.Single().DocumentUri.GetRequiredParsedUri().OriginalString.EndsWith("String.cs")); 371Assert.True(results.Single().DocumentUri.GetRequiredParsedUri().LocalPath.EndsWith("generated_file.cs")); 374Assert.True(service.DidMapSpans);

Diagnostics\DiagnosticRegistrationTests.cs (5)

83Assert.True(options.InterFileDependencies); 90Assert.True(options.WorkspaceDiagnostics); 91Assert.True(options.InterFileDependencies); 92Assert.True(options.WorkDoneProgress); 101Assert.True(diagnosticOptions.InterFileDependencies);

Diagnostics\PullDiagnosticTests.cs (7)

784Assert.True(results.Single().Diagnostics![0].Tags!.Contains(DiagnosticTag.Unnecessary)); 794Assert.True(results.Single().Diagnostics![0].Tags!.Contains(DiagnosticTag.Unnecessary)); 857Assert.True(results.Single().Diagnostics![1].Tags!.Contains(DiagnosticTag.Unnecessary)); 861Assert.True(results.Single().Diagnostics![2].Tags!.Contains(DiagnosticTag.Unnecessary)); 867Assert.True(results.Single().Diagnostics!.Single().Tags!.Contains(DiagnosticTag.Unnecessary)); 1101Assert.True(testLspServer.TestWorkspace.TryApplyChanges(solution)); 1107Assert.True(results[1].Diagnostics!.Single().Message.Contains("Source generator failed"));

DocumentChanges\DocumentChangesTests.cs (1)

369Assert.True(DidChangeHandler.AreChangesInReverseOrder([change1, change2, change3]));

HandlerTests.cs (2)

162Assert.True(didReport); 220Assert.True(didReport);

InlayHint\AbstractInlayHintTests.cs (1)

53Assert.True(matchingInlayHint.PaddingRight);

InlayHint\CSharpInlayHintTests.cs (1)

139Assert.True(lastInlayHints.Any());

LanguageServerTargetTests.cs (3)

51Assert.True(server.GetServerAccessor().GetServerRpc().IsDisposed); 62Assert.True(server.GetServerAccessor().GetServerRpc().IsDisposed); 136Assert.True(statefulService.IsDisposed);

LspServicesTests.cs (5)

26Assert.True(lspService is CSharpLspService); 39Assert.True(lspService is CSharpLspService); 52Assert.True(lspService is AnyLspService); 79Assert.True(lspService is CSharpLspService); 84Assert.True(lspService2 is AlwaysActiveCSharpLspService);

MapCode\MapCodeTests.cs (1)

117Assert.True(results.Changes!.TryGetValue(ProtocolConversions.GetDocumentFilePathFromUri(documentUri.GetRequiredParsedUri()), out edits));

Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (6)

100Assert.True(workspace.CurrentSolution.FallbackAnalyzerOptions.TryGetValue(language, out var fallbackOptions)); 101Assert.True(fallbackOptions!.TryGetValue(option.Definition.ConfigName, out var configValue)); 155Assert.True(workspace.CurrentSolution.FallbackAnalyzerOptions.TryGetValue(LanguageNames.CSharp, out var fallbackOptions)); 168Assert.True(workspace.CurrentSolution.FallbackAnalyzerOptions.TryGetValue(LanguageNames.CSharp, out fallbackOptions)); 178Assert.True(documentOptions.TryGetEditorConfigOption<NamingStylePreferences>(NamingStyleOptions.NamingPreferences, out var documentPreferences)); 217Assert.True(documentOptions.TryGetEditorConfigOption(NamingStyleOptions.NamingPreferences, out documentPreferences));

Ordering\RequestOrderingTests.cs (16)

ProtocolConversionsTests.cs (1)

336Assert.True(projectContext.IsMiscellaneous);

References\FindAllReferencesHandlerTests.cs (4)

251Assert.True(results.All(r => r.Location != null)); 346Assert.True(results[0].Location.DocumentUri.ToString().EndsWith("String.cs")); 382Assert.True(results[1].Location.DocumentUri.GetRequiredParsedUri().LocalPath.EndsWith("generated_file.cs")); 385Assert.True(service.DidMapSpans);

Rename\RenameTests.cs (4)

189Assert.True(documentEdit.Edits.All(edit => edit.Unify().NewText == renameText)); 279Assert.True(service.DidMapSpans); 329Assert.True(service.DidMapSpans); 371Assert.True(service.DidMapSpans);

SemanticTokens\AbstractSemanticTokensTests.cs (1)

83Assert.True(tokens.Length % 5 == 0);

SemanticTokens\SemanticTokensRangeTests.cs (1)

604Assert.True(schema.AllTokenTypes.Contains(tokenName));

SpellCheck\SpellCheckTests.cs (2)

96Assert.True(results.Length == 6); 377Assert.True(results.All(r => r.TextDocument!.DocumentUri.GetRequiredParsedUri().LocalPath == "C:\\C.cs"));

Symbols\WorkspaceSymbolsTests.cs (1)

24=> Assert.True(expected.ToHashSet().SetEquals(results!));

UriTests.cs (5)

55Assert.True(await testLspServer.GetManager().GetTestAccessor().IsMiscellaneousFilesDocumentAsync(document)); 81Assert.True(await testLspServer.GetManager().GetTestAccessor().IsMiscellaneousFilesDocumentAsync(document)); 305Assert.True(await testLspServer.GetManager().GetTestAccessor().IsMiscellaneousFilesDocumentAsync(document)); 368Assert.True(areEqual == (documentUri1 == documentUri2)); 369Assert.True(areEqual != (documentUri1 != documentUri2));

Workspaces\LspWorkspaceManagerTests.cs (12)

Workspaces\SourceGeneratedDocumentTests.cs (2)

290Assert.True( 301Assert.True(testLspServer.TestWorkspace.TryApplyChanges(solutionWithDocumentChanged));

LspFileChangeWatcherTests.cs (3)

41Assert.True(LspFileChangeWatcher.SupportsLanguageServerHost(testLspServer.LanguageServerHost)); 124Assert.True(Registrations.TryAdd(registration.Id, registration)); 133Assert.True(Registrations.TryRemove(unregistration.Id, out var _));

BasicDeterministicKeyBuilderTests.cs (1)

315Assert.True(string.IsNullOrEmpty(output));

CSharpDeterministicKeyBuilderTests.cs (1)

499Assert.True(string.IsNullOrEmpty(output));

OptionRoundTripTests.cs (1)

70Assert.True(OptimizationLevelFacts.TryParsePdbSerializedString(data, out var optimization2, out var debugPlus2));

RebuildCommandLineTests.cs (1)

90Assert.True(commonCompiler.Arguments.CompilationOptions.Deterministic);

RoundTripUtil.cs (5)

41Assert.True(embeddedPdbReader == null ^ portablePdbReader == null); 58Assert.True(emitResult.Success); 71Assert.True(original.SyntaxTrees.All(x => !string.IsNullOrEmpty(x.FilePath))); 72Assert.True(original.Options.Deterministic); 109Assert.True(result.Success);

MetadataShadowCopyProviderTests.cs (2)

148Assert.True(Directory.Exists(scDir)); 155Assert.True(_provider.IsShadowCopy(sc));

NuGetPackageResolverTests.cs (1)

46Assert.True(NuGetPackageResolver.TryParsePackageReference(reference, out name, out version));

RuntimeMetadataReferenceResolverTests.cs (4)

40Assert.True(actualReferences.IsEmpty); 46Assert.True(actualReferences.IsEmpty); 55Assert.True(actualReferences.IsEmpty); 61Assert.True(actualReferences.IsEmpty);

ScriptOptionsTests.cs (4)

170Assert.True(ScriptOptions.Default.WithEmitDebugInformation(true).EmitDebugInformation); 199Assert.True(ScriptOptions.Default.WithAllowUnsafe(true).AllowUnsafe); 201Assert.True(ScriptOptions.Default.AllowUnsafe); 226Assert.True(ScriptOptions.Default.WithCheckOverflow(true).CheckOverflow);

Assert\EqualityTesting.cs (2)

20Assert.True(x.Equals(y)); 21Assert.True(((object)x).Equals(y));

Assert\EqualityUtil`1.cs (11)

73Assert.True(_compareWithEqualityOperator(unit.Value, value)); 74Assert.True(_compareWithEqualityOperator(value, unit.Value)); 111Assert.True(_compareWithInequalityOperator(unit.Value, value)); 112Assert.True(_compareWithInequalityOperator(value, unit.Value)); 126Assert.True(_compareWithInequalityOperator(default(T), value)); 127Assert.True(_compareWithInequalityOperator(value, default(T))); 135Assert.True(type.GetTypeInfo().ImplementedInterfaces.Contains(targetType)); 145Assert.True(value.Equals(unitValue)); 146Assert.True(unitValue.Equals(value)); 198Assert.True(equatableUnit.Equals(value)); 200Assert.True(equatableValue.Equals(unit.Value));

CommonTestBase.cs (3)

150Assert.True(assemblyValidator != null || symbolValidator != null); 690Assert.True(semanticModel.Root.FullSpan.Contains(child.Syntax.FullSpan)); 702Assert.True(set.Contains(operation));

Compilation\ControlFlowGraphVerifier.cs (10)

152Assert.True(block.IsReachable); 195Assert.True(previousPredecessorOrdinal < predecessor.Ordinal); 214Assert.True(predecessorBranch.IsConditionalSuccessor); 246Assert.True(conditionalBranch.IsConditionalSuccessor); 258Assert.True(block.ConditionKind == ControlFlowConditionKind.WhenTrue || block.ConditionKind == ControlFlowConditionKind.WhenFalse); 297Assert.True(block.EnclosingRegion.Kind == ControlFlowRegionKind.Filter || block.EnclosingRegion.Kind == ControlFlowRegionKind.Finally); 305Assert.True(ControlFlowBranchSemantics.Return == nextBranch.Semantics || ControlFlowBranchSemantics.Throw == nextBranch.Semantics); 1576Assert.True(ControlFlowBranchSemantics.None == branch.Semantics || ControlFlowBranchSemantics.Throw == branch.Semantics || 1582Assert.True(ControlFlowBranchSemantics.Regular == branch.Semantics || ControlFlowBranchSemantics.Return == branch.Semantics); 1583Assert.True(branch.Destination.Predecessors.Contains(p => p.Source == fromBlock));

Compilation\OperationTreeVerifier.cs (1)

321Assert.True(operation.Syntax.Language == operation.Language);

Compilation\TestOperationVisitor.cs (25)

Diagnostics\CommonDiagnosticAnalyzers.cs (1)

1257Assert.True(_verifyGetControlFlowGraph);

Diagnostics\DiagnosticExtensions.cs (2)

137Assert.True(assemblyIds.IsEmpty); 326Assert.True(diagnostics.All(d => !d.IsSuppressed));

Diagnostics\ThrowingDiagnosticAnalyzer.cs (1)

85Assert.True(diagnostics.Any(AnalyzerExecutor.IsAnalyzerExceptionDiagnostic));

Metadata\EncValidation.cs (3)

27Assert.True(previousModule.GenerationId.IsNil); 28Assert.True(previousModule.BaseGenerationId.IsNil); 31Assert.True(currentModule.BaseGenerationId.IsNil);

AnalyzerAssemblyLoaderTests.cs (1)

1204Assert.True(value is true);

Analyzers\AnalyzerConfigTests.cs (107)

Analyzers\AnalyzerFileReferenceTests.cs (6)

77Assert.True(refA.Equals(refA)); 78Assert.True(refA.Equals(refB)); 88Assert.True(refA.Equals((AnalyzerReference)refA)); 90Assert.True(refA!.Equals((AnalyzerReference)refB)); 91Assert.True(refA.Equals(new TestAnalyzerReference(path1))); 491Assert.True(result.Success);

AsyncQueueTests.cs (9)

29Assert.True(task.IsCompleted); 45Assert.True(queue.TryEnqueue(42)); 54Assert.True(queue.TryEnqueue(42)); 111Assert.True(threw); 137Assert.True(threw); 159Assert.True(threw); 186Assert.True(queue.TryDequeue(out var value)); 210Assert.True(queue.TryDequeue(out value)); 227Assert.True(queue.TryDequeue(out value));

Collections\BitArrayTests.cs (3)

30if (n > 0) Assert.True(arr[n - 1]); 246Assert.True(i2.MoveNext()); 285Assert.True(b[index]);

Collections\ByteSequenceComparerTests.cs (13)

Collections\Extensions\EnumerableExtensionsTests.cs (18)

Collections\Extensions\ImmutableArrayExtensionsTests.cs (70)

Collections\Extensions\ListExtensionsTests.cs (8)

42Assert.True(new[] { 1, 1 }.HasDuplicates()); 43Assert.True(new[] { 11, 1 }.HasDuplicates(comparer)); 44Assert.True(new[] { 1, 3 }.HasDuplicates(i => i % 2)); 45Assert.True(new[] { 11.0, 1.2 }.HasDuplicates(i => (int)i, comparer)); 52Assert.True(new[] { 2, 0, 1, 2 }.HasDuplicates()); 53Assert.True(new[] { 2, 0, 1, 12 }.HasDuplicates(comparer)); 54Assert.True(new[] { 2, 0, 1, 52 }.HasDuplicates(i => i % 10)); 55Assert.True(new[] { 2.3, 0.1, 1.3, 52.4 }.HasDuplicates(i => (int)i, comparer));

Collections\HashSet\ISet_Generic_Tests`1.cs (13)

94Assert.True(set.Add(newValue)); 98Assert.True(set.Contains(newValue)); 140Assert.True(expected.SetEquals(set)); 155Assert.True(beforeOperation.SetEquals(set)); 166Assert.True(expected.SetEquals(set)); 228Assert.True(set.IsSubsetOf(enumerable)); 240Assert.True(set.IsSupersetOf(enumerable)); 250Assert.True(set.Overlaps(enumerable)); 276Assert.True(set.SetEquals(enumerable)); 291Assert.True(expected.SetEquals(set)); 303Assert.True(expected.SetEquals(set)); 514Assert.True(set.SetEquals(set)); 662Assert.True(expected.SetEquals(set));

Collections\HashSet\SegmentedHashSet_Generic_Tests`1.cs (16)

92Assert.True(set.SetEquals(enumerable)); 102Assert.True(hashSetFromNoDuplicates.SetEquals(hashSetFromDuplicates)); 115Assert.True(set.SetEquals(source)); 134Assert.True(set.SetEquals(enumerable)); 203Assert.True(set.SetEquals(expected)); 217Assert.True(set.Remove(elementToRemove)); 221Assert.True(set.SetEquals(expected)); 284Assert.True(arr1.SequenceEqual(arr2)); 321Assert.True(comparerSet1.SetEquals(set)); 322Assert.True(comparerSet2.SetEquals(set)); 349Assert.True(noComparerSet.SequenceEqual(set, SegmentedHashSet<T>.CreateSetComparer())); 446Assert.True(set.TryGetValue(equalValue, out T? actualValue)); 463Assert.True(set.TryGetValue(equalValue, out actualValue)); 636Assert.True(set.Remove(set.ElementAt(0))); 639Assert.True(currentCapacity > 0); 642Assert.True(newCapacity > currentCapacity);

Collections\IdentifierCollectionTests.cs (6)

41Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), idcol.OrderBy(x => x))); 50Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), copy.OrderBy(x => x))); 58Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), idcol.OrderBy(x => x))); 67Assert.True(Enumerable.SequenceEqual(strings.OrderBy(x => x), copy.OrderBy(x => x))); 80Assert.True(collection.IsReadOnly); 95Assert.True(collection.Contains(str));

Collections\ImmutableDictionaryBuilderTestBase.cs (10)

82Assert.True(builder.Contains(new KeyValuePair<string, int>("five", 5))); 90Assert.True(builder.Remove(new KeyValuePair<string, int>("five", 5))); 149Assert.True(builder.TryGetValue("five", out int value) && value == 5); 150Assert.True(builder.TryGetValue("six", out value) && value == 6); 162Assert.True(enumerator.MoveNext()); 163Assert.True(enumerator.MoveNext()); 180Assert.True(dictionary.Contains("a")); 203Assert.True(enumerator.MoveNext()); 221Assert.True(enumerator.MoveNext()); 243Assert.True(builder.ContainsKey("b"));

Collections\ImmutableDictionaryBuilderTestBase.nonnetstandard.cs (2)

23Assert.True(TryGetKeyHelper(builder, "a", out string actualKey)); 26Assert.True(TryGetKeyHelper(builder, "A", out actualKey));

Collections\ImmutableDictionaryTestBase.cs (19)

54Assert.True(IsSame(map, sameMap)); 134Assert.True(dictionary.IsReadOnly); 143Assert.True(dictionary.IsSynchronized); 173Assert.True(dictionary.Contains("c")); 176Assert.True(dictionary.IsFixedSize); 177Assert.True(dictionary.IsReadOnly); 191Assert.True(enumerator.MoveNext()); 209Assert.True(enumerator.MoveNext()); 227Assert.True(dictionary.TryGetKey("a", out string actualKey)); 230Assert.True(dictionary.TryGetKey("A", out actualKey)); 240Assert.True(IsSame(empty, empty.Clear())); 259Assert.True(GetValueComparer(map).Equals(value1, value2)); 262Assert.True(IsSame(map, map.Add(key, value2))); 263Assert.True(IsSame(map, map.AddRange(new[] { new KeyValuePair<TKey, TValue>(key, value2) }))); 295Assert.True(map.Add(key, value).ContainsKey(key)); 303Assert.True(map.Add(key, value).Contains(new KeyValuePair<TKey, TValue>(key, value))); 304Assert.True(map.Add(key, value).Contains(key, value)); 311Assert.True(IsSame(map, map.Remove(key))); 312Assert.True(IsSame(map, map.RemoveRange(Enumerable.Empty<TKey>())));

Collections\ImmutableDictionaryTestBase.nonnetstandard.cs (17)

72Assert.True(Empty<int, int>().Equals(Empty<int, int>())); 79Assert.True(Empty<int, int>().ToReadOnlyDictionary().Equals(Empty<int, int>())); 80Assert.True(Empty<int, int>().Equals(Empty<int, int>().ToReadOnlyDictionary())); 81Assert.True(Empty<int, int>().ToReadOnlyDictionary().Equals(Empty<int, int>().ToReadOnlyDictionary())); 98Assert.True(IsSame(map, jointMap)); 101Assert.True(IsSame(map, jointMap)); 104Assert.True(IsSame(map, jointMap)); 134Assert.True(addedMap.ContainsKey(key)); 152Assert.True(map.ContainsKey(i)); 166Assert.True(map.ContainsKey(i)); 183Assert.True(map.ContainsKey(inputs[i])); 198Assert.True(IsSame(empty, empty.RemoveRange(Enumerable.Empty<int>()))); 199Assert.True(IsSame(empty, empty.AddRange(Enumerable.Empty<KeyValuePair<int, int>>()))); 204Assert.True(halfRemoved.ContainsKey(8)); 289Assert.True(collection.Contains(containedValue)); 296Assert.True(nonGeneric.IsSynchronized); 297Assert.True(collection.IsReadOnly);

Collections\ImmutableListTestBase.cs (5)

137Assert.True(ExistsImpl(list, n => n == 3)); 144Assert.True(FindAllImpl(ImmutableSegmentedList<int>.Empty, n => true).IsEmpty); 332Assert.True(ConvertAllImpl<int, float>(ImmutableSegmentedList<int>.Empty, n => n).IsEmpty); 343Assert.True(GetRangeImpl(ImmutableSegmentedList<int>.Empty, 0, 0).IsEmpty); 361Assert.True(TrueForAllImpl(ImmutableSegmentedList<int>.Empty, n => false));

Collections\ImmutableSegmentedDictionaryBuilderTest.cs (24)

Collections\ImmutableSegmentedDictionaryTest.cs (16)

43Assert.True(map.ContainsKey("Johnny")); 47Assert.True(newMap.ContainsKey("Johnny")); 48Assert.True(newMap.ContainsKey("johnny")); // because it's case insensitive 163Assert.True(IsSame(dictionary, result)); 175Assert.True(map.ContainsKey("a")); 181Assert.True(map.ContainsKey("a")); 182Assert.True(map.ContainsKey("A")); 183Assert.True(map.ContainsKey("b")); 195Assert.True(map.ContainsKey("a")); 273Assert.True(IsSame(ImmutableSegmentedDictionary<string, int>.Empty, dictionary.Clear())); 290Assert.True(clearedDictionary.ContainsKey("A")); 311Assert.True(map.Keys.All((key, arg) => key.Length == arg, 1)); 313Assert.True(ImmutableSegmentedDictionary<int, int>.Empty.Keys.All((_, _) => false, 0)); 324Assert.True(map.Values.All((key, arg) => key.Length == arg, 1)); 326Assert.True(ImmutableSegmentedDictionary<int, int>.Empty.Values.All((_, _) => false, 0)); 348Assert.True(map.Add(key, value).ContainsValue(value));

Collections\ImmutableSegmentedHashSetBuilderTest.cs (47)

Collections\ImmutableSegmentedHashSetTest.cs (6)

55Assert.True(ignoreCaseSet.Contains("aPpLe")); 88Assert.True(enumerator.MoveNext()); 94Assert.True(enumeratorCopy.MoveNext()); 103Assert.True(enumerator.MoveNext()); 162Assert.True(IsSame(set, set.Remove(2))); 177Assert.True(IsSame(set, set.Remove("c")));

Collections\ImmutableSegmentedHashSetTest.nonnetstandard.cs (3)

45Assert.True(IsSame(emptySet, emptySet.ToImmutableSegmentedHashSet(comparer))); 50Assert.True(IsSame(emptySet, ImmutableSegmentedHashSet<T>.Empty)); 54Assert.True(IsSame(reemptied, reemptied.ToImmutableSegmentedHashSet(comparer))); //, "Getting the empty set from a non-empty instance did not preserve the comparer.");

Collections\ImmutableSegmentedListBuilderTest.cs (18)

40Assert.True(builder.Contains(3)); 41Assert.True(builder.Contains(5)); 49Assert.True(builder.Contains(8)); 58Assert.True(builder.Contains(1)); 63Assert.True(builder.Contains(3)); 64Assert.True(builder.Contains(5)); 69Assert.True(list2.Contains(1)); 73Assert.True(builder.Contains(8)); 84Assert.True(IsSame(immutable1, mutable.ToImmutable())); //, "The Immutable property getter is creating new objects without any differences."); 89Assert.True(IsSame(immutable2, mutable.ToImmutable())); //, "The Immutable property getter is creating new objects without any differences."); 100Assert.True(enumerator.MoveNext()); 120Assert.True(collection == builder.ToImmutable()); // no changes at all. 125Assert.True(IsSame(newImmutable, builder.ToImmutable())); // second ToImmutable without changes should be the same instance. 181Assert.True(mutable.Remove(2)); 183Assert.True(mutable.Remove(1)); 185Assert.True(mutable.Remove(3)); 317Assert.True(list.Contains(5)); 419Assert.True(builder.ToImmutableSegmentedList().IsEmpty);

Collections\ImmutableSegmentedListTest.cs (27)

Collections\ImmutableSetTest.cs (28)

55Assert.True(IsSame(emptySet, emptySet.Remove(5))); 69Assert.True(IsSame(set, setAfterRemoval)); 78Assert.True(IsSame(set, empty2.Union(set))); // "Filling an empty immutable set with the contents of another immutable set with the exact same comparer should return the other set." 97Assert.True(enumerated); 103Assert.True(this.Empty<int>().SetEquals(this.Empty<int>())); 105Assert.True(nonEmptySet.SetEquals(nonEmptySet)); 145Assert.True(Empty<int>().Equals(Empty<int>())); 165Assert.True(IsSame(originalSet, clearedSet)); 186Assert.True(set.IsReadOnly); 202Assert.True(builder.IsSynchronized); 212Assert.True(set.Contains(null)); 213Assert.True(set.TryGetValue(null, out var @null)); 218Assert.True(set.IsSupersetOf(new[] { null, "a" })); 219Assert.True(set.IsSubsetOf(new[] { null, "a" })); 220Assert.True(set.IsProperSupersetOf(new[] { (string?)null })); 221Assert.True(set.IsProperSubsetOf(new[] { null, "a", "b" })); 222Assert.True(set.Overlaps(new[] { null, "b" })); 223Assert.True(set.SetEquals(new[] { null, null, "a", "a" })); 291Assert.True(IsSame(emptySet, emptySet.Clear())); 392Assert.True(IsSame(set, set.Except(Enumerable.Empty<T>()))); 403Assert.True(IsSame(nextSet, nextSet.Remove(value))); //, "Removing a non-existing element should not change the set reference."); 425Assert.True(set.Contains(value)); 479Assert.True(enumerator.MoveNext()); 488Assert.True(IsSame(set, set.Union(Enumerable.Empty<T>()))); 497Assert.True(enumerateAddSet.Contains(value)); 505Assert.True(nextSet.Count > 0); 514Assert.True(nextSet.Contains(value)); 521Assert.True(IsSame(nextSet, nextSet.Add(value))); //, "Adding duplicate value {0} should keep the original reference.", value);

Collections\ImmutableSetTest.nonnetstandard.cs (2)

100Assert.True(set.TryGetValue(lookupValue, out string actual)); 139Assert.True(set.Intersect(Enumerable.Empty<T>()).Count == 0);

Collections\List\ICollection.Generic.Tests.cs (11)

361Assert.True(SpinWait.SpinUntil(() => 376Assert.True(collection.Remove(value)); 410Assert.True(collection.Contains(item)); 432Assert.True(collection.Contains(default(T))); 536Assert.True(Enumerable.SequenceEqual(collection, array)); 546Assert.True(Enumerable.SequenceEqual(collection, array.Take(count))); 613Assert.True(collection.Remove(value)); 632Assert.True(collection.Remove(value)); 649Assert.True(collection.Remove(value)); 650Assert.True(collection.Contains(value)); 664Assert.True(collection.Remove(value));

Collections\List\IEnumerable.Generic.Tests.cs (4)

238Assert.True(itemsVisited[i]); 606Assert.True(firstValues.Add(item)); 608Assert.True(secondValues.Add(item)); 611Assert.True(secondValues.Contains(item));

Collections\List\IEnumerable.NonGeneric.Tests.cs (3)

300Assert.True(firstValues.Add(item)); 302Assert.True(secondValues.Add(item)); 305Assert.True(secondValues.Contains(item));

Collections\List\IList.NonGeneric.Tests.cs (3)

576Assert.True(collection.Contains(item)); 596Assert.True(collection.Contains(null)); 968Assert.True(collection.Contains(value));

Collections\List\SegmentedList.Generic.Tests.BinarySearch.cs (2)

55Assert.True(list.BinarySearch(beforeList[index]) >= 0); 56Assert.True(list.BinarySearch(beforeList[index], GetIComparer()) >= 0);

Collections\List\SegmentedList.Generic.Tests.cs (1)

62Assert.True(list[i] == null ? expectedItems[i] == null : list[i].Equals(expectedItems[i]));

Collections\List\SegmentedList.Generic.Tests.Misc.cs (14)

Collections\List\SegmentedList.Generic.Tests.Sort.cs (6)

41Assert.True(comparer.Compare(list[i], list[i + 1]) < 0); 55Assert.True(comparer.Compare(list[i], list[i + 1]) <= 0); 72Assert.True(comparer.Compare(list[i], list[i + 1]) < 0); 86Assert.True(comparer.Compare(list[i], list[i + 1]) <= 0); 104Assert.True(iComparer.Compare(list[i], list[i + 1]) < 0); 119Assert.True(iComparer.Compare(list[i], list[i + 1]) <= 0);

Collections\SegmentedArrayTests.cs (6)

46Assert.True(data.IsFixedSize); 47Assert.True(data.IsReadOnly); 115Assert.True(items[i].Length <= SegmentedArray<IntPtr>.TestAccessor.SegmentSize); 125Assert.True(data.IsFixedSize); 126Assert.True(data.IsReadOnly); 195Assert.True(SegmentedCollectionsMarshal.AsSegments(data).Length > 10);

Collections\SegmentedCollectionsMarshalTests.cs (70)

Collections\TemporaryArrayTests.cs (6)

56Assert.True(TemporaryArray<int>.TestAccessor.HasDynamicStorage(in array)); 62Assert.True(TemporaryArray<int>.TestAccessor.HasDynamicStorage(in array)); 93Assert.True(TemporaryArray<int>.TestAccessor.HasDynamicStorage(in array)); 113Assert.True(TemporaryArray<int>.TestAccessor.HasDynamicStorage(in array)); 162Assert.True(enumerator.MoveNext()); 300Assert.True(array.Contains(i));

Collections\TopologicalSortTests.cs (4)

39Assert.True(wasAcyclic); 60Assert.True(wasAcyclic); 83Assert.True(wasAcyclic); 151Assert.True(wasAcyclic);

CommonCommandLineParserTests.cs (2)

451Assert.True(ruleSet.Includes.Count() == 1); 1265Assert.True(MemoryMarshal.TryGetString(memory, out var memoryString, out _, out _));

CommonSqmUtilitiesTests.cs (1)

26Assert.True(result);

CommonSyntaxTests.cs (2)

48Assert.True(d.IsToken); 65Assert.True(d.IsToken);

CorLibTypesTests.cs (19)

CryptoBlobParserTests.cs (13)

Diagnostics\AnalysisContextInfoTests.cs (1)

50Assert.True(diagnostics[0].ToString().IndexOf(analyzer.Info.GetContext()) >= 0);

Diagnostics\DiagnosticLocalizationTests.cs (1)

326Assert.True(exceptionDiagnostics.TrueForAll(AnalyzerExecutor.IsAnalyzerExceptionDiagnostic));

Diagnostics\OperationTests.cs (9)

162Assert.True(exceptionThrown); 180Assert.True(exceptionThrown); 198Assert.True(exceptionThrown); 216Assert.True(exceptionThrown); 238Assert.True(exceptionThrown); 258Assert.True(exceptionThrown); 291Assert.True(exceptionThrown); 304Assert.True(exceptionThrown); 319Assert.True(exceptionThrown);

Emit\CustomDebugInfoTests.cs (5)

33Assert.True(CustomDebugInfoReader.TryGetCustomDebugInfoRecord(new byte[] { 5, 1, 0, 0 }, CustomDebugInfoKind.EditAndContinueLocalSlotMap).IsDefault); 42Assert.True(CustomDebugInfoReader.TryGetCustomDebugInfoRecord(cdi, CustomDebugInfoKind.EditAndContinueLocalSlotMap).IsDefault); 70Assert.True(CustomDebugInfoReader.TryGetCustomDebugInfoRecord(cdi, CustomDebugInfoKind.EditAndContinueLocalSlotMap).IsEmpty); 100Assert.True(CustomDebugInfoReader.TryGetCustomDebugInfoRecord(cdi, CustomDebugInfoKind.EditAndContinueLocalSlotMap).IsDefault); 110Assert.True(CustomDebugInfoReader.TryGetCustomDebugInfoRecord(cdi, CustomDebugInfoKind.EditAndContinueLocalSlotMap).IsDefault);

Emit\EmitOptionsTests.cs (1)

43Assert.True(newOpt1.Equals(newOpt2));

FileSystem\PathUtilitiesTests.cs (32)

FileUtilitiesTests.cs (10)

GivesAccessTo.cs (4)

56Assert.True(CS.ContainingAssembly.GivesAccessTo(CS2.ContainingAssembly)); 57Assert.True(CS.ContainingAssembly.GivesAccessTo(VB.ContainingAssembly)); 60Assert.True(VB.ContainingAssembly.GivesAccessTo(VB2.ContainingAssembly)); 61Assert.True(VB.ContainingAssembly.GivesAccessTo(CS.ContainingAssembly));

InternalUtilities\ConcurrentLruCacheTests.cs (2)

62Assert.True(clc.TestingEnumerable.SequenceEqual(expected)); 75Assert.True(clc.TestingEnumerable.SequenceEqual(expected));

InternalUtilities\OneOrManyTests.cs (34)

InternalUtilities\SpecializedCollectionsTests.cs (6)

35Assert.True(emptySet.IsReadOnly); 46Assert.True(emptySet.IsProperSubsetOf(new int[1])); 49Assert.True(emptySet.IsSubsetOf(new int[0])); 50Assert.True(emptySet.IsSubsetOf(new int[1])); 51Assert.True(emptySet.IsSupersetOf(new int[0])); 55Assert.True(emptySet.SetEquals(new int[0]));

LinePositionTests.cs (8)

81Assert.True(new LinePosition(1, 1) < new LinePosition(1, 2)); 84Assert.True(new LinePosition(1, 2) < new LinePosition(2, 1)); 85Assert.True(new LinePosition(1, 2) <= new LinePosition(1, 2)); 86Assert.True(new LinePosition(1, 2) <= new LinePosition(2, 1)); 89Assert.True(new LinePosition(1, 2) > new LinePosition(1, 1)); 92Assert.True(new LinePosition(2, 1) > new LinePosition(1, 2)); 93Assert.True(new LinePosition(2, 1) >= new LinePosition(2, 1)); 94Assert.True(new LinePosition(2, 1) >= new LinePosition(1, 2));

MetadataReferences\AssemblyIdentityComparerTests.cs (2)

53Assert.True(AssemblyIdentity.TryParseDisplayName(displayName1, out id1, out parts1)); 56Assert.True(AssemblyIdentity.TryParseDisplayName(displayName2, out id2, out parts2));

MetadataReferences\AssemblyIdentityDisplayNameTests.cs (1)

45Assert.True(AssemblyIdentity.TryParseVersion(value, out actual, out actualParts));

MetadataReferences\AssemblyIdentityMapTests.cs (7)

27Assert.True(map.Contains(new AssemblyIdentity("a", new Version(1, 0, 0, 0)))); 28Assert.True(map.TryGetValue(new AssemblyIdentity("a", new Version(1, 0, 0, 0)), out value)); 31Assert.True(map.Contains(new AssemblyIdentity("a", new Version(1, 1, 0, 0)))); 32Assert.True(map.TryGetValue(new AssemblyIdentity("a", new Version(1, 1, 0, 0)), out value)); 35Assert.True(map.Contains(new AssemblyIdentity("a", new Version(1, 0, 0, 0)), allowHigherVersion: false)); 36Assert.True(map.TryGetValue(new AssemblyIdentity("a", new Version(1, 0, 0, 0)), out value, allowHigherVersion: false)); 47Assert.True(map.TryGetValue(new AssemblyIdentity("b", new Version(1, 0, 0, 0)), out value));

MetadataReferences\AssemblyIdentityTests.cs (24)

37Assert.True(id1.Equals(id1)); 38Assert.True(id1.Equals(id2)); 39Assert.True(id2.Equals(id1)); 40Assert.True(id1.Equals(id11)); 41Assert.True(id11.Equals(id1)); 42Assert.True(id2.Equals(id22)); 43Assert.True(id22.Equals(id2)); 59Assert.True(win1.Equals(win3)); 72Assert.True(neutral1.Equals(invariant)); 73Assert.True(neutral2.Equals(invariant)); 74Assert.True(neutral3.Equals(invariant)); 99Assert.True(id.IsRetargetable); 112Assert.True(id.HasPublicKey); 113Assert.True(id.IsStrongName); 159Assert.True(id.HasPublicKey); 171Assert.True(id.IsRetargetable); 181Assert.True(id.HasPublicKey); 182Assert.True(id.IsRetargetable); 192Assert.True(id.HasPublicKey); 203Assert.True(id1.IsStrongName); 206Assert.True(id2.IsStrongName); 217Assert.True(id5.IsStrongName); 263Assert.True(id.HasPublicKey); 264Assert.True(id.IsRetargetable);

MetadataReferences\MetadataHelpersTests.cs (5)

26Assert.True(Char.IsLowSurrogate(lowSurrogate, 0)); 27Assert.True(Char.IsHighSurrogate(highSurrogate, 0)); 28Assert.True(Char.IsSurrogatePair(highSurrogate + lowSurrogate, 0)); 32Assert.True(MetadataHelpers.IsValidMetadataIdentifier("x")); 39Assert.True(MetadataHelpers.IsValidMetadataIdentifier(highSurrogate + lowSurrogate));

MetadataReferences\MetadataReferencePropertiesTests.cs (3)

21Assert.True(m.Aliases.IsEmpty); 27Assert.True(m.EmbedInteropTypes); 31Assert.True(m.Aliases.IsEmpty);

MetadataReferences\MetadataReferenceTests.cs (21)

MetadataReferences\ModuleMetadataTests.cs (9)

195Assert.True(disposed); 223Assert.True(disposed); 253Assert.True(disposed); 284Assert.True(disposed); 314Assert.True(disposed); 318Assert.True(seeked); 348Assert.True(disposed); 352Assert.True(seeked); 381Assert.True(disposed);

MetadataReferences\ModuleNoPiaTests.cs (4)

28Assert.True(localTypes1.ContainsNoPiaLocalTypes()); 29Assert.True(localTypes1.ContainsNoPiaLocalTypes()); 31Assert.True(localTypes2.ContainsNoPiaLocalTypes()); 32Assert.True(localTypes2.ContainsNoPiaLocalTypes());

PEWriter\UsedNamespaceOrTypeTests.cs (2)

71Assert.True(type1.Object.Equals(type2.Object)); 73Assert.True(object.Equals(type1.Object, type2.Object));

ShadowCopyAnalyzerPathResolverTests.cs (2)

37Assert.True(PathResolver.IsAnalyzerPathHandled(analyzerPath)); 66Assert.True(File.Exists(shadowPath));

StringTableTests.cs (2)

103Assert.True(TestTextEqualsASCII("", "")); 106Assert.True(TestTextEqualsASCII("a", "a"));

Text\CompositeTextTests.cs (1)

39Assert.True(sourceLinesText.SequenceEqual(compositeLinesText));

Text\SourceTextStreamTests.cs (2)

55Assert.True(buffer.Take(baseText.Length).SequenceEqual(encoding.GetBytes(baseText))); 58Assert.True(buffer.Take(3).SequenceEqual(encoding.GetBytes(new[] { '\u2019' })));

Text\SourceTextTests.cs (26)

Text\StringTextDecodingTests.cs (3)

164Assert.True(stream.CanRead); 181Assert.True(stream.CanRead); 198Assert.True(stream.CanRead);

Text\TextChangeTests.cs (1)

1274Assert.True(position <= change.Span.Start);

Text\TextSpanTest.cs (26)

Text\TextUtilitiesTests.cs (5)

18Assert.True(TextUtilities.IsAnyLineBreakCharacter('\n')); 19Assert.True(TextUtilities.IsAnyLineBreakCharacter('\r')); 20Assert.True(TextUtilities.IsAnyLineBreakCharacter('\u0085')); 21Assert.True(TextUtilities.IsAnyLineBreakCharacter('\u2028')); 22Assert.True(TextUtilities.IsAnyLineBreakCharacter('\u2029'));

VersionHelperTests.cs (6)

24Assert.True(VersionHelper.TryParseAssemblyVersion("3.2.*", allowWildcard: true, version: out version)); 30Assert.True(VersionHelper.TryParseAssemblyVersion("1.2.3.*", allowWildcard: true, version: out version)); 70Assert.True(VersionHelper.TryParse("1.234.56.7", out version)); 76Assert.True(VersionHelper.TryParse("3.2.1", out version)); 82Assert.True(VersionHelper.TryParse("3.2", out version)); 88Assert.True(VersionHelper.TryParse("3", out version));

Win32Res.cs (1)

186Assert.True(found);

CommandLineIVTTests.vb (1)

561Assert.True(compiler.Arguments.ReportInternalsVisibleToAttributes)

CommandLineTests.vb (81)

InteractiveSessionTests.vb (4)

133Assert.True(compilation2.IsSymbolAccessibleWithin(c2C1, c2C2)) 134Assert.True(compilation2.IsSymbolAccessibleWithin(c2C2, c2C1)) 135Assert.True(compilation2.IsSymbolAccessibleWithin(c2X, c2C2)) ' access not enforced among submission symbols 148Assert.True(compilation3.IsSymbolAccessibleWithin(c3C3, c3C1))

EmbeddedLanguages\VirtualChars\VisualBasicVirtualCharServiceTests.vb (1)

23Assert.True(token.Kind() = SyntaxKind.StringLiteralToken OrElse

VisualBasicSyntaxFactsServiceTests.vb (42)

BuildHostProcessManagerTests.cs (6)

26Assert.True(rollForwardIndex >= 0); 27Assert.True(latestMajorIndex >= 0); 77Assert.True(binlogIndex >= 0); 97Assert.True(binlogIndex >= 0); 118Assert.True(localeIndex >= 0); 146Assert.True(argumentIndex >= 0);

MSBuildWorkspaceTestBase.cs (1)

139Assert.True(result.Success);

NewlyCreatedProjectsFromDotNetNew.cs (1)

132Assert.True(foundDivider);

RpcTests.cs (4)

153Assert.True(call1.IsCompleted); 159Assert.True(call2.IsCompleted); 183Assert.True(call2.IsCompleted); 189Assert.True(call1.IsCompleted);

VisualStudioMSBuildWorkspaceTests.cs (11)

230Assert.True(projects[0].ProjectReferences.Any(r => r.ProjectId == projects[1].Id) || 237Assert.True(compilation1.References.OfType<CompilationReference>().Any(c => c.Compilation == compilation2) || 410Assert.True(dversion1.GetTestAccessor().IsNewerThan(dversion)); 415Assert.True(latestDV1.GetTestAccessor().IsNewerThan(latestDV)); 424Assert.True(document2.Project.Version.GetTestAccessor().IsNewerThan(document1.Project.Version)); 431Assert.True(solution3.Version.GetTestAccessor().IsNewerThan(solution2.Version)); 1883Assert.True(options.PreprocessorSymbolNames.Contains("EnableMyAttribute")); 1984Assert.True(File.Exists(fooDoc.FilePath)); 2315Assert.True(analyzerReference.FullPath.EndsWith("CSharpProject.dll", StringComparison.OrdinalIgnoreCase)); 2901Assert.True(noEncodingSolution.Workspace.TryApplyChanges(noEncodingSolution)); 2946Assert.True(projFileText.Contains(@"<ProjectReference Include=""..\CSharpProject\CSharpProject.csproj"">"));

Formatting\FormattingTestBase.cs (1)

79Assert.True(newRootNodeFromString.IsEquivalentTo(newRootNode));

Logging\TestTelemetryLogger.cs (1)

54Assert.True(OpenedScopes.Remove((TestScope)scope));

OptionsCollection.cs (1)

98Assert.All(this, o => Assert.True(o.Key.Option.Definition.IsEditorConfigOption));

Workspaces\TestWorkspace`1.cs (1)

641Assert.True(document.IsLinkFile || documentFilePaths.Add(document.FilePath!));

ChecksumTests.cs (1)

147Assert.True((i == j) == (checksums[i] == checksums[j]));

CodeCleanup\CodeCleanupTests.cs (1)

325Assert.True(newSemanticModel.IsSpeculativeSemanticModel);

Differencing\LongestCommonSubsequenceTests.cs (5)

50Assert.True(edit.Kind is EditKind.Delete or EditKind.Insert or EditKind.Update); 54Assert.True(edit.OldIndex < oldStr.Length); 59Assert.True(edit.NewIndex < newStr.Length); 64Assert.True(edit.OldIndex < oldStr.Length); 65Assert.True(edit.NewIndex < newStr.Length);

Differencing\MatchTests.cs (7)

26Assert.True(m.TryGetNewNode(x1, out var n)); 54Assert.True(m.TryGetNewNode(x1, out var n)); 56Assert.True(m.TryGetOldNode(x2, out n)); 58Assert.True(m.TryGetNewNode(y1, out n)); // matched 79Assert.True(m.TryGetNewNode(x1, out var n)); // matched 81Assert.True(m.TryGetOldNode(newRoot, out n)); 83Assert.True(m.TryGetNewNode(oldRoot, out n));

EditorConfigParsing\EditorConfigFileParserTests.cs (19)

EditorConfigParsing\SectionParserTests.cs (10)

EditorConfigStorageLocation\NamingStylePreferenceEditorConfigStorageLocationTests.cs (1)

19Assert.True(value.IsEmpty);

FindAllDeclarationsTests.cs (2)

139Assert.True(csharpResult.Count() > 0); 142Assert.True(vbResult.Count() > 0);

FindReferencesTests.cs (4)

416Assert.True(projectIds.Contains(netCoreProject.Id)); 664Assert.True(typeResult.Locations.All(loc => loc.Location.SourceSpan != constructorResult.Locations.Single().Location.SourceSpan)); 670Assert.True(typeResult.Locations.Count(loc => loc.Alias == null) == 1); 671Assert.True(typeResult.Locations.Count(loc => loc.Alias != null) == 1);

Formatter\FormatterTests.cs (20)

ObjectSerializationTests.cs (5)

72Assert.True(Equalish(value, newValue)); 103Assert.True(Equalish(value, newValue)); 266Assert.True(Enumerable.SequenceEqual(expected, (byte[])reader.ReadByteArray())); 431Assert.True(reader.ReadBoolean()); 498Assert.True((bool)reader.ReadScalarValue());

Options\CodeStyleOptionTests.cs (1)

102Assert.True(deserialized.Value);

Options\EditorConfigCodeStyleParserTests.cs (2)

57Assert.True(CodeStyleOptions2.AccessibilityModifiersRequired.Definition.Serializer.TryParseValue(configurationString, out var parsedCodeStyleOption)); 74Assert.True(FormattingOptions2.NewLine.Definition.Serializer.TryParseValue(configurationString, out var parsedNewLine));

Options\EditorConfigNamingStyleParserTests.cs (1)

464Assert.True(!string.IsNullOrEmpty(editorConfigString));

Options\NamingStylePreferencesTests.cs (2)

28=> Assert.True( 196Assert.True(type.IsEnum);

Options\OptionKeyTests.cs (7)

171Assert.True(option.Definition.Serializer.TryParseValue("true:suggestion", out var result)); 180Assert.All(FormattingOptions2.EditorConfigOptions, o => Assert.True(o.Definition.IsEditorConfigOption)); 181Assert.All(FormattingOptions2.UndocumentedOptions, o => Assert.True(o.Definition.IsEditorConfigOption)); 185Assert.All(CSharpFormattingOptions2.EditorConfigOptions, o => Assert.True(o.Definition.IsEditorConfigOption)); 186Assert.All(CSharpFormattingOptions2.UndocumentedOptions, o => Assert.True(o.Definition.IsEditorConfigOption)); 188Assert.True(NamingStyleOptions.NamingPreferences.Definition.IsEditorConfigOption); 189Assert.True(CodeStyleOptions2.PreferIntrinsicPredefinedTypeKeywordInMemberAccess.Definition.IsEditorConfigOption);

SemanticModelReuse\SemanticModelReuseTests.cs (20)

SolutionTests\DocumentInfoTests.cs (5)

47Assert.True(info.IsGenerated); 66Assert.True(info.IsGenerated); 78Assert.True(((ImmutableArray<string>)info2.Folders).IsEmpty); 81Assert.True(((ImmutableArray<string>)info3.Folders).IsEmpty); 84Assert.True(((ImmutableArray<string>)info4.Folders).IsEmpty);

SolutionTests\ProjectIdTests.cs (4)

21Assert.True(id1.Equals(id2)); 22Assert.True(id1 == id2); 23Assert.True(id1.GetHashCode() == id2.GetHashCode()); 24Assert.True(id1.Checksum == id2.Checksum);

SolutionTests\ProjectInfoTests.cs (15)

SolutionTests\SolutionInfoTests.cs (3)

38Assert.True(((ImmutableArray<ProjectInfo>)info2.Projects).IsEmpty); 41Assert.True(((ImmutableArray<ProjectInfo>)info3.Projects).IsEmpty); 44Assert.True(((ImmutableArray<ProjectInfo>)info4.Projects).IsEmpty);

SolutionTests\SolutionTests.cs (85)

SolutionTests\SolutionWithSourceGeneratorTests.cs (26)

SolutionTests\SourceGeneratorExecutionVersionMapTests.cs (5)

28Assert.True(map1.Map.SequenceEqual(map2.Map)); 50Assert.True(array1.Length > 0); 52Assert.True(array1.AsSpan().SequenceEqual(array2)); 60Assert.True(rehydrated1.Map.SequenceEqual(rehydrated2.Map)); 61Assert.True(rehydrated1.Map.SequenceEqual(map1.Map));

SolutionTests\TryApplyChangesTests.cs (5)

80Assert.True(workspace.TryApplyChanges(project.WithCompilationOptions(project.CompilationOptions!.WithMainTypeName("Test")).Solution)); 93Assert.True(workspace.TryApplyChanges(project.WithCompilationOptions(project.CompilationOptions!.WithMainTypeName("Test")).Solution)); 123Assert.True(workspace.TryApplyChanges( 138Assert.True( 167Assert.True(workspace.TryApplyChanges(project.AddAnalyzerConfigDocument(".editorconfig", SourceText.From("")).Project.Solution));

SymbolKeyTests.cs (31)

SyntaxPathTests.cs (23)

SyntaxReferenceTests.cs (1)

182Assert.True(node.IsMissing);

UtilityTest\BKTreeTests.cs (6)

33Assert.True(results2.SetEquals(Expected("cart", "what", "water"))); 36Assert.True(results3.SetEquals(Expected("cake", "cape"))); 123Assert.True(results.SetEquals(Expected("hull"))); 126Assert.True(results.SetEquals(Expected("leicester"))); 129Assert.True(results.SetEquals(Expected("leicester"))); 132Assert.True(results.SetEquals(Expected("leicester")));

UtilityTest\CancellationSeriesTests.cs (8)

28Assert.True(token.CanBeCanceled); 41Assert.True(token1.IsCancellationRequested); 46Assert.True(token2.IsCancellationRequested); 70Assert.True(token.IsCancellationRequested); 83Assert.True(token.IsCancellationRequested); 98Assert.True(token.IsCancellationRequested); 113Assert.True(token.IsCancellationRequested); 129Assert.True(token1.IsCancellationRequested);

UtilityTest\DictionaryExtensionsTests.cs (4)

34Assert.True(dictionary.ContainsKey(1)); 52Assert.True(dictionary.ContainsKey(1)); 53Assert.True(dictionary.ContainsKey(2)); 54Assert.True(dictionary.ContainsKey(3));

UtilityTest\DocumentationCommentIdTests.cs (2)

36Assert.True(symbol is TSymbol); 37Assert.True(test((TSymbol)symbol));

UtilityTest\DocumentationCommentTests.cs (2)

107Assert.True(comment.HadXmlParseError); 279Assert.True(comments.HadXmlParseError);

UtilityTest\EditDistanceTests.cs (2)

237Assert.True(editDistance1 >= 0); 291Assert.True(editDistance13 <= editDistance12 + editDistance23);

UtilityTest\ExceptionHelpersTests.cs (1)

50Assert.True(finallyExecuted);

UtilityTest\FormattingRangeHelperTests.cs (3)

21Assert.True(FormattingRangeHelper.AreTwoTokensOnSameLine(token1, token2)); 39Assert.True(FormattingRangeHelper.AreTwoTokensOnSameLine(token, token)); 47Assert.True(FormattingRangeHelper.AreTwoTokensOnSameLine(token, token));

UtilityTest\ImmutableDictionaryExtensionsTests.cs (7)

18Assert.True(empty.KeysEqual(empty)); 22Assert.True(empty.Add(1, 1).KeysEqual(empty.Add(1, 1))); 23Assert.True(empty.Add(1, 2).KeysEqual(empty.Add(1, 1))); 25Assert.True(empty.Add(2, 0).Add(1, 0).KeysEqual(empty.Add(1, 1).Add(2, 1))); 35Assert.True(emptyIgnoreCase.Add("A", 1).KeysEqual(emptyIgnoreCase.Add("a", 1))); 40Assert.True(emptyIgnoreCase.Add("A", 1).KeysEqual(emptyOrdinal.Add("A", 1))); 41Assert.True(emptyOrdinal.Add("A", 1).KeysEqual(emptyIgnoreCase.Add("A", 1)));

UtilityTest\IntervalTreeTests.cs (20)

UtilityTest\NameGeneratorTests.cs (7)

19Assert.True(a.StartsWith("ABC", StringComparison.Ordinal)); 20Assert.True(a.EndsWith(".txt", StringComparison.Ordinal)); 24Assert.True(b.StartsWith("ABC", StringComparison.Ordinal)); 25Assert.True(b.EndsWith(".txt", StringComparison.Ordinal)); 29Assert.True(c.StartsWith("ABC", StringComparison.Ordinal)); 30Assert.True(c.EndsWith(".\u0640.txt", StringComparison.Ordinal)); 101Assert.True(Enumerable.SequenceEqual(expectedResult, namesBuilder));

UtilityTest\ReferenceHolderTests.cs (2)

94Assert.True(x.Equals(y)); 95Assert.True(y.Equals(x));

UtilityTest\SpecializedTasksTests.cs (14)

UtilityTest\SpellCheckerTests.cs (3)

16Assert.True(WordSimilarityChecker.AreSimilar("variabledeclaratorsyntax", "variabledeclaratorsyntaxextensions", substringsAreSimilar: true)); 19Assert.True(WordSimilarityChecker.AreSimilar("expressionsyntax", "expressionsyntaxextensions", substringsAreSimilar: true)); 22Assert.True(WordSimilarityChecker.AreSimilar("expressionsyntax", "expressionsyntaxgeneratorvisitor", substringsAreSimilar: true));

WorkspaceServiceTests\GlobalOptionServiceTests.cs (3)

81Assert.True(workspace1.TryApplyChanges(newSolution1)); 110Assert.True(workspace1.TryApplyChanges(newSolution1)); 229Assert.True(optionSet.GetOption(optionTrue));

WorkspaceServiceTests\ReferenceCountedDisposableTests.cs (4)

40Assert.True(target.IsDisposed); 90Assert.True(target.IsDisposed); 120Assert.True(target.IsDisposed); 183Assert.True(field.FieldType.IsClass);

WorkspaceTests\AdhocWorkspaceTests.cs (20)

170Assert.True(result); 204Assert.True(result); 232Assert.True(doc.TryGetText(out currentText)); 233Assert.True(doc.TryGetTextVersion(out var currentVersion)); 266Assert.True(doc.TryGetText(out currentText)); 267Assert.True(doc.TryGetTextVersion(out var currentVersion)); 305Assert.True(doc.TryGetText(out currentText)); 306Assert.True(doc.TryGetTextVersion(out var currentVersion)); 339Assert.True(doc.TryGetText(out currentText)); 340Assert.True(doc.TryGetTextVersion(out currentVersion)); 354Assert.True(newDoc.TryGetTextVersion(out currentVersion)); 432Assert.True(ws.TryApplyChanges(changedDoc.Project.Solution)); 438Assert.True(tcs.Task.IsCompleted && tcs.Task.Result); 465Assert.True(ws.TryApplyChanges(changedDoc.Project.Solution)); 473Assert.True(tcs.Task.IsCompleted && tcs.Task.Result); 499Assert.True(ws.TryApplyChanges(changedDoc.Project.Solution)); 505Assert.True(tcs.Task.IsCompleted && tcs.Task.Result); 530Assert.True(ws.TryApplyChanges(changedDoc.Project.Solution)); 536Assert.True(tcs.Task.IsCompleted && tcs.Task.Result); 560Assert.True(ws.TryApplyChanges(changedDoc.Project.Solution));

XxHash128Tests.cs (4)

60Assert.True(XxHash128.TryHash(input, destination, out bytesWritten)); 65Assert.True(XxHash128.TryHash(input, destination, out bytesWritten, test.Seed)); 121Assert.True(hash.TryGetCurrentHash(destination, out int bytesWritten)); 123Assert.True(destination.SequenceEqual(destination2));

ExampleTests.cs (1)

57Assert.True(result.Capabilities.SemanticTokensOptions!.Value.Unify().Range!.Value.First);

RequestExecutionQueueTests.cs (2)

151Assert.True(task1.IsCompleted); 152Assert.True(task2.IsCompleted);

ArrayComparer.cs (8)

87Assert.True(expectedArray.NullBitmapBuffer.Span.SequenceEqual(actualArray.NullBitmapBuffer.Span)); 96Assert.True(actualArray.IsValid(i)); 99Assert.True(expectedArray.Values.Slice(0, expectedArray.Length).SequenceEqual(actualArray.Values.Slice(0, actualArray.Length))); 111Assert.True(expectedArray.NullBitmapBuffer.Span.SequenceEqual(actualArray.NullBitmapBuffer.Span)); 113Assert.True(expectedArray.Values.Slice(0, booleanByteCount).SequenceEqual(actualArray.Values.Slice(0, booleanByteCount))); 125Assert.True(expectedArray.NullBitmapBuffer.Span.SequenceEqual(actualArray.NullBitmapBuffer.Span)); 126Assert.True(expectedArray.Values.Slice(0, expectedArray.Length).SequenceEqual(actualArray.Values.Slice(0, actualArray.Length))); 186Assert.True(SchemaComparer.Equals(expectedBatch.Schema, actualBatch.Schema));

ArrowIntegrationTests.cs (1)

168Assert.True(foundARecordBatch);

DataFrame.IOTests.cs (38)

DataFrameColumn.BinaryOperationTests.cs (209)

DataFrameIDataViewTests.cs (5)

252Assert.True(preview.ColumnView[16].Values[0] is VBuffer<int>); 253Assert.True(preview.ColumnView[16].Values[6] is VBuffer<int>); 267Assert.True(df.Columns[i].ElementwiseEquals(newDf.Columns[i]).All()); 279Assert.True(df.Columns["Int"].ElementwiseEquals(newDf.Columns["Int"]).All()); 280Assert.True(df.Columns["Double"].ElementwiseEquals(newDf.Columns["Double"]).All());

DataFrameJoinExtensionsTests.cs (1)

151Assert.True(expected.SequenceEqual(intersection));

DataFrameTests.BinaryOperations.cs (34)

127Assert.True(verify.All()); 133Assert.True(verify.All()); 136Assert.True(verify.All()); 154Assert.True(dtype == typeof(double)); 159Assert.True(dtype == typeof(decimal)); 274Assert.True(newCol.All()); 278Assert.True(newCol.All()); 289Assert.True(newCol.All()); 291Assert.True(newCol.All()); 323Assert.True(newCol.All()); 350Assert.True(newCol.ElementwiseEquals(addString).All()); 369Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 375Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 381Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 387Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 393Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 401Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 407Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 413Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 422Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 428Assert.True(typeof(decimal) == tempDf.Columns["Int"].DataType); 450Assert.True(res.ElementwiseEquals(ints).All()); 451Assert.True(res.ElementwiseGreaterThanOrEqual(ints).All()); 452Assert.True(res.ElementwiseLessThanOrEqual(ints).All()); 459Assert.True(inPlace.ElementwiseEquals(ints).All()); 460Assert.True(inPlace.ElementwiseGreaterThanOrEqual(ints).All()); 461Assert.True(inPlace.ElementwiseLessThanOrEqual(ints).All()); 467Assert.True(inPlace.ElementwiseGreaterThanOrEqual(res).All()); 469Assert.True(inPlace.ElementwiseNotEquals(res).All()); 470Assert.True(inPlace.ElementwiseGreaterThan(res).All()); 476Assert.True(allFalse.ElementwiseEquals(false).All()); 480Assert.True(inPlaceAllFalse.ElementwiseEquals(bools).All()); 484Assert.True(reverse.ElementwiseEquals(ints).All()); 488Assert.True(reverseInPlace.ElementwiseEquals(ints).All());

DataFrameTests.Computations.cs (1)

60Assert.True(any);

DataFrameTests.cs (10)

101Assert.True(object.ReferenceEquals(differentIntColumn, dataFrame.Columns[1])); 105Assert.True(ReferenceEquals(intColumn, dataFrame.Columns[0])); 133Assert.True(ReferenceEquals(intColumn, intColumn_1)); 137Assert.True(ReferenceEquals(originalLastColumn, lastColumn_1)); 195Assert.True(ReferenceEquals(city, renamedColumn)); 214Assert.True(ReferenceEquals(city, renamedColumn)); 223Assert.True(checkOrderColumn.ElementwiseEquals(column).All()); 1370Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); 1387Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); 1388Assert.True(filteredNullDf.Columns.IndexOf("index") >= 0);

DataFrameTests.Filter.cs (3)

57Assert.True(intFilteredColumn.ElementwiseEquals(dfColumn).All()); 58Assert.True(boolFilteredColumn.ElementwiseEquals(dfColumn).All()); 59Assert.True(longFilteredColumn.ElementwiseEquals(dfColumn).All());

PrimitiveDataFrameColumnTests.cs (5)

102Assert.True(dataFrameColumn1.IsValid(i)); 250Assert.True(intColumn.IsValid(2)); 503Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); 520Assert.True(filteredNullDf.Columns.IndexOf("col") >= 0); 521Assert.True(filteredNullDf.Columns.IndexOf("index") >= 0);

TextFieldParserTests.cs (6)

115Assert.True(parser.HasFieldsEnclosedInQuotes); 123Assert.True(parser.TrimWhiteSpace); 144Assert.True(parser.EndOfData); 155Assert.True(parser.EndOfData); 166Assert.True(parser.EndOfData); 170Assert.True(parser.EndOfData);

CalculateAssemblyAndFileVersionsTests.cs (2)

27Assert.True(result); 46Assert.True(result);

GetAssemblyFullNameTests.cs (2)

39Assert.True(result); 66Assert.True(result);

GetLicenseFilePathTests.cs (1)

31Assert.True(result);

GroupItemsByTests.cs (1)

40Assert.True(result);

ValidateLicenseTests.cs (2)

18Assert.True(ValidateLicense.LinesEqual(new[] { "a" }, new[] { "*ignore-line*" })); 20Assert.True(ValidateLicense.LinesEqual(new[] { "a", " ", " b", "xxx", "\t \t" }, new[] { "a", "b ", "*ignore-line*" }));

ProductionChannelValidatorTests.cs (1)

639Assert.True(typeof(IProductionChannelValidatorBuildInfoService).GetMethod(nameof(IProductionChannelValidatorBuildInfoService.GetBuildInfoAsync)) != null);

PublishToSymbolServerTest.cs (4)

33Assert.True(Directory.Exists(path)); 67Assert.True(SymbolPublishVisibility.Public > SymbolPublishVisibility.Internal); 68Assert.True(SymbolPublishVisibility.Internal > SymbolPublishVisibility.None); 70Assert.True(Visibility.Public > Visibility.Internal);

GenerateFileFromTemplateTests.cs (3)

26Assert.True(task.Execute()); 54Assert.True(task.Execute()); 79Assert.True(task.Execute());

OptProf\GenerateTrainingInputFilesTests.cs (1)

220Assert.True(result);

OptProf\GenerateTrainingPropsFileTests.cs (2)

35Assert.True(result); 63Assert.True(result);

OptProf\GetRunSettingsSessionConfigurationTests.cs (1)

444Assert.True(result);

Vsix\GetPkgDefAssemblyDependencyGuidTests.cs (2)

42Assert.True(result); 64Assert.True(result);

CreateVisualStudioWorkloadSetTests.cs (1)

46Assert.True(createWorkloadSetTask.Execute());

CreateVisualStudioWorkloadTests.cs (3)

75Assert.True(result); 153Assert.All(swixComponentProjects, c => Assert.True(c.ItemSpec.Contains(".pre.") && c.GetMetadata(Metadata.IsPreview) == "true" || 211Assert.True(result);

ReplacePackagePartsTests.cs (1)

41Assert.True(result);

OpenApiAddURLTests.cs (11)

39Assert.True(File.Exists(jsonFile)); 72Assert.True(File.Exists(jsonFile)); 105Assert.True(File.Exists(jsonFile)); 138Assert.True(File.Exists(jsonFile)); 170Assert.True(File.Exists(jsonFile)); 203Assert.True(File.Exists(firstJsonFile)); 231Assert.True(File.Exists(secondJsonFile)); 263Assert.True(File.Exists(resultFile)); 295Assert.True(File.Exists(resultFile)); 327Assert.True(File.Exists(resultFile)); 361Assert.True(File.Exists(resultFile));

RemoteExecutorTests.cs (3)

29Assert.True(false); 54Assert.True(false); 67Assert.True(false);

AsyncCollectionAssertsTests.cs (3)

139 item => Assert.True(false) 611 Assert.True(enumerator.IsDisposed); 1077 Assert.True(enumerator.IsDisposed);

BooleanAssertsTests.cs (2)

60 Assert.True(true); 66 var ex = Record.Exception(() => Assert.True(false));

CollectionAssertsTests.cs (3)

137 item => Assert.True(false) 689 Assert.True(enumerator.IsDisposed); 1640 Assert.True(enumerator.IsDisposed);

EqualityAssertsTests.cs (6)

224 Assert.True(obj1.CompareCalled); 319 Assert.True(obj1.CompareCalled); 578 Assert.True(obj1.Equals__Called); 2563 Assert.True(obj1.CompareCalled); 2658 Assert.True(obj1.CompareCalled); 2917 Assert.True(obj1.Equals__Called);

MultipleAssertsTests.cs (5)

16 () => Assert.True(true) 25 () => Assert.True(false) 36 () => Assert.True(true), 46 () => Assert.True(true), 59 () => Assert.True(false),

ConditionalAttributeTests.cs (1)

94Assert.True(s_conditionalFactTrueExecuted);

AdditionalPropertiesDictionaryTests.cs (4)

78Assert.True(d.TryGetValue("key", out T2? value)); 100Assert.True(d.TryAdd("key", "value")); 101Assert.True(d.ContainsKey("key")); 105Assert.True(d.ContainsKey("key"));

ChatCompletion\ChatFinishReasonTests.cs (4)

28Assert.True(new ChatFinishReason("abc").Equals(new ChatFinishReason("ABC"))); 29Assert.True(new ChatFinishReason("abc").Equals((object)new ChatFinishReason("ABC"))); 30Assert.True(new ChatFinishReason("abc") == new ChatFinishReason("ABC")); 39Assert.True(new ChatFinishReason("abc") != new ChatFinishReason("def"));

ChatCompletion\ChatMessageTests.cs (1)

314Assert.True(dataContent.Data.Span.SequenceEqual(new BinaryData(new[] { 1, 2, 3 }, TestJsonSerializerContext.Default.Options)));

ChatCompletion\ChatOptionsTests.cs (1)

197Assert.True(deserialized.AdditionalProperties.TryGetValue("key", out object? value));

ChatCompletion\ChatResponseTests.cs (1)

114Assert.True(result.AdditionalProperties.TryGetValue("key", out object? value));

ChatCompletion\ChatResponseUpdateTests.cs (1)

166Assert.True(result.AdditionalProperties.TryGetValue("key", out object? value));

ChatCompletion\ChatRoleTests.cs (4)

28Assert.True(new ChatRole("abc").Equals(new ChatRole("ABC"))); 29Assert.True(new ChatRole("abc").Equals((object)new ChatRole("ABC"))); 30Assert.True(new ChatRole("abc") == new ChatRole("ABC")); 38Assert.True(new ChatRole("abc") != new ChatRole("def"));

ChatCompletion\ChatToolModeTests.cs (8)

22Assert.True(ChatToolMode.Auto == ChatToolMode.Auto); 23Assert.True(ChatToolMode.Auto.Equals(ChatToolMode.Auto)); 29Assert.True(ChatToolMode.None == ChatToolMode.None); 30Assert.True(ChatToolMode.None.Equals(ChatToolMode.None)); 36Assert.True(ChatToolMode.RequireAny == ChatToolMode.RequireAny); 37Assert.True(ChatToolMode.RequireAny.Equals(ChatToolMode.RequireAny)); 41Assert.True(ChatToolMode.RequireAny.Equals(new RequiredChatToolMode(null))); 45Assert.True(new RequiredChatToolMode("func").Equals(new RequiredChatToolMode("func")));

ChatCompletion\DelegatingChatClientTests.cs (3)

48Assert.True(resultTask.IsCompleted); 83Assert.True(await enumerator.MoveNextAsync()); 85Assert.True(await enumerator.MoveNextAsync());

Contents\DataContentTests.cs (1)

230Assert.True(content.HasTopLevelMediaType(prefix));

Contents\FunctionCallContentTests..cs (4)

275Assert.True(kvp.Value is JsonElement { ValueKind: JsonValueKind.Object }); 285Assert.True(kvp.Value is JsonElement { ValueKind: JsonValueKind.Array }); 290Assert.True(kvp.Value is JsonElement { ValueKind: JsonValueKind.Number }); 295Assert.True(kvp.Value is JsonElement { ValueKind: JsonValueKind.True });

Contents\UriContentTests.cs (1)

115Assert.True(content.HasTopLevelMediaType(prefix));

Embeddings\DelegatingEmbeddingGeneratorTests.cs (1)

47Assert.True(resultTask.IsCompleted);

Embeddings\EmbeddingGenerationOptionsTests.cs (1)

82Assert.True(deserialized.AdditionalProperties.TryGetValue("key", out object? value));

Embeddings\EmbeddingTests.cs (1)

34Assert.True(MemoryMarshal.TryGetArray(e.Vector, out ArraySegment<float> array));

Embeddings\GeneratedEmbeddingsTests.cs (5)

75Assert.True(generatedEmbeddings.Contains(embeddings[0])); 76Assert.True(generatedEmbeddings.Contains(embeddings[1])); 84Assert.True(embeddings.SequenceEqual(generatedEmbeddings)); 166Assert.True(embeddings.Remove(e1)); 174Assert.True(embeddings.Remove(e2));

Functions\AIFunctionArgumentsTests.cs (15)

Image\DelegatingImageGeneratorTests.cs (4)

47Assert.True(resultTask.IsCompleted); 121Assert.True(inner.DisposeInvoked); 131Assert.True(inner.DisposeInvoked); 137Assert.True(inner.DisposeInvoked);

Image\ImageGenerationOptionsTests.cs (1)

122Assert.True(Enum.IsDefined(typeof(ImageGenerationResponseFormat), responseFormat));

Image\ImageGeneratorTests.cs (3)

84Assert.True(generator.DisposeInvoked); 93Assert.True(generator.DisposeInvoked); 99Assert.True(generator.DisposeInvoked);

SpeechToText\DelegatingSpeechToTextClientTests.cs (3)

49Assert.True(resultTask.IsCompleted); 84Assert.True(await enumerator.MoveNextAsync()); 86Assert.True(await enumerator.MoveNextAsync());

SpeechToText\SpeechToTextOptionsTests.cs (1)

80Assert.True(deserialized.AdditionalProperties.TryGetValue("key", out object? value));

SpeechToText\SpeechToTextResponseTests.cs (1)

183Assert.True(result.AdditionalProperties.TryGetValue("key", out object? value));

SpeechToText\SpeechToTextResponseUpdateKindTests.cs (4)

30Assert.True(kind1.Equals(kind2)); 31Assert.True(kind1.Equals((object)kind2)); 32Assert.True(kind1 == kind2); 39Assert.True(kind1 != kind3);

Utilities\AIJsonSchemaTransformCacheTests.cs (2)

53Assert.True(transformedSchema.TryGetProperty("myAwesomeKeyword", out _)); 68Assert.True(transformedSchema.Value.TryGetProperty("myAwesomeKeyword", out _));

Utilities\AIJsonUtilitiesTests.cs (4)

35Assert.True(options.IsReadOnly); 39Assert.True(options.PropertyNameCaseInsensitive); 44Assert.True(options.WriteIndented); 476Assert.True(options.IsReadOnly);

AgentQualityEvaluatorTests.cs (10)

NLPEvaluatorTests.cs (12)

QualityEvaluatorTests.cs (24)

ResultsTests.cs (24)

SafetyEvaluatorTests.cs (51)

BLEUEvaluatorTests.cs (1)

44Assert.True(metric.Interpretation.Failed);

F1EvaluatorTests.cs (1)

44Assert.True(metric.Interpretation.Failed);

GLEUEvaluatorTests.cs (1)

44Assert.True(metric.Interpretation.Failed);

NGramTests.cs (2)

33Assert.True(a.Equals(b)); 34Assert.True(a.Equals((object)b));

RationalNumberTests.cs (2)

49Assert.True(a.Equals(b)); 50Assert.True(a.Equals((object)b));

ResponseCacheTester.cs (14)

ResultStoreTester.cs (7)

90Assert.True(results.All(r => r.executionName == newExecutionName)); 146Assert.True(results.Take(3).All(r => r.executionName == thirdExecutionName)); 147Assert.True(results.Skip(3).Take(3).All(r => r.executionName == secondExecutionName)); 148Assert.True(results.Skip(6).Take(3).All(r => r.executionName == firstExecutionName)); 199Assert.True(results.All(r => r.executionName == executionName1)); 234Assert.True(results.All(r => r.executionName == executionName)); 269Assert.True(results.All(r => r.executionName == executionName));

ScenarioRunResultTests.cs (8)

103Assert.True(entry.Messages.SequenceEqual(deserialized.Messages, ChatMessageComparer.Instance)); 105Assert.True(entry.ChatDetails!.TurnDetails.SequenceEqual(deserialized.ChatDetails!.TurnDetails!, ChatTurnDetailsComparer.Instance)); 106Assert.True(entry.Tags!.SequenceEqual(deserialized.Tags!)); 197Assert.True(entry.Messages.SequenceEqual(deserialized.ScenarioRunResults[0].Messages, ChatMessageComparer.Instance)); 199Assert.True(entry.ChatDetails!.TurnDetails.SequenceEqual(deserialized.ScenarioRunResults[0].ChatDetails!.TurnDetails!, ChatTurnDetailsComparer.Instance)); 200Assert.True(entry.Tags!.SequenceEqual(deserialized.ScenarioRunResults[0].Tags!)); 223Assert.True(defaultJson.Length > compactJson.Length); 279Assert.True(metric.Diagnostics.SequenceEqual(deserializedMetric.Diagnostics, DiagnosticComparer.Instance));

IntentResolutionRatingTests.cs (19)

RelevanceTruthAndCompletenessRatingTests.cs (10)

ChatClientIntegrationTests.cs (9)

124Assert.True(response.Usage?.InputTokenCount > 1); 125Assert.True(response.Usage?.OutputTokenCount > 1); 148Assert.True(chunks.Count > 1); 151Assert.True(usage.Details.InputTokenCount > 1); 152Assert.True(usage.Details.OutputTokenCount > 1); 611Assert.True(callCount >= 1); 632Assert.True(shieldsUp); 952Assert.True(activity.Duration.TotalMilliseconds > 0); 1023Assert.True(response.Result);

EmbeddingGeneratorIntegrationTests.cs (17)

OpenAIAssistantChatClientIntegrationTests.cs (1)

95Assert.True(dr.Value.Deleted);

OpenAIConversionTests.cs (6)

75Assert.True(root.TryGetProperty("properties", out var properties)); 76Assert.True(properties.TryGetProperty("name", out var nameProperty)); 135Assert.True(JsonElement.DeepEquals(JsonSerializer.SerializeToElement(new Dictionary<string, object?> 189Assert.True(JsonElement.DeepEquals(JsonSerializer.SerializeToElement(new Dictionary<string, object?> 490Assert.True(((JsonElement)deserializedArgs["boolean"]!).GetBoolean()); 933Assert.True(openAIResponse.ParallelToolCallsEnabled);

ChatCompletion\ConfigureOptionsChatClientTests.cs (1)

83Assert.True(await e.MoveNextAsync());

ChatCompletion\DependencyInjectionPatterns.cs (2)

149Assert.True(sd.IsKeyedService); 218Assert.True(sd.IsKeyedService);

ChatCompletion\DistributedCachingChatClientTest.cs (5)

26Assert.True(cachingClient.CoalesceStreamingUpdates); 32Assert.True(cachingClient.CoalesceStreamingUpdates); 229Assert.True(result1.IsCanceled); 538Assert.True(result1Assertion.IsCanceled); 839Assert.True(await actualEnumerator.MoveNextAsync());

ChatCompletion\FunctionInvocationContextTests.cs (2)

26Assert.True(ctx.Messages.IsReadOnly); 69Assert.True(ctx.Terminate);

ChatCompletion\FunctionInvokingChatClientTests.cs (6)

ChatCompletion\LoggingChatClientTests.cs (8)

ChatCompletion\OpenTelemetryChatClientTests.cs (1)

179Assert.True(activity.Duration.TotalMilliseconds > 0);

ChatCompletion\ReducingChatClientTests.cs (1)

161Assert.True(configureCalled);

Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (1)

233Assert.True(result1.IsCanceled);

Embeddings\LoggingEmbeddingGeneratorTests.cs (2)

73entry => Assert.True(entry.Message.Contains("GenerateAsync invoked:") && entry.Message.Contains("Blue whale")), 79entry => Assert.True(entry.Message.Contains("GenerateAsync invoked.") && !entry.Message.Contains("Blue whale")),

Embeddings\OpenTelemetryEmbeddingGeneratorTests.cs (1)

96Assert.True(activity.Duration.TotalMilliseconds > 0);

Image\ImageGeneratorDependencyInjectionPatterns.cs (1)

149Assert.True(sd.IsKeyedService);

Image\LoggingImageGeneratorTests.cs (6)

SpeechToText\ConfigureOptionsSpeechToTextClientTests.cs (1)

86Assert.True(await e.MoveNextAsync());

SpeechToText\LoggingSpeechToTextClientTests.cs (10)

SpeechToText\SpeechToTextClientDependencyInjectionPatterns.cs (1)

149Assert.True(sd.IsKeyedService);

CSharpIdentifierTest.cs (1)

26Assert.True(result);

GetCurrentOpenApiReferenceTest.cs (1)

41Assert.True(result);

GetOpenApiReferenceMetadataTest.cs (9)

55Assert.True(result); 115Assert.True(result); 175Assert.True(result); 235Assert.True(result); 292Assert.True(task.Log.HasLoggedErrors); 338Assert.True(task.Log.HasLoggedErrors); 388Assert.True(result); 452Assert.True(result); 550Assert.True(result);

GetDocumentTests.cs (4)

182Assert.True(File.Exists(Path.Combine(outputPath.FullName, $"{fileName}.json"))); 183Assert.True(File.Exists(Path.Combine(outputPath.FullName, $"{fileName}_internal.json"))); 237Assert.True(File.Exists(Path.Combine(outputPath.FullName, "Sample.json"))); 238Assert.True(File.Exists(Path.Combine(outputPath.FullName, "Sample_internal.json")));

AsyncContextTests.cs (2)

100Assert.True(context1.TryGet(out var ctx1)); 107Assert.True(context1.TryGet(out var ctx1));

AsyncStateTokenTests.cs (6)

15Assert.True(t1.Equals(t2)); 16Assert.True((object)t1 != (object)t2); 17Assert.True(t1.Equals((object)t2)); 19Assert.True(t1 == t2); 30Assert.True((object)t1 != (object)t2); 33Assert.True(t1 != t2);

FeaturesPooledPolicyTests.cs (2)

16Assert.True(policy.Return([])); 29Assert.True(policy.Return(list));

BufferReleaseTests.cs (10)

51Assert.True(cache.DebugTryGetCacheItem(key, out var cacheItem)); 55Assert.True(cacheItem.TryReserveBuffer(out _)); 146Assert.True(cache.DebugTryGetCacheItem(key, out var cacheItem)); 150Assert.True(cacheItem.TryReserveBuffer(out _)); 173Assert.True(cacheItem.TryReserveBuffer(out _)); // always readable 209Assert.True(cache.DebugTryGetCacheItem(key, out var cacheItem)); 213Assert.True(cacheItem.TryReserveBuffer(out _)); 250Assert.True(obj.TryGetValue(NullLogger.Instance, out var value)); 263Assert.True(new DefaultJsonSerializerFactory(services).TryCreateSerializer<Customer>(out var serializer)); 279Assert.True(obj.TryGetValue(NullLogger.Instance, out var value));

DistributedCacheTests.cs (17)

76Assert.True(expected.SequenceEqual(actual)); 84Assert.True(expected.SequenceEqual(actual)); 122Assert.True(expected.SequenceEqual(actual)); 130Assert.True(expected.SequenceEqual(actual)); 188Assert.True(cache.TryGet(key, writer)); 189Assert.True(expected.Span.SequenceEqual(writer.GetCommittedMemory().Span)); 196Assert.True(cache.TryGet(key, writer)); 197Assert.True(expected.Span.SequenceEqual(writer.GetCommittedMemory().Span)); 251Assert.True(expected.Span.SequenceEqual(writer.GetCommittedMemory().Span)); 259Assert.True(expected.Span.SequenceEqual(writer.GetCommittedMemory().Span)); 323Assert.True(payload.IsSingleSegment); 324Assert.True(MemoryMarshal.TryGetArray(payload.First, out _)); 330Assert.True(payload.IsSingleSegment); 334Assert.True(payload.IsSingleSegment); 335Assert.True(MemoryMarshal.TryGetArray(payload.First, out var segment)); 342Assert.True(payload.IsSingleSegment); 343Assert.True(MemoryMarshal.TryGetArray(payload.First, out segment));

PayloadTests.cs (13)

SerializerTests.cs (4)

21Assert.True("test value"u8.SequenceEqual(target.GetCommittedMemory().Span)); 35Assert.True("test value"u8.SequenceEqual(target.GetCommittedMemory().Span)); 198Assert.True(clone.TryGetValue("x", out var val)); 200Assert.True(clone.TryGetValue("y", out val));

StampedeTests.cs (2)

250Assert.True(callerCount >= 2); // "most" is not "one" 478Assert.True(pair.Value > 16);

TagSetTests.cs (1)

14Assert.True(tags.IsEmpty);

TypeTests.cs (1)

22Assert.True((bool)typeof(ImmutableTypeCache<>).MakeGenericType(type)

Classification\DataClassificationAttributeTests.cs (1)

26Assert.True(attribute.Classification == new DataClassification(TaxonomyName, Value));

Classification\DataClassificationTests.cs (4)

20Assert.True(dc == new DataClassification(TaxonomyName, Value)); 23Assert.True(dc != new DataClassification(TaxonomyName + "x", Value)); 26Assert.True(dc != new DataClassification(TaxonomyName, Value + 1)); 29Assert.True(dc.Equals((object)dc));

Redaction\RedactorTest.cs (3)

23Assert.True(r.TryRedact<object?>(null, new char[0], out _, string.Empty.AsSpan())); 298Assert.True(r.TryRedact(Array.Empty<char>(), buffer, out int charsWritten, string.Empty.AsSpan(), null)); 314Assert.True(r.TryRedact(new char[0], buffer, out int charsWritten, string.Empty.AsSpan(), null));

HmacRedactorExtensionsTests.cs (2)

67Assert.True(expectedLength == 0 || expectedLength == Example.Length); 68Assert.True(actualLength == 0 || actualLength == Example.Length);

RedactionFakesEventCollectorTests.cs (10)

40Assert.True(first.Equals(second)); 43Assert.True(first.Equals((object)second)); 44Assert.True(first == second); 45Assert.True(first != third); 46Assert.True(first != fifth); 61Assert.True(first.Equals(second)); 64Assert.True(first.Equals((object)second)); 65Assert.True(first == second); 66Assert.True(first != third); 67Assert.True(first == fourth);

ConfigurationProviderTestBase.cs (1)

124Assert.True(caught is ArgumentException

ApplicationLifecycleHealthChecksExtensionsTests.cs (1)

61Assert.True(r.Factory(serviceProvider) is T);

DefaultHealthCheckServiceTest.cs (3)

455Assert.True(healthCheck.SynchronousDisposable.IsDisposed); 456Assert.True(healthCheck.AsyncOnlyDisposable.IsAsyncDisposed); 457Assert.True(healthCheck.SyncOrAsyncDisposable.IsAsyncDisposed);

HealthCheckPublisherHostedServiceTest.cs (18)

KubernetesProbesExtensionsTests.cs (3)

49Assert.True(livenessConfig.FilterChecks!(livenessRegistration)); 56Assert.True(startupConfig.FilterChecks(startupRegistration)); 63Assert.True(readinessConfig.FilterChecks(readinessRegistration));

KubernetesProbesOptionsValidatorTests.cs (6)

21Assert.True(result.Succeeded); 34Assert.True(result.Succeeded); 47Assert.True(result.Failed); 53Assert.True(result.Failed); 59Assert.True(result.Failed); 65Assert.True(result.Failed);

TcpEndpointProbesServiceTests.cs (3)

45Assert.True(IsTcpOpened(port)); 49Assert.True(IsTcpOpened(port)); 63Assert.True(IsTcpOpened(port));

ByteArrayEqualityComparerTests.cs (2)

15Assert.True(_comparer.Equals(null, null)); 47Assert.True(_comparer.Equals(x, y));

Linux\AcceptanceTest.cs (2)

261Assert.True(double.IsNaN(cpuFromGauge)); 365Assert.True(double.IsNaN(cpuFromGauge));

Linux\LinuxUtilizationParserCgroupV1Tests.cs (1)

396Assert.True(true);

Linux\LinuxUtilizationParserCgroupV2Tests.cs (1)

595Assert.True(true);

Linux\LinuxUtilizationProviderTests.cs (8)

Linux\OSFileSystemTests.cs (2)

67Assert.True(length >= written); 68Assert.True(b.AsSpan(0, written).SequenceEqual(new string(Content, written).AsSpan()));

ResourceMonitoringExtensionsTests.cs (1)

254Assert.True(delegateCalled);

ResourceMonitoringOptionsCustomValidatorTests.cs (4)

27Assert.True(result.Failed); 40Assert.True(result.Succeeded); 56Assert.True(isValid); 71Assert.True(validationResult.Failed);

ResourceMonitoringOptionsTests.cs (1)

33Assert.True(options.UseLinuxCalculationV2);

ResourceMonitoringOptionsValidatorTests.cs (4)

26Assert.True(isValid); 41Assert.True(validator.Validate(nameof(options), options).Failed); 56Assert.True(validator.Validate(nameof(options), options).Failed); 71Assert.True(validator.Validate(nameof(options), options).Failed);

ResourceMonitoringServiceTests.cs (1)

345Assert.True(publisherCalled);

Windows\MemoryInfoTests.cs (1)

22Assert.True(memoryStatus.TotalPhys > 0);

Windows\ProcessInfoTests.cs (1)

21Assert.True(workingSet64 > 0);

Windows\SystemInfoTests.cs (1)

25Assert.True(sysInfo.NumberOfProcessors > 0);

Windows\WindowsContainerSnapshotProviderTests.cs (4)

131Assert.True(data.MemoryUsageInBytes > 0); 158Assert.True(data.MemoryUsageInBytes > 0); 190Assert.True(data.MemoryUsageInBytes > 0); 300Assert.True(double.IsNaN(metricCollector.LastMeasurement.Value));

Windows\WindowsSnapshotProviderTests.cs (1)

100Assert.True(double.IsNaN(metricCollector.LastMeasurement.Value));

Logging\FakeLogCollectorOptionsTests.cs (1)

17Assert.True(options.CollectRecordsForDisabledLogLevels);

Logging\FakeLoggerTests.cs (17)

Metrics\MeasurementExtensionsTests.cs (8)

32Assert.True(filtered[1].Tags.ContainsKey("A")); 33Assert.True(filtered[1].Tags.ContainsKey("B")); 57Assert.True(filtered[1].Tags.ContainsKey("A")); 58Assert.True(filtered[1].Tags.ContainsKey("B")); 82Assert.True(filtered[1].Tags.ContainsKey("A")); 83Assert.True(filtered[1].Tags.ContainsKey("B")); 110Assert.True(filtered[1].Tags.ContainsKey("A")); 111Assert.True(filtered[1].Tags.ContainsKey("B"));

Metrics\MetricCollectorTests.cs (4)

259Assert.True(wait.IsCompleted); 266Assert.True(wait.IsCompleted); 373Assert.True(wait.IsCompleted); 374Assert.True(wait.IsFaulted);

EmbeddedFileProviderTests.cs (8)

50Assert.True(fileInfo.Exists); 116Assert.True(fileInfo.Exists); 118Assert.True(fileInfo.Length > 0); 154Assert.True(fileInfo.Exists); 156Assert.True(fileInfo.Length > 0); 192Assert.True(fileInfo.Exists); 194Assert.True(fileInfo.Length > 0); 233Assert.True(files.Exists);

ManifestEmbeddedFileProviderTests.cs (9)

29Assert.True(jqueryValidate.Exists); 36Assert.True(jqueryMin.Exists); 43Assert.True(siteCss.Exists); 66Assert.True(jqueryValidate.Exists); 73Assert.True(jqueryMin.Exists); 80Assert.True(siteCss.Exists); 165Assert.True(jqueryValidate.Exists); 188Assert.True(jqueryValidate.Exists); 439Assert.True(jqueryValidate.Exists);

FakeHostTests.cs (2)

92Assert.True(receivedToken.IsCancellationRequested); 152Assert.True(receivedToken.IsCancellationRequested);

Latency\HttpClientLatencyTelemetryExtensionsTest.cs (2)

51Assert.True(options.EnableDetailedLatencyBreakdown); 86Assert.True(invoked);

Latency\Internal\HttpCheckpointsTest.cs (1)

15Assert.True(HttpCheckpoints.Checkpoints.Length > 0);

Latency\Internal\HttpLatencyTelemetryHandlerTest.cs (1)

71Assert.True(req.Headers.Contains(TelemetryConstants.ClientApplicationNameHeader));

Latency\Internal\HttpRequestLatencyListenerTest.cs (3)

104Assert.True(esSockets.IsEnabled()); 109Assert.True(esHttp.IsEnabled()); 114Assert.True(esNameRes.IsEnabled());

DependencyInjection\PollyHttpClientBuilderExtensionsTest.cs (4)

371Assert.True(registry.ContainsKey("host1")); 380Assert.True(registry.ContainsKey("host1")); 390Assert.True(registry.ContainsKey("host1")); 391Assert.True(registry.ContainsKey("host2"));

PolicyHttpMessageHandlerTest.cs (3)

147Assert.True(fakeContent.Disposed); 199Assert.True(fakeContent.Disposed); 245Assert.True(ct.CanBeCanceled);

Hedging\HttpClientHedgingResiliencePredicatesTests.cs (6)

20Assert.True(HttpClientHedgingResiliencePredicates.IsTransientHttpException(new TimeoutRejectedException())); 21Assert.True(HttpClientHedgingResiliencePredicates.IsTransientHttpException(new BrokenCircuitException())); 22Assert.True(HttpClientHedgingResiliencePredicates.IsTransientHttpException(new HttpRequestException())); 29Assert.True(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new TimeoutRejectedException()))); 30Assert.True(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new BrokenCircuitException()))); 31Assert.True(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new HttpRequestException())));

Hedging\HttpStandardHedgingResilienceOptionsCustomValidatorTests.cs (2)

24Assert.True(validationResult.Failed); 103Assert.True(validationResult.Failed);

Internal\RandomizerTest.cs (1)

47Assert.True(ok);

Polly\HttpRetryStrategyOptionsExtensionsTests.cs (1)

90Assert.True(await options.ShouldHandle(CreatePredicateArguments(response, context)));

Resilience\HttpResilienceContextExtensionsTests.cs (2)

63Assert.True(context.Properties.TryGetValue(ResilienceKeys.RequestMessage, out HttpRequestMessage? request)); 74Assert.True(context.Properties.TryGetValue(ResilienceKeys.RequestMessage, out HttpRequestMessage? actualRequest));

Resilience\HttpStandardResilienceOptionsCustomValidatorTests.cs (3)

30Assert.True(validationResult.Failed); 44Assert.True(validationResult.Succeeded); 104Assert.True(validationResult.Failed);

Routing\RoutingStrategyTest.cs (1)

53Assert.True(strategies.Count < 5);

FileLoaderTests.cs (1)

55Assert.True(prediction.Sentiment);

DependencyInjectionExtensionsTests.cs (1)

109Assert.True(pooled is OtherTestClass);

DisposableObjectPoolTest.cs (4)

72Assert.True(obj.IsDisposed); 89Assert.True(obj1.IsDisposed); 90Assert.True(obj2.IsDisposed); 122Assert.True(obj.IsDisposed);

InitCommandTest.cs (1)

113Assert.True(lineCountWithSecret == lineCountWithoutSecret + 1);

SetCommandTest.cs (1)

69Assert.True(secretStore.ContainsKey("Key1:nested"));

Latency\CheckpointTests.cs (4)

28Assert.True(c1.Equals(c2)); 29Assert.True(c1.Equals((object)c2)); 33Assert.True(c1 == c2); 36Assert.True(c1.GetHashCode() == c2.GetHashCode());

Latency\LatencyDataTests.cs (9)

15Assert.True(ld.Checkpoints.Length == 0); 16Assert.True(ld.Measures.Length == 0); 17Assert.True(ld.Tags.Length == 0); 31Assert.True(ld.Checkpoints.Length == num); 32Assert.True(ld.Measures.Length == num); 33Assert.True(ld.Tags.Length == num); 50Assert.True(ld.Checkpoints.Length == numCheckpoints); 51Assert.True(ld.Measures.Length == numMeasures); 52Assert.True(ld.Tags.Length == numTags);

Latency\LatencyRegistryExtensionsTests.cs (3)

80Assert.True(lcro.CheckpointNames.Count == 1); 81Assert.True(lcro.MeasureNames.Count == 2); 82Assert.True(lcro.TagNames.Count == 3);

Latency\MeasureTests.cs (4)

29Assert.True(m1.Equals(m2)); 30Assert.True(m1.Equals((object)m2)); 34Assert.True(m1 == m2); 36Assert.True(m1.GetHashCode() == m2.GetHashCode());

Latency\NoopLatencyContextTests.cs (3)

73Assert.True(latencyData.Checkpoints.Length == 0); 74Assert.True(latencyData.Measures.Length == 0); 75Assert.True(latencyData.Tags.Length == 0);

Logging\LogPropertiesAttributeTests.cs (3)

17Assert.True(lpa.SkipNullProperties); 27Assert.True(lpa.OmitReferenceName); 37Assert.True(lpa.Transitive);

Logging\TagProviderAttributeTests.cs (1)

20Assert.True(attr.OmitReferenceName);

Enrichment\ApplicationEnricherExtensionsTests.cs (3)

90Assert.True(options.ApplicationName); 92Assert.True(options.BuildVersion); 93Assert.True(options.DeploymentRing);

Enrichment\ProcessEnricherExtensionsTests.cs (1)

88Assert.True(options.ProcessId);

Enrichment\ProcessLogEnricherTests.cs (1)

37Assert.True(options.ProcessId);

Http\HttpParserTests.cs (14)

165Assert.True(success); 183Assert.True(success); 203Assert.True(success); 236Assert.True(success); 255Assert.True(success); 266Assert.True(success); 292Assert.True(success); 304Assert.True(success); 317Assert.True(success); 332Assert.True(success); 363Assert.True(success); 374Assert.True(success); 420Assert.True(success); 465Assert.True(success);

Latency\Internal\CheckpointTrackerTests.cs (11)

19Assert.True(ct.Checkpoints.Count == 0); 35Assert.True(c.Count == names.Length); 42Assert.True(c[i].Name == names[i]); 43Assert.True(elapsed >= t); 58Assert.True(checkpoints.Count == 1); 59Assert.True(first.Name == checkpoints[0].Name); 60Assert.True(first.Elapsed == checkpoints[0].Elapsed); 61Assert.True(first.Frequency == checkpoints[0].Frequency); 76Assert.True(c.Count == names.Length); 80Assert.True(c.Count == 0); 88Assert.True(c.Count == names.Length);

Latency\Internal\LatencyContextPoolTests.cs (2)

64Assert.True(o.ResetCalled == 1); 67Assert.True(o.ResetCalled == 1);

Latency\Internal\LatencyContextProviderTests.cs (6)

60Assert.True(lc.LatencyData.Checkpoints.Length == 1); 61Assert.True(lc.LatencyData.Measures.Length == 1); 62Assert.True(lc.LatencyData.Tags.Length == 1); 91Assert.True(lc.LatencyData.Checkpoints.Length == 1); 92Assert.True(lc.LatencyData.Measures.Length == 1); 93Assert.True(lc.LatencyData.Tags.Length == 1);

Latency\Internal\LatencyContextRegistrySetTests.cs (10)

25Assert.True(lcrs.CheckpointNameRegistry.KeyCount == 0); 26Assert.True(lcrs.MeasureNameRegistry.KeyCount == 0); 27Assert.True(lcrs.TagNameRegistry.KeyCount == 0); 68Assert.True(lcr.CheckpointNameRegistry.IsRegistered("ca")); 69Assert.True(lcr.CheckpointNameRegistry.KeyCount == 2); 70Assert.True(lcr.MeasureNameRegistry.IsRegistered("ma")); 71Assert.True(lcr.MeasureNameRegistry.KeyCount == 2); 72Assert.True(lcr.TagNameRegistry.IsRegistered("ta")); 73Assert.True(lcr.TagNameRegistry.KeyCount == 2); 78Assert.True(registry.IsRegistered(registered));

Latency\Internal\LatencyContextTests.cs (9)

25Assert.True(latencyContext.IsRunning); 37Assert.True(latencyContext.IsDisposed); 68Assert.True(latencyContext.IsDisposed); 69Assert.True(pool.ReturnCalled); 119Assert.True(((LatencyContext)context).IsRunning); 145Assert.True(((LatencyContext)context).IsRunning); 203Assert.True(((LatencyContext)context).IsRunning); 231Assert.True(afterFreezeDuration.Equals(afterDelayDuration)); 280Assert.True(((LatencyContext)context).IsRunning);

Latency\Internal\LatencyContextTokenIssuerTests.cs (6)

25Assert.True(ct.Position > -1); 29Assert.True(mt.Position > -1); 33Assert.True(tt.Position > -1); 44Assert.True(ct.Position == -1); 48Assert.True(mt.Position == -1); 52Assert.True(tt.Position == -1);

Latency\Internal\MeasureTrackerTests.cs (25)

Latency\Internal\RegistryTests.cs (6)

37Assert.True(r.KeyCount == 0); 59Assert.True(ok.Length == 4); 66Assert.True(o == i); 76Assert.True(ok.Length == 4); 86Assert.True(ok.Length == 4); 88Assert.True(r.GetRegisteredKeyIndex("e") == -1);

Latency\Internal\TagCollectionTests.cs (15)

22Assert.True(tc.Tags.Count == 4); 23tc.Tags.ToList().ForEach(t => Assert.True(t.Name != "e")); 43Assert.True(t.Count == _tagNames.KeyCount); 48Assert.True(_tagNames.GetRegisteredKeyIndex(tagName) > -1); 52Assert.True(namesNumTimes[tagName] == 0); 53Assert.True(t[i].Value == "testVal"); 59Assert.True(t[i].Value == string.Empty); 70Assert.True(tc.Tags.Count == _tagNames.KeyCount); 75Assert.True(atag.Count == 1); 76Assert.True(atag[0].Name == "a"); 77Assert.True(atag[0].Value == "second"); 81Assert.True(notaTag.Count == tagList.Count - 1); 83Assert.True(notaTagEmptyValues.Count == notaTag.Count); 94Assert.True(numNonEmpty == 2); 98Assert.True(numNonEmpty == 0);

Latency\LatencyConsoleExtensionsTests.cs (2)

47Assert.True(invoked); 64Assert.True(actualOptions.Value.OutputTags);

Latency\LatencyConsoleOptionsTests.cs (3)

14Assert.True(o.OutputCheckpoints); 15Assert.True(o.OutputTags); 16Assert.True(o.OutputMeasures);

Latency\LatencyContextExtensionTests.cs (3)

82Assert.True(invoked); 100Assert.True(actualOptions.Value.ThrowOnUnregisteredNames == expectedOptions.ThrowOnUnregisteredNames); 110Assert.True(l.ThrowOnUnregisteredNames);

Logging\ExtendedLoggerFactoryTests.cs (2)

55Assert.True(true); 537Assert.True(disposed);

Logging\JustInTimeRedactorTests.cs (2)

46Assert.True(r.TryFormat(d, out int charsWritten, string.Empty.AsSpan(), CultureInfo.InvariantCulture)); 70Assert.True(r.TryFormat(d, out charsWritten, string.Empty.AsSpan(), CultureInfo.InvariantCulture));

Logging\LoggerEnrichmentOptionsTests.cs (2)

25Assert.True(o.CaptureStackTraces); 26Assert.True(o.UseFileInfoForStackTraces);

Sampling\RandomProbabilisticSamplerTests.cs (1)

55Assert.True(actualDecision);

Sampling\TraceBasedSamplerTests.cs (2)

32Assert.True(shouldSample); 51Assert.True(shouldSample);

FakeTimeProviderTests.cs (7)

134Assert.True(pnow2 > pnow); 295Assert.True(t.IsCompleted && !t.IsFaulted); 307Assert.True(delay.IsCompleted); 383Assert.True(t.IsCompleted); 403Assert.True(t.IsCompleted); 421Assert.True(t.IsCompleted); 422Assert.True(t.IsFaulted);

TimerTests.cs (3)

165Assert.True(t.Change(TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(1))); 176Assert.True(t.Change(TimeSpan.FromMilliseconds(1), TimeSpan.FromMilliseconds(1))); 349Assert.True(triggers[j]);

ValidationsGenerator.ClassAttributes.cs (1)

86Assert.True(validationOptions.TryGetValidatableTypeInfo(type, out var validatableTypeInfo));

ValidationsGenerator.SkipValidation.cs (2)

106Assert.True(validationOptions.TryGetValidatableTypeInfo(type, out var validatableTypeInfo)); 325Assert.True(validationOptions.TryGetValidatableTypeInfo(type, out var validatableTypeInfo));

ValidationsGenerator.ValidatableType.cs (2)

85Assert.True(validationOptions.TryGetValidatableTypeInfo(type, out var validatableTypeInfo)); 454Assert.True(validationOptions.TryGetValidatableTypeInfo(type, out var validatableTypeInfo));

ValidationsGeneratorTestBase.cs (1)

152Assert.True(result.Success);

RuntimeValidatableParameterInfoResolverTests.cs (5)

67Assert.True(result); 83Assert.True(result); 99Assert.True(result); 115Assert.True(result); 140Assert.True(result);

ValidatableInfoResolverTests.cs (3)

57Assert.True(result); 106Assert.True(result); 156Assert.True(result);

GeneratorTests.cs (1)

156Assert.True(File.Exists(Path.Combine(fullReportPath, "ComplianceReport.json")));