True

Options\SymbolNamesWithValueOptionTests.cs (14)

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)

170Assert.True(response2.IsSuccessStatusCode); 187Assert.True(response2.IsSuccessStatusCode); 238Assert.True(response.IsSuccessStatusCode); 299Assert.True(response.IsSuccessStatusCode); 323Assert.True(response.IsSuccessStatusCode); 354Assert.True(headerOrResetFrame.Type == Http2FrameType.HEADERS || headerOrResetFrame.Type == Http2FrameType.RST_STREAM);

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

144Assert.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)

348Assert.True(logContents.Contains("[aspnetcorev2_inprocess.dll]") || logContents.Contains("[aspnetcorev2_outofprocess.dll]")); 366Assert.True(DateTime.UtcNow > time); 368Assert.True(DateTime.UtcNow.AddHours(-2) < time);

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

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

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

400Assert.True(response.IsSuccessStatusCode); 403Assert.True(response2.IsSuccessStatusCode); 530Assert.True(response.Headers.TryGetValues("UnknownHeader", out var headerValues)); 533Assert.True(response.Content.Headers.TryGetValues(Net.Http.Headers.HeaderNames.ContentType, out headerValues)); 536Assert.True(response.Headers.TryGetValues("MultiHeader", out headerValues));

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

68Assert.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)

214Assert.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)

29Assert.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)

214Assert.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)

214Assert.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)

294Assert.True(!task.IsCompleted);

MaxRequestBodySizeTests.cs (1)

249Assert.True(feature.IsReadOnly);

ResponseAbortTests.cs (3)

144Assert.True(tokenAborted); 157Assert.True(token.WaitHandle.WaitOne(10000)); 158Assert.True(ctx.RequestAborted.WaitHandle.WaitOne(10000));

InProcess\AppOfflineIISExpressTests.cs (1)

65Assert.True(false);

InProcess\IISExpressShutdownTests.cs (2)

87Assert.True(result.HostProcess.ExitCode == 0); 99Assert.True(result.HostProcess.ExitCode == 1);

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

144Assert.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)

348Assert.True(logContents.Contains("[aspnetcorev2_inprocess.dll]") || logContents.Contains("[aspnetcorev2_outofprocess.dll]")); 366Assert.True(DateTime.UtcNow > time); 368Assert.True(DateTime.UtcNow.AddHours(-2) < time);

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

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

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

400Assert.True(response.IsSuccessStatusCode); 403Assert.True(response2.IsSuccessStatusCode); 530Assert.True(response.Headers.TryGetValues("UnknownHeader", out var headerValues)); 533Assert.True(response.Content.Headers.TryGetValues(Net.Http.Headers.HeaderNames.ContentType, out headerValues)); 536Assert.True(response.Headers.TryGetValues("MultiHeader", out headerValues));

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

214Assert.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);

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.cs (5)

367Assert.True(IPAddress.IsLoopback(ctx.Connection.LocalIpAddress)); 371Assert.True(IPAddress.IsLoopback(ctx.Connection.RemoteIpAddress)); 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"));

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.WebSockets.cs (1)

40Assert.True(upgradeFeature.IsUpgradableRequest);

InteractiveHostCoreTests.cs (2)

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

InteractiveHostDesktopInitTests.cs (2)

76Assert.True(result); 83Assert.True(result);

InteractiveHostDesktopTests.cs (28)

116Assert.True(mayTerminate.WaitOne()); 123Assert.True(execution); 164Assert.True(mayTerminate.WaitOne()); 194Assert.True(execution); 290Assert.True(mayTerminate.WaitOne()); 293Assert.True(await Execute(@"1+1")); 304Assert.True(await LoadReference(Path.Combine(fxDir, "System.Data.dll"))); 305Assert.True(await Execute("new System.Data.DataSet()")); 312Assert.True(await LoadReference("System.Data")); 313Assert.True(await Execute("new System.Data.DataSet()")); 320Assert.True(await LoadReference("System.Data")); 321Assert.True(await LoadReference("System")); 322Assert.True(await LoadReference("System.Xml")); 332Assert.True(await LoadReference("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")); 333Assert.True(await Execute("new System.Data.DataSet()")); 345Assert.True(result); 352Assert.True(result); 359Assert.True(result); 373Assert.True(await LoadReference(c.Path)); 374Assert.True(await Execute("new C()")); 386Assert.True(result); 441Assert.True(await LoadReference(main.Path)); 442Assert.True(await Execute("Program.Main()")); 463Assert.True(await LoadReference(file1.Path)); 464Assert.True(await LoadReference(file2.Path)); 469Assert.True(await LoadReference(main.Path)); 470Assert.True(await Execute("Program.Main()")); 979Assert.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); 935Assert.True(request2Headers.ContainsKey("alt-used")); 951Assert.True(request3Headers.ContainsKey("alt-used")); 1196Assert.True(memoryPool.ContainsMemory(memory)); 1615Assert.True(hasWriteLog); 1620Assert.True(hasReadLog); 2200Assert.True(ranHandler);

Http3\Http3TlsTests.cs (5)

67Assert.True(serverCertificateSelectorActionCalled); 249Assert.True(response.IsSuccessStatusCode); 470Assert.True(ranConfigureKestrelAction); 471Assert.True(ranUseHttpsAction); 498Assert.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)

272Assert.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)

42Assert.True(Certificates.SelfSignedValidWithNoEku.IsSelfSigned()); 310Assert.True(failCalled);

CookieTests.cs (5)

146Assert.True(transaction.Response.Headers.CacheControl.NoCache); 147Assert.True(transaction.Response.Headers.CacheControl.NoStore); 279Assert.True(transaction.Response.Headers.CacheControl.NoCache); 280Assert.True(transaction.Response.Headers.CacheControl.NoStore); 1066Assert.True(c.Principal.Identities.First().HasClaim("marker", "true"));

GoogleTests.cs (7)

63Assert.True(queryParams.ContainsKey("redirect_uri")); 64Assert.True(queryParams.ContainsKey("scope")); 65Assert.True(queryParams.ContainsKey("state")); 66Assert.True(queryParams.ContainsKey("code_challenge")); 354Assert.True(result.None); 482Assert.True(accessDeniedCalled); 483Assert.True(remoteFailureCalled);

JwtBearerTests.cs (3)

127Assert.True(options.MapInboundClaims); 133Assert.True(jwtHandler.MapInboundClaims); 137Assert.True(tokenHandler.MapInboundClaims);

JwtBearerTests_Handler.cs (10)

117Assert.True(options.MapInboundClaims); 123Assert.True(jwtHandler.MapInboundClaims); 127Assert.True(tokenHandler.MapInboundClaims); 987Assert.True(jwtBearerOptions.SaveToken); 989Assert.True(jwtBearerOptions.TokenValidationParameters.ValidateIssuerSigningKey); 991Assert.True(jwtBearerOptions.MapInboundClaims); 992Assert.True(jwtBearerOptions.TokenValidationParameters.ValidateIssuer); 993Assert.True(jwtBearerOptions.TokenValidationParameters.ValidateAudience); 1070Assert.True(jwtBearerOptions.TokenValidationParameters.ValidateIssuer); 1071Assert.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)

247Assert.True(query.TryGetValue("post_logout_redirect_uri", out redirectUri)); 251Assert.True(query.TryGetValue("state", out state)); 278Assert.True(query.TryGetValue("post_logout_redirect_uri", out redirectUri)); 282Assert.True(query.TryGetValue("state", out state)); 376Assert.True(options.MapInboundClaims); 381Assert.True(jwtHandler.MapInboundClaims); 482Assert.True(options.CorrelationCookie.HttpOnly); 485Assert.True(options.NonceCookie.IsEssential); 486Assert.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)

212Assert.True(transaction.Response.Headers.TryGetValues(HeaderNames.SetCookie, out var setCookie)); 213Assert.True(SetCookieHeaderValue.TryParseList(setCookie.ToList(), out var setCookieValues)); 262Assert.True(transaction.Response.Headers.TryGetValues(HeaderNames.SetCookie, out var setCookie)); 263Assert.True(SetCookieHeaderValue.TryParseList(setCookie.ToList(), out var setCookieValues)); 369Assert.True(transaction.Response.Headers.TryGetValues(HeaderNames.SetCookie, out var setCookie)); 370Assert.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["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 (7)

18Assert.True(result); 43Assert.True(result); 61Assert.True(result); 102Assert.True(result); 142Assert.True(result); 166Assert.True(result); 190Assert.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\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);

Circuits\CircuitActivitySourceTest.cs (3)

55Assert.True(activity.IsAllDataRequested); 61Assert.True(activity.IsStopped); 82Assert.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); 1008Assert.True(task.IsCompletedSuccessfully); 1051Assert.True(task.IsCompletedSuccessfully);

Circuits\CircuitMetricsTest.cs (3)

121Assert.True(durationMeasurements[0].Value > 0); 135Assert.True(circuitMetrics.IsDurationEnabled()); 189Assert.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)

169Assert.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 (16)

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)

ParameterViewTest.cs (5)

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

PersistentState\ComponentApplicationStateTest.cs (7)

24Assert.True(applicationState.TryTakeFromJson<byte[]>("MyState", out var existing)); 72Assert.True(applicationState.TryTakeFromJson<byte[]>("MyState", out var existing)); 92Assert.True(currentState.TryGetValue("MyState", out var stored)); 128Assert.True(currentState.TryGetValue("MyState", out var stored)); 146Assert.True(currentState.TryGetValue("MyState", out var stored)); 162Assert.True(applicationState.TryTakeFromJson<byte[]>("MyState", out var stored)); 180Assert.True(applicationState.TryTakeFromJson<byte[]>("MyState", out var stored));

PersistentState\ComponentStatePersistenceManagerTest.cs (6)

57Assert.True(persistenceManager.State.TryTakeFromJson<byte[]>("MyState", out var retrieved)); 128Assert.True(testStore.State.TryGetValue(typeof(PersistentServicesRegistry).FullName, out var registrations)); 157Assert.True(store.State.TryGetValue("MyState", out var persisted)); 180Assert.True(invoked); 269Assert.True(invoked); 300Assert.True(invoked);

RendererTest.cs (45)

Rendering\RendererSynchronizationContextTest.cs (2)

361Assert.True(e3.IsSet); 368Assert.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)

53Assert.True(called); 111Assert.True(true); 164Assert.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);

SupplyParameterFromPersistentComponentStateValueProviderTests.cs (10)

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); 134Assert.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 (11)

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)

140Assert.True(logWritten);

ConverterTests\JsonConverterReadTests.cs (1)

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

ConverterTests\JsonConverterWriteTests.cs (1)

550Assert.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);

ParserTests.cs (20)

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 (21)

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); 444Assert.True(context.MetricsTagsFeature.MetricsDisabled); 563Assert.True(isEnabledActivityFired); 600Assert.True(isEnabledActivityFired); 601Assert.True(isEnabledStartFired); 627Assert.True(startCalled); 644Assert.True(Activity.Current.Duration > TimeSpan.Zero); 652Assert.True(endCalled); 668Assert.True(Activity.Current.Duration > TimeSpan.Zero); 676Assert.True(endCalled); 698Assert.True(endCalled); 1013Assert.True(onActivityImportCalled); 1015Assert.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)

262Assert.True(configurationCallbackCalled); 442Assert.True(service.Disposed); 683Assert.True(Path.IsPathRooted(basePath)); 686Assert.True(Path.IsPathRooted(basePath2)); 995Assert.True(disposables[0].Disposed); 996Assert.True(disposables[1].Disposed); 1391Assert.True(service.StopCalled);

WebHostConfigurationsTests.cs (3)

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

WebHostTests.AsyncDisposable.cs (1)

39Assert.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 (15)

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)

793Assert.True(context.TryDisable(HttpLoggingFields.RequestPath)); 1276Assert.True(TestSink.Writes.TryTake(out var contentTypeLog)); 1279Assert.True(TestSink.Writes.TryTake(out var requestLog)); 1486Assert.True(upgradeFeature is UpgradeFeatureLoggingDecorator); 1702Assert.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")); 181Assert.True(context.Request.Headers.ContainsKey("X-Original-For")); 380Assert.True(assertsExecuted); 465Assert.True(assertsExecuted); 515Assert.True(assertsExecuted); 566Assert.True(assertsExecuted); 602Assert.True(assertsExecuted); 692Assert.True(assertsExecuted); 749Assert.True(assertsExecuted); 889Assert.True(options.ForwardedHeaders == ForwardedHeaders.None); 1313Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Prefix")); 1363Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-For")); 1364Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Host")); 1365Assert.True(context.Request.Headers.ContainsKey("X-Forwarded-Proto")); 1366Assert.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)

26Assert.True(network.Contains(IPAddress.Parse(addressText))); 117Assert.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)

53Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUsers", "Id", "UserName", "Email", "PasswordHash", "SecurityStamp", 56Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetRoles", "Id", "Name", "NormalizedName", "ConcurrencyStamp")); 57Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserRoles", "UserId", "RoleId")); 58Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserClaims", "Id", "UserId", "ClaimType", "ClaimValue")); 59Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserLogins", "UserId", "ProviderKey", "LoginProvider", "ProviderDisplayName")); 60Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserTokens", "UserId", "LoginProvider", "Name", "Value")); 61Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserPasskeys", "UserId", "CredentialId", "PublicKey", "Name", "CreatedAt", 65Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUsers", 256, "UserName", "Email", "NormalizedUserName", "NormalizedEmail", "PhoneNumber")); 66Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetRoles", 256, "Name", "NormalizedName")); 67Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUserLogins", 128, "LoginProvider", "ProviderKey")); 68Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUserTokens", 128, "LoginProvider", "Name"));

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 (11)

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); 38Assert.True(options.Passkey.AllowCurrentOrigin); 55Assert.True(myOptions.Password.RequireLowercase); 56Assert.True(myOptions.Password.RequireDigit); 57Assert.True(myOptions.Password.RequireNonAlphanumeric); 58Assert.True(myOptions.Password.RequireUppercase); 74Assert.True(myOptions.User.RequireUniqueEmail);

Passkeys\DefaultPasskeyHandlerAssertionTest.cs (19)

Passkeys\DefaultPasskeyHandlerAttestationTest.cs (20)

30Assert.True(result.Succeeded); 39Assert.True(credentialJson.Remove("id")); 90Assert.True(credentialJson.Remove("type")); 139Assert.True(credentialJson.Remove("response")); 174Assert.True(rp.Remove("name")); 208Assert.True(originalOptionsJson.Remove("rp")); 225Assert.True(user.Remove("id")); 277Assert.True(user.Remove("name")); 312Assert.True(user.Remove("displayName")); 346Assert.True(originalOptionsJson.Remove("user")); 362Assert.True(originalOptionsJson.Remove("challenge")); 416Assert.True(response.Remove("clientDataJSON")); 466Assert.True(response.Remove("attestationObject")); 515Assert.True(clientDataJson.Remove("type")); 567Assert.True(clientDataJson.Remove("challenge")); 654Assert.True(clientDataJson.Remove("origin")); 783Assert.True(result.Succeeded); 814Assert.True(result.Succeeded); 867Assert.True(result.Succeeded); 1067Assert.True(result.Succeeded);

RoleManagerTest.cs (3)

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

SignInManagerTest.cs (21)

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)

58Assert.True(categoryParameter.IsRequired); 59Assert.True(groupParameter.IsRequired); 1384Assert.True(parameter.ModelMetadata.IsRequired); 1385Assert.True(parameter.ModelMetadata.IsBindingRequired); 2059Assert.True(description.IsRequired); 2116Assert.True(description.IsRequired); 2134Assert.True(description.IsRequired);

EndpointMetadataApiDescriptionProviderTest.cs (18)

129Assert.True(apiParameterDescription.IsRequired); 741Assert.True(fooParam.IsRequired); 748Assert.True(barParam.IsRequired); 755Assert.True(fromBodyParam.IsRequired); 771Assert.True(param.IsRequired); 778Assert.True(param.IsRequired); 817param => Assert.True(param.IsRequired), 819param => Assert.True(param.IsRequired), 847param => Assert.True(param.IsRequired), 862Assert.True(fooParam.IsRequired); 891Assert.True(apiExplorerSettings!.IgnoreApi); 913Assert.True(barParam.IsRequired); 1223Assert.True(bodyParameterDescription.IsRequired); 1315Assert.True(bodyParameterDescription.IsRequired); 1373Assert.True(bodyParameterDescription.IsRequired); 1411Assert.True(fromFileParam0.IsRequired); 1461Assert.True(bodyParameterDescription.IsRequired); 1506Assert.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)

532Assert.True(method.IsSpecialName); 628Assert.True(isValid); 661Assert.True(isValid); 700Assert.True(isValid); 720Assert.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 (8)

28Assert.True(factory.CreateServerCalled); 29Assert.True(factory.CreateWebHostBuilderCalled); 32Assert.True(factory.CreateHostBuilderCalled); 49Assert.True(factory.CreateHostBuilderCalled); 50Assert.True(factory.CreateHostCalled); 78Assert.True(callbackCalled); 93Assert.True(sink._asyncDisposed); 108Assert.True(sink._asyncDisposed);

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

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 (1)

273Assert.True(idParam.Deprecated);

SchemaTests.cs (1)

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

SnapshotTestHelper.cs (1)

139Assert.True(result.Success);

Extensions\OpenApiRouteHandlerBuilderExtensionTests.cs (2)

143Assert.True(defaultOperation.Content.ContainsKey("text/plain")); 147Assert.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)

37Assert.True(operation.RequestBody.Required); 75Assert.True(operation.RequestBody.Required); 114Assert.True(operation.RequestBody.Required); 153Assert.True(operation.RequestBody.Required);

Services\OpenApiGeneratorTests.cs (16)

141Assert.True(request.Required); 454Assert.True(fooParam.Required); 460Assert.True(barParam.Required); 467Assert.True(fromBodyParam.Required); 482Assert.True(param.Required); 489Assert.True(param.Required); 514Assert.True(fooParam.Required); 538Assert.True(barParam.Required); 720Assert.True(requestBody.Required); 768Assert.True(requestBody.Required); 800Assert.True(requestBody.Required); 838Assert.True(fromFileParam0.Required); 879Assert.True(requestBody.Required); 987param => Assert.True(param.Required), 989param => Assert.True(param.Required), 1007param => 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); 695Assert.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)); 657Assert.True(schema.AdditionalPropertiesAllowed);

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

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)

118Assert.True(HttpMethods.Equals(method, httpContext.Request.Method)); 168Assert.True(HttpMethods.Equals(method, httpContext.Request.Method)); 232Assert.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)

57Assert.True(assertsExecuted); 428Assert.True(assertsExecuted); 485Assert.True(assertsExecuted); 530Assert.True(assertsExecuted);

AddressBinderTests.cs (3)

28Assert.True(AddressBinder.TryCreateIPEndPoint( 191Assert.True(bindTask.IsCompletedSuccessfully); 219Assert.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)

203Assert.True(memoryPool.TryScheduleEviction(time.AddSeconds(10))); 218Assert.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)

208Assert.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)

65Assert.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)

26Assert.True(features.Get<IHttpRequestLifetimeFeature>().RequestAborted.CanBeCanceled); 75Assert.True(features.Get<IHttpRequestLifetimeFeature>().RequestAborted.CanBeCanceled);

HttpContextBuilderTests.cs (2)

30Assert.True(context.RequestAborted.CanBeCanceled); 225Assert.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)

337Assert.True(readCanceled); 628Assert.True(hello.SequenceEqual(buffer.Take(hello.Length))); 633Assert.True(world.SequenceEqual(buffer.Take(world.Length)));

TestServerTests.cs (3)

226Assert.True(response.IsSuccessStatusCode); 385Assert.True(testServer.AllowSynchronousIO); 386Assert.True(testServer.PreserveExecutionContext);

WebSocketClientTests.cs (2)

88Assert.True(res.EndOfMessage); 109Assert.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)

1208Assert.True(string.IsNullOrEmpty(app.Configuration["A"])); 1209Assert.True(string.IsNullOrEmpty(app.Configuration["C"])); 1252Assert.True(string.IsNullOrEmpty(app.Configuration["B"])); 2470Assert.True(helloEndpointCalled); 2471Assert.True(customMiddlewareExecuted); 2503Assert.True(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); 2508Assert.True(app.Properties.ContainsKey("__AuthenticationMiddlewareSet")); 2509Assert.True(app.Properties.ContainsKey("__AuthorizationMiddlewareSet")); 2526Assert.True(iHostApplicationBuilder.Environment.IsProduction()); 2941Assert.True((bool)val);

WebHostTests.cs (1)

123Assert.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);

EditorConfig_Tests.cs (103)

CommandLineSwitches_Tests.cs (51)

Construction\ConstructionEditing_Tests.cs (15)

Construction\ElementLocationPublic_Tests.cs (2)

76Assert.True(Object.ReferenceEquals(e1, target.Location)); 77Assert.True(Object.ReferenceEquals(e2, target.OutputsLocation));

Construction\ProjectExtensionsElement_Tests.cs (1)

89Assert.True(extensions.ContainingProject.HasUnsavedChanges);

Construction\ProjectImportGroupElement_Tests.cs (3)

337Assert.True(project.HasUnsavedChanges); 379Assert.True(project.HasUnsavedChanges); 396Assert.True(project.HasUnsavedChanges);

Construction\ProjectItemDefinitionElement_Tests.cs (1)

213Assert.True(project.HasUnsavedChanges);

Construction\ProjectItemDefinitionGroupElement_Tests.cs (2)

109Assert.True(project.HasUnsavedChanges); 126Assert.True(project.HasUnsavedChanges);

Construction\ProjectItemElement_Tests.cs (2)

1016Assert.True(project.HasUnsavedChanges); 1036Assert.True(project.HasUnsavedChanges);

Construction\ProjectItemGroupElement_tests.cs (2)

86Assert.True(project.HasUnsavedChanges); 103Assert.True(project.HasUnsavedChanges);

Construction\ProjectMetadataElement_Tests.cs (35)

Construction\ProjectOnErrorElement_Tests.cs (2)

267Assert.True(project.HasUnsavedChanges); 285Assert.True(project.HasUnsavedChanges);

Construction\ProjectOutputElement_Tests.cs (5)

29Assert.True(output.IsOutputItem); 43Assert.True(output.IsOutputProperty); 217Assert.True(output.ContainingProject.HasUnsavedChanges); 231Assert.True(output.ContainingProject.HasUnsavedChanges); 258Assert.True(output.ContainingProject.HasUnsavedChanges);

Construction\ProjectPropertyElement_Tests.cs (4)

164Assert.True(property.ContainingProject.HasUnsavedChanges); 193Assert.True(property.ContainingProject.HasUnsavedChanges); 234Assert.True(property.ContainingProject.HasUnsavedChanges); 262Assert.True(property.ContainingProject.HasUnsavedChanges);

Construction\ProjectPropertyGroupElement_Tests.cs (2)

85Assert.True(project.HasUnsavedChanges); 102Assert.True(project.HasUnsavedChanges);

Construction\ProjectRootElement_Tests.cs (14)

108Assert.True(project.HasUnsavedChanges); // it is indeed unsaved 121Assert.True(project.HasUnsavedChanges); 134Assert.True(project.HasUnsavedChanges); 147Assert.True(project.HasUnsavedChanges); 176Assert.True(object.ReferenceEquals(projectXml1, projectXml2)); 192Assert.True(object.ReferenceEquals(projectXml1, projectXml2)); 208Assert.True(object.ReferenceEquals(projectXml1, projectXml2)); 227Assert.True(object.ReferenceEquals(projectXml1, projectXml2)); 246Assert.True(object.ReferenceEquals(projectXml1, projectXml2)); 383Assert.True(exceptionThrown); // "ERROR: An invalid project file exception should have been thrown." 640Assert.True(File.Exists(path)); 672Assert.True(File.Exists(file)); 1300Assert.True(xml0.PreserveFormatting); 1863Assert.True(projectElement.HasUnsavedChanges);

Construction\ProjectTargetElement_Tests.cs (10)

63Assert.True(project.HasUnsavedChanges); 225Assert.True(project.HasUnsavedChanges); 241Assert.True(project.HasUnsavedChanges); 257Assert.True(project.HasUnsavedChanges); 273Assert.True(project.HasUnsavedChanges); 289Assert.True(project.HasUnsavedChanges); 305Assert.True(project.HasUnsavedChanges); 322Assert.True(project.HasUnsavedChanges); 329Assert.True(project.HasUnsavedChanges); 336Assert.True(project.HasUnsavedChanges);

Construction\ProjectTaskElement_Tests.cs (5)

161Assert.True(task.ContainingProject.HasUnsavedChanges); 229Assert.True(task.ContainingProject.HasUnsavedChanges); 245Assert.True(task.ContainingProject.HasUnsavedChanges); 277Assert.True(project.HasUnsavedChanges); 292Assert.True(project.HasUnsavedChanges);

Construction\ProjectUsingTaskElement_Tests.cs (5)

254Assert.True(usingTask.ContainingProject.HasUnsavedChanges); 268Assert.True(usingTask.ContainingProject.HasUnsavedChanges); 309Assert.True(usingTask.ContainingProject.HasUnsavedChanges); 324Assert.True(usingTask.ContainingProject.HasUnsavedChanges); 339Assert.True(usingTask.ContainingProject.HasUnsavedChanges);

Construction\SolutionFile_Tests.cs (10)

Construction\UsingTaskBodyElement_Tests.cs (2)

82Assert.True(body.ContainingProject.HasUnsavedChanges); 96Assert.True(body.ContainingProject.HasUnsavedChanges);

Construction\UsingTaskParameterElement_Tests.cs (9)

Construction\UsingTaskParameterGroup_Tests.cs (2)

97Assert.True(foundFirst); 98Assert.True(foundSecond);

Construction\WhiteSpacePreservation_Tests.cs (2)

44Assert.True(p.IsDirty); 106Assert.True(p.IsDirty);

Definition\DefinitionEditing_Tests.cs (17)

Definition\Project_Tests.cs (1)

4288Assert.True(hasErrorCode);

Definition\ProjectCollection_Tests.cs (44)

Definition\ProjectItem_Tests.cs (23)

Definition\ProjectItemDefinition_Tests.cs (1)

218Assert.True(project.Build(loggers));

Definition\ProjectMetadata_Tests.cs (3)

32Assert.True(Object.ReferenceEquals(project, metadatum.Project)); 62Assert.True(project.IsDirty); 472Assert.True(metadata.IsImported);

Definition\ProjectProperty_Tests.cs (6)

30Assert.True(Object.ReferenceEquals(project, property.Project)); 92Assert.True(project.IsDirty); 109Assert.True(project.IsDirty); 178Assert.True(project.GetProperty(varName).IsEnvironmentProperty); 195Assert.True(project.GetProperty("g").IsGlobalProperty); 212Assert.True(project.GetProperty("MSBuildProjectFile").IsReservedProperty);

Definition\ProtectImports_Tests.cs (14)

Instance\ProjectInstance_Tests.cs (7)

42Assert.True(i.GetPropertyValue("username") != null); 134Assert.True(object.ReferenceEquals(returned, Helpers.MakeList(p.GetItems("i"))[0])); 240Assert.True(Object.ReferenceEquals(newProperty, first.GetProperty("p1"))); 440Assert.True(projAInstanceItem.HasMetadata(CapturedMetadataName)); 482Assert.True(projAInstanceItem.HasMetadata(CapturedMetadataName)); 517Assert.True(projAInstanceItem.HasMetadata(CapturedMetadataName)); 913Assert.True(Object.ReferenceEquals(protoInstance, instance));

Instance\ProjectPropertyInstance_Tests.cs (1)

95Assert.True(property.IsImmutable);

ObjectModelRemoting\Helpers\ViewValidation.construction.cs (9)

187Assert.True(this.View is ProjectElementContainer); 188Assert.True(this.Real is ProjectElementContainer); 281Assert.True(obj == null || !IsLinkedObject(obj)); 315Assert.True(obj == null || IsLinkedObject(obj)); 338Assert.True(!IsLinkedObject(obj)); 349Assert.True(IsLinkedObject(obj)); 448Assert.True(viewChild is ProjectElementContainer); 505Assert.True(realXml is ProjectElementContainer); 666Assert.True(viewParams.ContainsKey(k));

ObjectModelRemoting\Helpers\ViewValidation.cs (4)

111Assert.True(real is T); 289Assert.True(hasMetadata(md.Key)); 328Assert.True(viewCollection.TryGetValue(k, out var vv)); 329Assert.True(realCollection.TryGetValue(k, out var rv));

ObjectModelRemoting\Helpers\ViewValidation.evaluation.cs (1)

42Assert.True(result.HasMetadata(m.Key));

ObjectModelRemoting\LinkedConstructionModify_Tests.cs (7)

136Assert.True(string.IsNullOrEmpty(clone.FullPath)); 229Assert.True(newOutputItem1.View.IsOutputItem); 235Assert.True(newOutputItemWithConfig1.View.IsOutputItem); 241Assert.True(newOutputProp1.View.IsOutputProperty); 247Assert.True(newOutputPropWithConfig1.View.IsOutputProperty); 326Assert.True(newOutputItem.View.IsOutputItem); 333Assert.True(newOutputProp.View.IsOutputProperty);

ObjectModelRemoting\LinkedEvaluationModify_Tests.cs (20)

48Assert.True(File.Exists(proj1Path)); 58Assert.True(realProj.IsDirty); 59Assert.True(viewProj.IsDirty); 63Assert.True(realProj.IsDirty); 64Assert.True(viewProj.IsDirty); 68Assert.True(File.Exists(savedPath)); 84Assert.True(viewProj.IsBuildEnabled); 85Assert.True(realProj.IsBuildEnabled); 91Assert.True(viewProj.SkipEvaluation); 92Assert.True(realProj.SkipEvaluation); 98Assert.True(viewProj.ThrowInsteadOfSplittingItemElement); 99Assert.True(realProj.ThrowInsteadOfSplittingItemElement); 238Assert.True(fooView.HasMetadata("xx")); 244Assert.True(fooView.RemoveMetadata("xx")); 252Assert.True(fooView.HasMetadata("xxReal")); 256Assert.True(fooReal.RemoveMetadata("xxReal")); 321Assert.True(pair.View.GlobalProperties.ContainsKey("gp1")); 322Assert.True(pair.Real.GlobalProperties.ContainsKey("gp1")); 331Assert.True(pair.View.GlobalProperties.ContainsKey("Configuration")); 379Assert.True(pair.View.RemoveProperty(fooView));

ObjectModelRemoting\LinkedProjectCollection_Tests.cs (1)

103Assert.True(prj1Coll.Contains(proj1local));

ObjectModelRemoting\LinkedSpecialCasesScenarios.cs (5)

97Assert.True(xmlPair.View.HasUnsavedChanges); 127Assert.True(xmlPair.View.HasUnsavedChanges); 128Assert.True(xmlPair.Real.HasUnsavedChanges); 151Assert.True(xmlPair.View.HasUnsavedChanges); 180Assert.True(xmlPair.View.HasUnsavedChanges);

AssemblyNameEx_Tests.cs (54)

BackEnd\AssemblyTaskFactory_Tests.cs (4)

134Assert.True(_taskFactory.TaskNameCreatableByFactory("TaskToTestFactories", null, String.Empty, null, ElementLocation.Create(".", 1, 1))); 185Assert.True(_taskFactory.TaskNameCreatableByFactory("TaskToTestFactories", taskIdentityParameters, String.Empty, null, ElementLocation.Create(".", 1, 1))); 235Assert.True(foundExpectedParameter); 692Assert.True(_loadedType.Assembly.Equals(_loadInfo)); // "Expected the AssemblyLoadInfo to be equal"

BackEnd\BatchingEngine_Tests.cs (1)

70Assert.True(ConditionEvaluator.EvaluateCondition(

BackEnd\BinaryTranslator_Tests.cs (10)

BackEnd\BuildEventArgTransportSink_Tests.cs (3)

77Assert.True(wentInHandler); // "Expected to go into transport delegate" 96Assert.True(transportSink.HaveLoggedBuildStartedEvent); 118Assert.True(transportSink.HaveLoggedBuildFinishedEvent);

BackEnd\BuildManager_Tests.cs (34)

BackEnd\BuildRequest_Tests.cs (2)

60Assert.True(request2.IsConfigurationResolved); 91Assert.True(request.IsConfigurationResolved);

BackEnd\BuildRequestConfiguration_Tests.cs (3)

107Assert.True(config1.WasGeneratedByNode); 311Assert.True(configuration.IsCacheable); 378Assert.True(fooCount > 0);

BackEnd\BuildRequestEngine_Tests.cs (1)

468Assert.True(_newConfiguration_Config.WasGeneratedByNode);

BackEnd\BuildRequestEntry_Tests.cs (1)

76Assert.True(results.ContainsKey(requiredResult.NodeRequestId));

BackEnd\BuildResult_Tests.cs (8)

249Assert.True(result.HasResultsForTarget("foo")); 278Assert.True(foundFoo); 305Assert.True(foundFoo); 306Assert.True(foundBar); 332Assert.True(TranslationHelpers.CompareCollections(result.DefaultTargets, deserializedResult.DefaultTargets, StringComparer.Ordinal)); 336Assert.True(TranslationHelpers.CompareCollections(result.InitialTargets, deserializedResult.InitialTargets, StringComparer.Ordinal)); 340Assert.True(TranslationHelpers.CompareCollections(result["alpha"].Items, deserializedResult["alpha"].Items, TaskItemComparer.Instance)); 343Assert.True(TranslationHelpers.CompareCollections(result["omega"].Items, deserializedResult["omega"].Items, TaskItemComparer.Instance));

BackEnd\CacheSerialization_Tests.cs (4)

106Assert.True(result.ConfigCache.HasConfiguration(1)); 138Assert.True(result.ConfigCache.HasConfiguration(1)); 140Assert.True(buildResult.HasResultsForTarget("target1")); 141Assert.True(buildResult.HasResultsForTarget("target2"));

BackEnd\CentralForwardingLogger_Tests.cs (1)

31Assert.True(string.IsNullOrEmpty(centralLogger.Parameters)); // "Expected parameters to be null or empty"

BackEnd\ConfigurationMetadata_Tests.cs (1)

109Assert.True(metadata1.Equals(metadata2));

BackEnd\EventRedirectorToSink_Tests.cs (1)

72Assert.True(wentInHandler); // "Expected to go into event handler"

BackEnd\EventSourceSink_Tests.cs (12)

145Assert.True(handlerHelper.EnteredEventHandler); 146Assert.True(handlerHelper.EnteredAnyEventHandler); 147Assert.True(handlerHelper.EnteredStatusEventHandler); 222Assert.True(ExceptionHandling.IsCriticalException(e)); 233Assert.True(ExceptionHandling.IsCriticalException(e)); 247Assert.True(ExceptionHandling.IsCriticalException(e)); 283Assert.True(e is InternalLoggerException); // "Expected general exception to be raised in event handler and re-thrown by event source as a InternalLoggerException" 307Assert.True(testHandlers.EnteredEventHandler); // "Expected to enter into event handler" 311Assert.True(testHandlers.EnteredAnyEventHandler); // "Expected to enter into AnyEvent handler" 316Assert.True(testHandlers.EnteredStatusEventHandler); // "Expected to enter into Status event handler" 1006Assert.True(_sourceForEvents.HaveLoggedBuildStartedEvent); 1012Assert.True(_sourceForEvents.HaveLoggedBuildFinishedEvent);

BackEnd\FullyQualifiedBuildRequest_Tests.cs (1)

54Assert.True(request.ResultsNeeded);

BackEnd\IntrinsicTask_Tests.cs (3)

3287Assert.True(success); 3315Assert.True(success); 3361Assert.True(success);

BackEnd\LoggingService_Tests.cs (15)

BackEnd\LoggingServicesLogMethod_Tests.cs (14)

BackEnd\MSBuild_Tests.cs (21)

BackEnd\NodeEndpointInProc_Tests.cs (2)

391Assert.True(caught); // "Did not receive InternalErrorException." 405Assert.True(caught); // "Did not receive InternalErrorException."

BackEnd\NodePackets_Tests.cs (1)

364Assert.True(Object.ReferenceEquals(buildEvent, packet.NodeBuildEvent.Value.Value)); // "Expected buildEvent to have the same object reference as packet.BuildEvent"

BackEnd\OnError_Tests.cs (46)

BackEnd\ResultsCache_Tests.cs (10)

39Assert.True(AreResultsIdentical(result, retrievedResult)); 58Assert.True(retrievedResult.HasResultsForTarget("testTarget")); 59Assert.True(retrievedResult.HasResultsForTarget("otherTarget")); 84Assert.True(results[0].HasResultsForTarget("result1target1")); 85Assert.True(results[0].HasResultsForTarget("result1target2")); 86Assert.True(results[1].HasResultsForTarget("result2target1")); 114Assert.True(AreResultsIdenticalForTarget(result, retrievedResult, "testTarget")); 115Assert.True(AreResultsIdenticalForTarget(result2, retrievedResult, "testTarget2")); 164Assert.True(AreResultsIdenticalForTarget(result2, retrievedResult, "testTarget2")); 187Assert.True(AreResultsIdenticalForTarget(result, response.Results, "testTarget2"));

BackEnd\Scheduler_Tests.cs (9)

BackEnd\TargetBuilder_Tests.cs (14)

BackEnd\TargetResult_Tests.cs (2)

104Assert.True(TranslationHelpers.CompareCollections(result.Items, deserializedResult.Items, TaskItemComparer.Instance)); 124Assert.True(TranslationHelpers.CompareCollections(result.Items, deserializedResult.Items, TaskItemComparer.Instance));

BackEnd\TargetUpToDateChecker_Tests.cs (9)

63Assert.True(success); 124Assert.True(success); 149Assert.True(success); 294Assert.True(changedTargetInputs.HasEmptyMarker("MoreItems")); 321Assert.True(p.Build(new string[] { "Build" }, new ILogger[] { logger })); 350Assert.True(p.Build(new string[] { "Build" }, new ILogger[] { logger })); 379Assert.True(p.Build(new string[] { "Build" }, new ILogger[] { logger })); 409Assert.True(p.Build(new string[] { "Build" }, new ILogger[] { logger })); 444Assert.True(p.Build(new string[] { "Build" }, new ILogger[] { logger }));

BackEnd\TaskBuilder_Tests.cs (2)

526Assert.True(result); 557Assert.True(result);

BackEnd\TaskExecutionHost_Tests.cs (23)

BackEnd\TaskHost_Tests.cs (28)

BackEnd\TaskHostTaskComplete_Tests.cs (1)

258Assert.True(exceptionCaught); // "No exception was caught when one was expected!"

BackEnd\TaskRegistry_Tests.cs (10)

233Assert.True(foundFirstLoadInfo); // "Expected first task to be registered in this bucket!" 234Assert.True(foundSecondLoadInfo); // "Expected second task to be registered in this bucket!" 1334Assert.True(parameterInfo.Output); 1335Assert.True(parameterInfo.Required); 1351Assert.True(registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.UsingTaskParameters["ParameterWithAllAttributesHardCoded"].PropertyType.Equals(typeof(String))); 1366Assert.True(registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.UsingTaskParameters["ParameterWithAllAttributesHardCoded"].PropertyType.Equals(typeof(String))); 1766Assert.True(inlineTaskRecord.TaskBodyEvaluated); 1836Assert.True(registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.TaskBodyEvaluated); 1848Assert.True(registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.TaskBodyEvaluated); 2128Assert.True(registry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("Name", null)][0].ParameterGroupAndTaskBody.UsingTaskParameters["ParameterWithAllAttributesHardCoded"].PropertyType.Equals(paramType));

Collections\MSBuildNameIgnoreCaseComparer_Tests.cs (11)

Collections\MultiDictionary_Tests.cs (4)

49Assert.True(dictionary.Remove("x", "x1")); 54Assert.True(dictionary.Remove("x", "x2")); 59Assert.True(dictionary.Remove("y", "y1")); 67Assert.True(dictionary.Remove("x", "x2"));

Collections\OMcollections_tests.cs (6)

50Assert.True(properties.Remove("p1")); 172Assert.True(enumerator.MoveNext()); 176Assert.True(enumerator.MoveNext()); 214Assert.True(readOnlyDictionary.ContainsKey("P")); 231Assert.True(dictionary.ContainsKey("p2")); 280Assert.True(convertingCollection.IsReadOnly);

Construction\ElementLocation_Tests.cs (6)

87Assert.True(location1.Equals(location6)); 88Assert.True(location2.Equals(location5)); 354Assert.True(doc.IsReadOnly); 369Assert.True(doc.IsReadOnly); 386Assert.True(doc.IsReadOnly); 403Assert.True(doc.IsReadOnly);

Construction\ProjectRootElement_Tests.cs (2)

35Assert.True(ProjectRootElement.IsEmptyXmlFile(path)); 111Assert.True(xml.XmlDocument.IsReadOnly);

Construction\SolutionFilter_Tests.cs (1)

334Assert.True(sp.ProjectShouldBuild("SolutionTest.csproj"));

Construction\SolutionProjectGenerator_Tests.cs (11)

1162Assert.True(solutionConfigurationContents.IndexOf(tempProjectPath, StringComparison.OrdinalIgnoreCase) > 0); 1168Assert.True(solutionConfigurationContents.IndexOf(tempProjectPath, StringComparison.OrdinalIgnoreCase) > 0); 1550Assert.True(caughtException); // "Passing an invalid ToolsVersion should have caused an InvalidProjectFileException to be thrown." 1805Assert.True(success); 1833Assert.True(success); 1861Assert.True(success); 2041Assert.True(File.Exists(solution.FullPath + ".metaproj")); // "Solution parser should have written in-memory project to disk" 2116Assert.True(msbuildProject.Build(new ILogger[] { logger })); 2498Assert.True(instances[0].Targets.ContainsKey(targetName)); 2505Assert.True(instances[0].Targets.ContainsKey(traversalTargetName)); 2637Assert.True(projectInstance.Targets.ContainsKey("MyTarget"));

CopyOnWriteDictionary_Tests.cs (8)

34Assert.True(Object.ReferenceEquals(v1, v2)); 35Assert.True(dictionary.ContainsKey(k1)); 66Assert.True(result); 67Assert.True(Object.ReferenceEquals(v1, v2)); 106Assert.True(Object.ReferenceEquals(v1, v2)); 179Assert.True(dictionary.HasSameBacking(clone)); 180Assert.True(dictionary.HasSameBacking(clone2)); 185Assert.True(dictionary.HasSameBacking(clone2));

Definition\ItemDefinitionGroup_Tests.cs (40)

Definition\Project_Internal_Tests.cs (1)

97Assert.True(Object.ReferenceEquals(project, project2));

Definition\ProjectItem_Tests.cs (1)

39Assert.True(Object.ReferenceEquals(item1.DirectMetadata.First().Xml, item2.DirectMetadata.First().Xml));

Definition\ToolsetConfigurationReader_Tests.cs (1)

584Assert.True(pathsTable.ContainsKey(kind));

Definition\ToolsVersion_Tests.cs (10)

315Assert.True(success); 353Assert.True(success); 388Assert.True(success); 450Assert.True(success); 557Assert.True(success); 595Assert.True(success); 638Assert.True(success); 709Assert.True(success); 794Assert.True(success); 904Assert.True(success);

EscapingInProjects_Tests.cs (4)

690Assert.True(success); // "Build failed. See test output (Attachments in Azure Pipelines) for details" 720Assert.True(success); // "Build failed. See test output (Attachments in Azure Pipelines) for details" 789Assert.True(exceptionCaught); // "Expected an InvalidProjectFileException" 813Assert.True(success); // "Build failed. See test output (Attachments in Azure Pipelines) for details"

EscapingUtilities_Tests.cs (6)

86Assert.True(EscapingUtilities.ContainsEscapedWildcards("%2a")); 87Assert.True(EscapingUtilities.ContainsEscapedWildcards("%2A")); 88Assert.True(EscapingUtilities.ContainsEscapedWildcards("%3F")); 89Assert.True(EscapingUtilities.ContainsEscapedWildcards("%3f")); 90Assert.True(EscapingUtilities.ContainsEscapedWildcards("%%3f")); 91Assert.True(EscapingUtilities.ContainsEscapedWildcards("%3%3f"));

Evaluation\Evaluator_Tests.cs (56)

Evaluation\Expander_Tests.cs (5)

1650Assert.True(Object.ReferenceEquals(xmlattribute.Value, expandedString)); 2321Assert.True( 2331Assert.True( 2629Assert.True(int.TryParse(result, out pid)); 4426Assert.True(Guid.TryParse(result, out Guid guid));

Evaluation\ImportFromMSBuildExtensionsPath_Tests.cs (17)

Evaluation\ItemSpec_Tests.cs (10)

34Assert.True(itemSpecGlob.IsMatch("a")); 35Assert.True(itemSpecGlob.IsMatch("bar")); 36Assert.True(itemSpecGlob.IsMatch("car")); 37Assert.True(itemSpecGlob.IsMatch("d")); 38Assert.True(itemSpecGlob.IsMatch("e")); 74Assert.True(itemSpecGlob.IsMatch("a")); 75Assert.True(itemSpecGlob.IsMatch("bar")); 76Assert.True(itemSpecGlob.IsMatch("car")); 77Assert.True(itemSpecGlob.IsMatch("d")); 78Assert.True(itemSpecGlob.IsMatch("e"));

Evaluation\ProjectRootElementCache_Tests.cs (3)

122Assert.True(Object.ReferenceEquals(xml0, xml1)); 156Assert.True(Object.ReferenceEquals(xml0, xml1)); 161Assert.True(Object.ReferenceEquals(xml0, xml2));

Evaluation\ProjectSdkImplicitImport_Tests.cs (1)

829Assert.True(property.IsImported);

Evaluation\SimpleVersion_Tests.cs (9)

141Assert.True(version1 < version2); 142Assert.True(version1 <= version2); 146Assert.True(version1 != version2); 151Assert.True(version1 <= version2); 152Assert.True(version1 == version2); 153Assert.True(version1 >= version2); 162Assert.True(version1 >= version2); 163Assert.True(version1 > version2); 164Assert.True(version1 != version2);

Evaluation\UsedUninitializedProperties_Tests.cs (2)

31Assert.True(props.TryGetPropertyElementLocation("Hello", out elementLocation)); 34Assert.True(props.TryGetPropertyElementLocation("Hello", out elementLocation));

EvaluationProfiler_Tests.cs (2)

223Assert.True(profiledElements.Where(e => e.IsEvaluationPass && e.EvaluationPass != EvaluationPass.TotalGlobbing && !e.Equals(totalEvaluation)) 258Assert.True(profiledElements.All(e => e.ParentId == null || allUniqueIds.Contains(e.ParentId.Value)));

ExpressionTree_Tests.cs (2)

122Assert.True(value); 497Assert.True(fExceptionCaught);

FileLogger_Tests.cs (1)

380Assert.True(result.Exists);

FileMatcher_Tests.cs (1)

2609Assert.True(shouldBeRecursive); // "FileMatcher Regression: Match was recursive when it shouldn't be."

FileUtilities_Tests.cs (39)

FixPathOnUnix_Tests.cs (1)

50Assert.True(result);

Globbing\CompositeGlob_Tests.cs (1)

99Assert.True(compositeGlob.IsMatch(stringToMatch));

Globbing\MSBuildGlob_Tests.cs (12)

121Assert.True(glob.IsLegal); 122Assert.True(glob.TestOnlyNeedsRecursion); 169Assert.True(glob.IsLegal); 215Assert.True(glob.IsMatch("\\")); 235Assert.True(glob.IsMatch("abc")); 263Assert.True(glob.IsMatch(string.Empty)); 273Assert.True(glob.IsMatch(string.Empty)); 293Assert.True(glob.IsMatch(illegalSpec)); 308Assert.True(glob.IsMatch(stringToMatch)); 326Assert.True(glob.IsMatch(@"../x/d13/../../x/d12/d23/../a.cs")); 351Assert.True(glob.IsMatch(stringToMatch)); 354Assert.True(result.IsMatch);

Globbing\MSBuildGlobWithGaps_Tests.cs (2)

20Assert.True(glob.IsMatch("ab")); 28Assert.True(glob.IsMatch("ab"));

HashTableUtility_Tests.cs (5)

34Assert.True(HashTableUtility.Compare(h1, h2) < 0); 35Assert.True(HashTableUtility.Compare(h2, h1) > 0); 56Assert.True(HashTableUtility.Compare(h1, h2) < 0); 60Assert.True(HashTableUtility.Compare(h1, h2) > 0); 64Assert.True(HashTableUtility.Compare(h1, h2) < 0);

Instance\HostServices_Tests.cs (1)

434Assert.True(hostServices.HasInProcessHostObject(project2.FullPath));

Instance\ProjectPropertyInstance_Internal_Tests.cs (1)

77Assert.True(property.IsImmutable);

Instance\TaskItem_Tests.cs (3)

73Assert.True(left.Equals(left)); 175Assert.True(parent.Equals(clone)); // "The parent and the clone should be equal" 176Assert.True(clone.Equals(parent)); // "The parent and the clone should be equal"

Scanner_Tests.cs (170)

TaskParameter_Tests.cs (1)

154Assert.True(t2.WrappedParameter is string[]);

TestComparers\TaskRegistryComparers.cs (1)

122Assert.True(x == null && y == null);

TypeLoader_Tests.cs (13)

37Assert.True(TypeLoader.IsPartialTypeNameMatch("Csc", "csc")); // ==> exact match 38Assert.True(TypeLoader.IsPartialTypeNameMatch("Microsoft.Build.Tasks.Csc", "Microsoft.Build.Tasks.Csc")); // ==> exact match 39Assert.True(TypeLoader.IsPartialTypeNameMatch("Microsoft.Build.Tasks.Csc", "Csc")); // ==> partial match 40Assert.True(TypeLoader.IsPartialTypeNameMatch("Microsoft.Build.Tasks.Csc", "Tasks.Csc")); // ==> partial match 41Assert.True(TypeLoader.IsPartialTypeNameMatch("MyTasks.ATask+NestedTask", "NestedTask")); // ==> partial match 42Assert.True(TypeLoader.IsPartialTypeNameMatch("MyTasks.ATask\\\\+NestedTask", "NestedTask")); // ==> partial match 58Assert.True(TypeLoader.IsPartialTypeNameMatch("Csc", "Microsoft.Build.Tasks.Csc")); 88Assert.True(successfulExit); 132Assert.True(successfulExit); 156Assert.True(successfulExit); 176Assert.True(File.Exists(originalDllPath)); 182Assert.True(File.Exists(newDllPath)); 188Assert.True(File.Exists(newDllPath));

XmakeAttributes_Tests.cs (25)

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)

611Assert.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")));

AssemblyDependency\ResolveAssemblyReferenceTestFixture.cs (1)

3107Assert.True(ContainsItem(t.Assemblies, originalItemSpec) || ContainsItem(t.AssemblyFiles, originalItemSpec)); // "Expected to find OriginalItemSpec in Assemblies or AssemblyFiles task parameters"

AssemblyDependency\SuggestedRedirects.cs (11)

AssemblyNameEx_Tests.cs (54)

AssignLinkMetadata_Tests.cs (7)

34Assert.True(success); 55Assert.True(success); 74Assert.True(success); 101Assert.True(success); 125Assert.True(success); 147Assert.True(success); 167Assert.True(success);

CallTarget_Tests.cs (1)

178Assert.True(success); // "Build failed. See test output (Attachments in Azure Pipelines) for details"

CombinePath_Tests.cs (8)

32Assert.True(t.Execute()); // "success" 62Assert.True(t.Execute()); // "success" 82Assert.True(t.Execute()); // "success" 111Assert.True(t.Execute()); // "success" 143Assert.True(t.Execute()); // "success" 159Assert.True(t.Execute()); // "success" 178Assert.True(t.Execute()); // "success" 195Assert.True(t.Execute()); // "success"

ConvertToAbsolutePath_Tests.cs (4)

36Assert.True(t.Execute()); // "success" 68Assert.True(t.Execute()); // "success" 98Assert.True(t.Execute()); // "success" 122Assert.True(t.Execute()); // "success"

Copy_Tests.cs (27)

CreateCSharpManifestResourceName_Tests.cs (5)

370Assert.True(success); // "Expected the task to succeed." 803Assert.True(success); // "Expected the task to succeed." 829Assert.True(success); // "Expected the task to succeed." 855Assert.True(success); // "Expected the task to succeed." 880Assert.True(success); // "Expected the task to succeed."

CreateItem_Tests.cs (9)

59Assert.True(success); 77Assert.True(success); 95Assert.True(success); 114Assert.True(success); 129Assert.True(success); 148Assert.True(success); 231Assert.True(success); 254Assert.True(success); 279Assert.True(success);

EscapingUtilities_Tests.cs (6)

86Assert.True(EscapingUtilities.ContainsEscapedWildcards("%2a")); 87Assert.True(EscapingUtilities.ContainsEscapedWildcards("%2A")); 88Assert.True(EscapingUtilities.ContainsEscapedWildcards("%3F")); 89Assert.True(EscapingUtilities.ContainsEscapedWildcards("%3f")); 90Assert.True(EscapingUtilities.ContainsEscapedWildcards("%%3f")); 91Assert.True(EscapingUtilities.ContainsEscapedWildcards("%3%3f"));

FileStateTests.cs (4)

97Assert.True(state.IsDirectory); 189Assert.True(state.FileExists); 321Assert.True(state.IsReadOnly); 334Assert.True(new FileState(Path.GetTempPath()).IsDirectory);

FindAppConfigFile_Tests.cs (6)

24Assert.True(f.Execute()); 37Assert.True(f.Execute()); 50Assert.True(f.Execute()); 63Assert.True(f.Execute()); 75Assert.True(f.Execute()); 93Assert.True(f.Execute());

FindInList_Tests.cs (9)

24Assert.True(f.Execute()); 36Assert.True(f.Execute()); 48Assert.True(f.Execute()); 63Assert.True(f.Execute()); 83Assert.True(f.Execute()); // "Expect success" 96Assert.True(f.Execute()); 107Assert.True(f.Execute()); 119Assert.True(f.Execute()); 132Assert.True(f.Execute());

FindInvalidProjectReferences_Tests.cs (1)

43Assert.True(succeeded);

FindUnderPath_Tests.cs (3)

31Assert.True(success); 107Assert.True(success); 129Assert.True(success);

GetInstalledSDKLocations_Tests.cs (16)

GetSDKReference_Tests.cs (31)

Hash_Tests.cs (2)

111Assert.True(hashTask.Execute()); 157Assert.True(hashTask.Execute());

MakeDir_Tests.cs (6)

41Assert.True(success); 100Assert.True(success); 144Assert.True(success); 154Assert.True(success); 204Assert.True(success); 210Assert.True(success);

MockUnmanagedMemoryHelper.cs (1)

68Assert.True(_allocatedHandles.Exists(new Predicate<IntPtr>(

Move_Tests.cs (17)

46Assert.True(t.Execute()); 49Assert.True(File.Exists(destinationFile)); // "Expected the destination file to exist." 53Assert.True(((new FileInfo(destinationFile)).Attributes & FileAttributes.ReadOnly) == 0); // should have cleared r/o bit 92Assert.True(t.Execute()); 95Assert.True(File.Exists(destinationFile)); // "Expected the destination file to exist." 99Assert.True(((new FileInfo(destinationFile)).Attributes & FileAttributes.ReadOnly) == 0); // should have cleared r/o bit 143Assert.True(File.Exists(destinationFile)); // "Expected the destination file to still exist." 187Assert.True(t.Execute()); 190Assert.True(File.Exists(sourceFile)); // "Source file should be there" 231Assert.True(File.Exists(sourceFile)); // "Source file should be present" 241Assert.True(((new FileInfo(destinationFile)).Attributes & FileAttributes.ReadOnly) != 0); // should still be r/o 349Assert.True(((new FileInfo(destinationFile)).Attributes & FileAttributes.ReadOnly) == 0); // readonly bit should not be set 403Assert.True(((new FileInfo(destinationFile)).Attributes & FileAttributes.ReadOnly) == 0); // should have cleared r/o bit 616Assert.True(success); 620Assert.True(File.Exists(file)); // "Source file should be there" 701Assert.True(success); // "success" 703Assert.True(File.Exists(destFile)); // "destination exists"

MSBuild_Tests.cs (13)

PropertyParser_Tests.cs (10)

ReadLinesFromFile_Tests.cs (13)

37Assert.True(a.Execute()); 44Assert.True(r.Execute()); 51Assert.True(a.Execute()); 54Assert.True(r.Execute()); 84Assert.True(a.Execute()); 91Assert.True(r.Execute()); 98Assert.True(a.Execute()); 101Assert.True(r.Execute()); 129Assert.True(a.Execute()); 136Assert.True(r.Execute()); 160Assert.True(r.Execute()); 189Assert.True(a.Execute()); 196Assert.True(r.Execute());

RegressionTests.cs (1)

48Assert.True(result);

RemoveDuplicates_Tests.cs (9)

26Assert.True(success); 44Assert.True(success); 47Assert.True(t.HadAnyDuplicates); 69Assert.True(success); 95Assert.True(success); 114Assert.True(success); 133Assert.True(success); 136Assert.True(t.HadAnyDuplicates); 149Assert.True(success);

ResolveCodeAnalysisRuleSet_Tests.cs (12)

66Assert.True(result); 89Assert.True(result); 109Assert.True(result); 135Assert.True(result); 160Assert.True(result); 186Assert.True(result); 210Assert.True(result); 234Assert.True(result); 264Assert.True(result); 287Assert.True(result); 306Assert.True(result); 325Assert.True(result);

ResolveNonMSBuildProjectOutput_Tests.cs (7)

230Assert.True(resolvedOutputs.Contains(Path.Combine("obj", "managed.dll"))); 231Assert.True(resolvedOutputs.Contains(Path.Combine("obj", "unmanaged.dll"))); 273Assert.True(resolvedOutputs.ContainsKey(Path.Combine("obj", "correct.dll"))); 288Assert.True(resolvedOutputs.ContainsKey(Path.Combine("obj", "correct.dll"))); 289Assert.True(resolvedOutputs.ContainsKey(Path.Combine("obj", "correct2.dll"))); 316Assert.True(resolvedOutputs.ContainsKey(Path.Combine("obj", "correct.dll"))); 345Assert.True(rvpo.VerifyProjectReferenceItems(taskItems, false /* treat problems as warnings */));

ResolveSDKReference_Tests.cs (65)

ResourceHandling\GenerateResource_Tests.cs (39)

StreamMappedString_Tests.cs (2)

190Assert.True(s.IsPastEnd(2)); // <-- 2 required because of extra \xd added. 215Assert.True(s.IsPastEnd(1));

TelemetryTaskTests.cs (3)

26Assert.True(retVal); 48Assert.True(retVal); 90Assert.True(retVal);

ToolTaskExtension_Tests.cs (1)

87Assert.True(t.GetBoolParameterWithDefault("Key", false));

Touch_Tests.cs (4)

198Assert.True(success); 245Assert.True(success); 380Assert.True(success); 404Assert.True(success);

WriteCodeFragment_Tests.cs (29)

WriteLinesToFile_Tests.cs (4)

62Assert.True(a.Execute()); 68Assert.True(r.Execute()); 82Assert.True(a.Execute()); 89Assert.True(r.Execute());

XmlPeek_Tests.cs (7)

75Assert.True(p.Execute()); // "Test should've passed" 98Assert.True(p.Execute()); // "Test should've passed" 127Assert.True(p.Execute()); // "Test should've passed" 155Assert.True(p.Execute()); // "Test should've passed" 175Assert.True(p.Execute()); // "Test should've passed" 306Assert.True(result); // "Only 3rd value should pass." 356Assert.True(p.Execute());

XslTransformation_Tests.cs (5)

149Assert.True(t.Execute()); // "The test should have passed at the both params correct test" 373Assert.True(t.Execute()); // "Test out should have given true when executed" 465Assert.True(result); // "Only 5th and 7th values should pass." 501Assert.True(t.Execute()); // "This test should've passed (empty parameters)." 1079Assert.True(t.Execute()); // "Test should have passed and allowed the use of the document() function within the xslt file"

ObjectModelHelpers.cs (6)

1260Assert.True(two.Contains(item)); 1265Assert.True(one.Contains(item)); 1273Assert.True(x == null && y == null); 1346Assert.True(result); 1672Assert.True(FileSystems.Default.DirectoryExists(directoryName)); 1675Assert.True(FileSystems.Default.FileExists(fullPath));

TestEnvironment.cs (1)

291Assert.True(!(createFolder ^ FileSystems.Default.DirectoryExists(folder.Path)));

EscapingUtilities_Tests.cs (6)

86Assert.True(EscapingUtilities.ContainsEscapedWildcards("%2a")); 87Assert.True(EscapingUtilities.ContainsEscapedWildcards("%2A")); 88Assert.True(EscapingUtilities.ContainsEscapedWildcards("%3F")); 89Assert.True(EscapingUtilities.ContainsEscapedWildcards("%3f")); 90Assert.True(EscapingUtilities.ContainsEscapedWildcards("%%3f")); 91Assert.True(EscapingUtilities.ContainsEscapedWildcards("%3%3f"));

TaskItem_Tests.cs (1)

342Assert.True(actualMetadata.SequenceEqual(expectedMetadata));

ToolTask_Tests.cs (1)

642Assert.True(task.StartInfo.Environment["PATH"].Length > 0);

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

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

CommandLineTests.cs (165)

CodeActions\ApplyChangesOperationTests.cs (1)

257Assert.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)

57Assert.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)

462Assert.True(called);

Completion\CompletionProviders\DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs (1)

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

Completion\CompletionProviders\OverrideCompletionProviderTests.cs (1)

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

Completion\CompletionServiceTests.cs (4)

63Assert.True(provider is ThirdPartyCompletionProvider); 135Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions( 182Assert.True(performSort == completionList.ItemsList.SequenceEqual(completionListManuallySorted)); 232Assert.True(completionList.ItemsList.Select(item => item.DisplayText).Contains(expectedItem));

Debugging\ProximityExpressionsGetterTests.cs (1)

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

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (3)

100Assert.True(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 113Assert.True(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 759Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences(

EditorConfigSettings\Updater\SettingsUpdaterTests.cs (3)

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

Formatting\Indentation\SmartIndenterEnterOnTokenTests.cs (1)

1412Assert.True(

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)

1189Assert.True(state.IsUnspecified); 1192Assert.True(state.IsUnspecified);

PdbSourceDocument\AbstractPdbSourceDocumentTests.cs (3)

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

PdbSourceDocument\ImplementationAssemblyLookupServiceTests.cs (3)

95Assert.True(service.TryFindImplementationAssemblyPath(GetDllPath(packDir), out var implementationDll)); 137Assert.True(service.TryFindImplementationAssemblyPath(GetDllPath(packDir), out var implementationDll)); 579Assert.True(_logs.Add(message));

PdbSourceDocument\PdbSourceDocumentTests.cs (4)

975Assert.True(result); 998Assert.True(openResult); 1001Assert.True(closeResult); 1049Assert.True(openResult);

SplitStringLiteral\SplitStringLiteralCommandHandlerTests.cs (1)

148Assert.True(notHandled);

SymbolKey\SymbolKeyTestBase.cs (1)

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

Workspaces\WorkspaceTests_EditorFeatures.cs (2)

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

EmbeddedLanguages\Json\CSharpJsonParserTests.cs (2)

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

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (5)

112Assert.True(allChars.IsDefault); 136Assert.True(result); 148Assert.True(regex.GetGroupNumbers().OrderBy(v => v).SequenceEqual( 151Assert.True(regex.GetGroupNames().Where(v => !int.TryParse(v, out _)).OrderBy(v => v).SequenceEqual( 355Assert.True(RegexLexer.IsEscapeCategoryChar(VirtualChar.Create(new Rune(ch), new TextSpan(0, 1))));

CodeGen\CodeGenAsyncMethodBuilderOverrideTests.cs (2)

134Assert.True(method.IsAsync); 137Assert.True(method.IsAsync);

CodeGen\CodeGenAsyncTests.cs (1)

84Assert.True(options.EnableEditAndContinue);

CodeGen\CodeGenAwaitForeachTests.cs (14)

939Assert.True(info.IsAsynchronous); 2978Assert.True(internalInfo.NeedsDisposal); 3297Assert.True(internalInfo.NeedsDisposal); 3551Assert.True(internalInfo.NeedsDisposal); 3599Assert.True(internalInfo.NeedsDisposal); 3732Assert.True(internalInfo.NeedsDisposal); 4480Assert.True(internalInfo.NeedsDisposal); 4553Assert.True(internalInfo.NeedsDisposal); 4663Assert.True(internalInfo.NeedsDisposal); 5066Assert.True(internalInfo.NeedsDisposal); 9110Assert.True(info.IsAsynchronous); 9186Assert.True(info.IsAsynchronous); 9264Assert.True(info.IsAsynchronous); 9396Assert.True(info.IsAsynchronous);

CodeGen\CodeGenAwaitUsingTests.cs (3)

2339Assert.True(first.Equals(first)); 2340Assert.True(first.Equals((object)first)); 2343Assert.True(first.GetHashCode() == another.GetHashCode());

CodeGen\CodeGenCapturing.cs (1)

121Assert.True(numSubsets > 0);

CodeGen\CodeGenDeconstructTests.cs (8)

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)); 6977Assert.True(model.GetSymbolInfo(discard1).IsEmpty); 6986Assert.True(model.GetSymbolInfo(discard2).IsEmpty); 7004Assert.True(model.GetSymbolInfo(discard4).IsEmpty);

CodeGen\CodeGenDynamicTests.cs (1)

602Assert.True(field.IsStatic);

CodeGen\CodeGenFunctionPointersTests.cs (15)

304Assert.True(signature.HasUseSiteError); 305Assert.True(signature.HasUnsupportedMetadata); 380Assert.True(signature.HasUseSiteError); 381Assert.True(signature.HasUnsupportedMetadata); 709Assert.True(firstMod.IsOptional); 998Assert.True(type.HasUseSiteError); 6307Assert.True(baseM1.Parameters.Single().Type.Equals(derivedM1.Parameters.Single().Type, TypeCompareKind.ConsiderEverything)); 6308Assert.True(baseM2.ReturnType.Equals(derivedM2.ReturnType, TypeCompareKind.ConsiderEverything)); 6309Assert.True(baseM3.Parameters.Single().Type.Equals(derivedM3.Parameters.Single().Type, TypeCompareKind.ConsiderEverything)); 6310Assert.True(baseM4.ReturnType.Equals(derivedM4.ReturnType, TypeCompareKind.ConsiderEverything)); 7692Assert.True(funcPtr.Equals(funcPtrWithTestOnReturn, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 7694Assert.True(funcPtrRef.Equals(funcPtrWithTestOnRef, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 7777Assert.True(funcPtr.Equals(funcPtrWithTestOnReturn, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 7779Assert.True(funcPtrRef.Equals(funcPtrWithTestOnRef, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); 10520Assert.True(callConvCdecl!.Equals((NamedTypeSymbol)m.GetUnmanagedCallersOnlyAttributeData(forceComplete: true)!.CallingConventionTypes.Single(), TypeCompareKind.ConsiderEverything));

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 (26)

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); 6172Assert.True(synthesizedParam.IsMetadataOut);

CodeGen\CodeGenOperators.cs (1)

5708Assert.True(passed);

CodeGen\CodeGenReadonlyStructTests.cs (9)

828Assert.True(namedType.IsReadOnly); 845Assert.True(namedType.IsReadOnly); 852Assert.True(namedType.IsReadOnly); 859Assert.True(namedType.IsReadOnly); 911Assert.True(s1.IsReadOnly); 1002Assert.True(namedType.IsReadOnly); 1009Assert.True(namedType.IsReadOnly); 1016Assert.True(namedType.IsReadOnly); 1023Assert.True(namedType.IsReadOnly);

CodeGen\CodeGenScriptTests.cs (1)

527Assert.True(((MethodSymbol)methodData.Method).ReturnsVoid);

CodeGen\CodeGenTests.cs (1)

14661Assert.True(result.Success);

CodeGen\CodeGenTupleEqualityTests.cs (1)

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

CodeGen\CodeGenTupleTest.cs (314)

CodeGen\EventTests.cs (4)

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

CodeGen\FixedSizeBufferTests.cs (1)

578Assert.True(f.IsFixedSizeBuffer);

CodeGen\ForeachTest.cs (1)

1689Assert.True(local.IsVar);

CodeGen\IndexAndRangeTests.cs (1)

1001Assert.True(property.IsIndexer);

CodeGen\WinMdDelegateTests.cs (1)

268Assert.True(isWinRt(fieldSymbol));

Emit\CompilationEmitTests.cs (45)

Emit\DeterministicTests.cs (1)

88Assert.True(resultNonDeterministic.Success);

Emit\DynamicAnalysis\DynamicInstrumentationTests.cs (1)

2460Assert.True(false);

Emit\EmitErrorTests.cs (1)

255Assert.True(result.Success);

Emit\EmitMetadataTests.cs (23)

362Assert.True(i1.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i2, i3, i4, i5, i6, i7))); 363Assert.True(i2.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i3, i4))); 366Assert.True(i5.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i6, i7))); 370Assert.True(c.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i1, i2, i3, i4, i5, i6, i7))); 436Assert.True(method1Ret.IsSZArray); 605Assert.True(ctor.IsDefinition); 613Assert.True(ctor.ReturnsVoid); 626Assert.True(cctor.IsDefinition); 627Assert.True(cctor.IsStatic); 634Assert.True(cctor.ReturnsVoid); 681Assert.True(field.IsStatic); 682Assert.True(field.IsConst); 1238Assert.True(getMethodA.IsVirtual); 1246Assert.True(getMethodC.IsOverride); 1298Assert.True(sourceProperty.IsAutoProperty); 1374Assert.True(field.IsStatic); 1375Assert.True(field.IsConst); 1395Assert.True(type.IsSealed); 2304Assert.True(peHeaders.TryGetDirectoryOffset(peHeader.ImportAddressTableDirectory, out importAddressTableDirectoryOffset)); 2317Assert.True(peHeaders.TryGetDirectoryOffset(peHeader.ImportTableDirectory, out importTableDirectoryOffset)); 3751Assert.True(emitResult.Success); 3793Assert.True(emitResult.Success); 3834Assert.True(emitResult.Success);

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\NoPiaEmbedTypes.cs (13)

146Assert.True(result.Success); 1178Assert.True(itest1.IsComImport); 1202Assert.True(test2.IsSealed); 1262Assert.True(test9.IsSealed); 1284Assert.True(value__.HasSpecialName); 1285Assert.True(value__.HasRuntimeSpecialName); 1295Assert.True(f1.IsStatic); 1328Assert.True(f3.IsNotSerialized); 1578Assert.True(p1.HasSpecialName); 1620Assert.True(e1.HasSpecialName); 4799Assert.True(isNoPiaLocalType); 4817Assert.True(isNoPiaLocalType); 6026Assert.True(p1.IsMetadataOptional);

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

Emit\EditAndContinue\EditAndContinueClosureTests.cs (2)

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

Emit\EditAndContinue\LocalSlotMappingTests.cs (1)

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

Emit\EditAndContinue\SymbolMatcherTests.cs (1)

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

Emit\NumericIntPtrTests.cs (6)

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

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 (26)

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)); 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)); 5425Assert.True(typesym.HasSpecialName); 5429Assert.True(idxsym.HasSpecialName); 5433Assert.True(etsym.HasSpecialName); 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);

Attributes\AttributeTests_Assembly.cs (10)

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); }); 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_IsByRefLike.cs (1)

1040Assert.True(peType.IsRefLikeType);

Attributes\AttributeTests_NativeInteger.cs (1)

1469Assert.True(attributeUsage.HasValidAttributeTargets);

Attributes\AttributeTests_Nullable.cs (3)

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_RefReadOnly.cs (8)

311Assert.True(property.ReturnsByRefReadonly); 340Assert.True(property.ReturnsByRefReadonly); 377Assert.True(property.ReturnsByRefReadonly); 1361Assert.True(NeedsGeneratedIsReadOnlyAttribute(reference)); 1398Assert.True(NeedsGeneratedIsReadOnlyAttribute(reference)); 1454Assert.True(model.TryGetSpeculativeSemanticModel(position, localfunction, out var newModel)); 1481Assert.True(model.TryGetSpeculativeSemanticModel(position, localfunction, out var newModel)); 1495Assert.True(NeedsGeneratedIsReadOnlyAttribute(reference));

Attributes\AttributeTests_Security.cs (2)

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

Attributes\AttributeTests_StructLayout.cs (3)

647Assert.True(badLayout); 651Assert.True(hasClassLayout); 659Assert.True(hasClassLayout);

Attributes\AttributeTests_Tuples.cs (1)

647Assert.True(constant.Type.SpecialType == SpecialType.System_String);

Attributes\AttributeTests_WellKnownAttributes.cs (8)

524Assert.True(attributeInfo.HasValue); 3680Assert.True(((Cci.IMethodDefinition)ctorA.GetCciAdapter()).IsExternal); 3683Assert.True(methodGoo.IsExternal); 4902Assert.True(typeC.IsSerializable); 4978Assert.True(((NamedTypeSymbol)substitutedNestedS).IsSerializable); 4982Assert.True(((NamedTypeSymbol)valueTupleS).IsSerializable); 4990Assert.True(((NamedTypeSymbol)constructedS).IsSerializable); 5754Assert.True(method.RequiresSecurityObject);

Attributes\InternalsVisibleToAndStrongNameTests.cs (48)

Diagnostics\CompilationEventTests.cs (2)

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

Diagnostics\DiagnosticAnalyzerTests.cs (9)

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); 3577Assert.True(first.Concurrent); 3717Assert.True(diagnostics.ContainsKey(analyzer)); 4406Assert.True(analyzer.AnalyzerInvoked);

Diagnostics\GetDiagnosticsTests.cs (31)

FieldKeywordTests.cs (170)

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 (10)

561Assert.True(e1.IsPartialDefinition); 566Assert.True(e2.IsPartialImplementation); 1234Assert.True(e.IsStatic); 1250Assert.True(m.IsStatic); 1953Assert.True(cImpl.IsPartialImplementation); 2006Assert.True(defSymbol.IsPartialDefinition); 2024Assert.True(defSymbol.IsPartialDefinition); 2045Assert.True(defSymbol.IsPartialDefinition); 2082Assert.True(defSymbol.IsPartialDefinition); 2113Assert.True(defSymbol.IsPartialDefinition);

RefReadonlyParameterTests.cs (3)

95Assert.True(method.HasUnsupportedMetadata); 96Assert.True(method.HasUseSiteError); 6696Assert.True(m1 is not RetargetingMethodSymbol);

RefStructInterfacesTests.cs (21)

157Assert.True(propertySymbol.HasUnscopedRefAttribute); 189Assert.True(propertySymbol.HasUnscopedRefAttribute); 404Assert.True(propertySymbol.HasUnscopedRefAttribute); 436Assert.True(propertySymbol.HasUnscopedRefAttribute); 496Assert.True(propertySymbol.HasUnscopedRefAttribute); 2446Assert.True(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefLikeGenerics)); 4388Assert.True(comp.SupportsRuntimeCapability(RuntimeCapability.ByRefLikeGenerics)); 14262Assert.True(info.IsAsynchronous); 14603Assert.True(info.IsAsynchronous); 14970Assert.True(info.IsAsynchronous); 15313Assert.True(info.IsAsynchronous); 15661Assert.True(info.IsAsynchronous); 16099Assert.True(info.IsAsynchronous); 16764Assert.True(info.IsAsynchronous); 16829Assert.True(info.IsAsynchronous); 16894Assert.True(info.IsAsynchronous); 16978Assert.True(info.IsAsynchronous); 17066Assert.True(info.IsAsynchronous); 17159Assert.True(info.IsAsynchronous); 17256Assert.True(info.IsAsynchronous); 17340Assert.True(info.IsAsynchronous);

Semantics\CollectionExpressionTests.cs (66)

Semantics\ExperimentalAttributeTests.cs (2)

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

Semantics\ExtensionOperatorsTests.cs (2)

531Assert.True(method.IsStatic); 9860Assert.True(method.IsStatic);

Semantics\ExtensionTests.cs (23)

56Assert.True(symbol.IsExtension); 60Assert.True(symbol.IsReferenceType); 82Assert.True(symbol.TupleElements.IsDefault); 89Assert.True(symbol.IsDefinition); 94Assert.True(symbol.IsSealed); 245Assert.True(symbol.IsGenericType); 259Assert.True(constructed.IsExtension); 268Assert.True(unbound.IsUnboundGenericType); 324Assert.True(symbol.IsGenericType); 327Assert.True(symbol.TypeParameters.Single().IsValueType); 384Assert.True(symbol.IsGenericType); 479Assert.True(substitutedExtension.IsExtension); 621Assert.True(symbol.IsGenericType); 1810Assert.True(symbol.IsExtensionMethod); 2725Assert.True(extensionParameter.Equals(extensionParameter)); 3243Assert.True(symbol.ExtensionParameter.HasExplicitDefaultValue); 4985Assert.True(implementation.IsStatic); 4990Assert.True(implementation.IsExtensionMethod); 6440Assert.True(implementation.IsStatic); 6445Assert.True(implementation.IsExtensionMethod); 7915Assert.True(implementation.IsStatic); 9421Assert.True(implementation.IsStatic); 9710Assert.True(implementation.IsStatic);

Semantics\InlineArrayTests.cs (11)

118Assert.True(comp.SupportsRuntimeCapability(RuntimeCapability.InlineArrayTypes)); 121Assert.True(vbComp.SupportsRuntimeCapability(RuntimeCapability.InlineArrayTypes)); 18591Assert.True(model.GetConversion(f).IsIdentity); 18601Assert.True(forEachInfo.ElementConversion.IsIdentity); 18602Assert.True(forEachInfo.CurrentConversion.IsIdentity); 18917Assert.True(model.GetConversion(f).IsIdentity); 18927Assert.True(forEachInfo.ElementConversion.IsIdentity); 18928Assert.True(forEachInfo.CurrentConversion.IsIdentity); 19254Assert.True(model.GetConversion(collection).IsIdentity); 19264Assert.True(forEachInfo.ElementConversion.IsIdentity); 19265Assert.True(forEachInfo.CurrentConversion.IsIdentity);

Semantics\OutVarTests.cs (59)

Semantics\ParamsCollectionTests.cs (16)

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); 9041Assert.True(module.FindTargetAttribute(p1.Handle, AttributeDescription.ScopedRefAttribute).HasValue);

Semantics\PatternMatchingTestBase.cs (19)

Semantics\PatternMatchingTests.cs (1)

3269Assert.True(symbolInfo.CandidateSymbols.IsDefaultOrEmpty);

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 (13)

410Assert.True(success); 715Assert.True(success); 984Assert.True(success); 1288Assert.True(success); 5344Assert.True(success); 6474Assert.True(success); 6885Assert.True(success); 7214Assert.True(success); 7537Assert.True(success); 9643Assert.True(success); 10206Assert.True(success); 10722Assert.True(success); 12147Assert.True(success);

Semantics\PatternMatchingTests2.cs (2)

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

Semantics\PrimaryConstructorTests.cs (100)

Semantics\RecordTests.cs (65)

Symbols\UserDefinedCompoundAssignmentOperatorsTests.cs (150)

EndToEndTests.cs (1)

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\SyntaxUtilitiesTests.cs (8)

ExtractClass\ExtractClassTests.cs (1)

3136Assert.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\AnonymousFunctionTests.cs (3)

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

Semantics\AwaitExpressionTests.cs (1)

412Assert.True(info.IsDynamic);

Semantics\BindingAsyncTasklikeMoreTests.cs (8)

111Assert.True(method.IsAsync); 114Assert.True(method.IsAsync); 436Assert.True(method.IsAsync); 440Assert.True(method.IsAsync); 517Assert.True(method.IsAsync); 521Assert.True(method.IsAsync); 596Assert.True(method.IsAsync); 600Assert.True(method.IsAsync);

Semantics\BindingAsyncTasklikeTests.cs (2)

189Assert.True(diagnostics.Length == 1); 190Assert.True(diagnostics.First().Code == (int)ErrorCode.ERR_AmbigCall);

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 (78)

Semantics\DelegateTypeTests.cs (7)

905Assert.True(HaveMatchingSignatures(((INamedTypeSymbol)typeInfo.Type!).DelegateInvokeMethod!, method)); 948Assert.True(HaveMatchingSignatures(((INamedTypeSymbol)typeInfo.Type!).DelegateInvokeMethod!, method)); 8157Assert.True(HaveMatchingSignatures(((INamedTypeSymbol)typeInfo.Type!).DelegateInvokeMethod!, method)); 12218Assert.True(model.TryGetSpeculativeSemanticModel(position, stmt, out model)); 14485Assert.True(delegateType.IsImplicitlyDeclared); 15715Assert.True(functionTypeStringNotNullable.Equals(functionTypeStringNullable, TypeCompareKind.AllIgnoreOptions)); 15719Assert.True(functionTypeNullA.Equals(functionTypeNullA, TypeCompareKind.ConsiderEverything));

Semantics\DynamicTests.cs (9)

Semantics\ExpressionBodiedMemberTests.cs (4)

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

Semantics\ForEachTests.cs (15)

Semantics\FunctionPointerTests.cs (12)

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 (1)

6706Assert.True(c2Type.Interfaces().All(iface => iface.Name == "I1" || iface.Name == "I2"));

Semantics\InitOnlyMemberTests.cs (26)

Semantics\InterceptorsTests.cs (2)

6788Assert.True(interceptor!.IsDefinition); 7222Assert.True(comp.InterceptorsDiscoveryComplete);

Semantics\InterpolationTests.cs (15)

Semantics\IteratorTests.cs (5)

42Assert.True(publicI.IsIterator); 48Assert.True(publicI.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 (26)

Semantics\LocalFunctionTests.cs (13)

351Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m.Body.SpanStart, m, out model)); 407Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(m.Body.SpanStart, m, out model)); 446Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(mMethod.Body.SpanStart, mMethod, out var newModel)); 6896Assert.True(method.IsStatic); 6921Assert.True(method.IsStatic); 6922Assert.True(method.IsGenericMethod); 6951Assert.True(method.IsStatic); 6952Assert.True(method.IsGenericMethod); 7369Assert.True(success); 8742Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel)); 8950Assert.True(success); 10751Assert.True(i1Symbol.IsIterator); 10755Assert.True(i2Symbol.IsIterator);

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 (2)

537Assert.True(szArray.IsSZArray); 1684Assert.True(a1.IsSZArray);

Semantics\NameOfTests.cs (9)

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

Semantics\NativeIntegerTests.cs (29)

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); 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); 2642Assert.True(type.IsNativeIntegerWrapperType); 2744Assert.True(type.IsNativeIntegerWrapperType); 2884Assert.True(type.IsNativeIntegerWrapperType); 3727Assert.True(underlyingType1.IsNativeIntegerWrapperType); 3761Assert.True(underlyingType1.IsNativeIntegerWrapperType); 4083Assert.True(type.IsNativeIntegerType); 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\NullableReferenceTypesTests.cs (137)

Semantics\OperatorTests.cs (10)

7620Assert.True(symbol1.IsImplicitlyDeclared); 7663Assert.True(symbol1.IsStatic); 7723Assert.True(symbol2.IsCheckedBuiltin); 8092Assert.True(CandidateReason.LateBound == info1.CandidateReason || CandidateReason.None == info1.CandidateReason); 8396Assert.True(symbol1.IsImplicitlyDeclared); 8432Assert.True(SymbolEqualityComparer.ConsiderEverything.Equals(symbol1.ContainingSymbol, symbol1.Parameters[0].Type) || 8451Assert.True(match >= 2); 8458Assert.True(symbol1.IsStatic); 8606Assert.True(symbol2.IsCheckedBuiltin); 8704Assert.True(symbol2.IsCheckedBuiltin);

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 (3)

2911Assert.True(semanticInfo.ImplicitConversion.Exists); 2912Assert.True(semanticInfo.ImplicitConversion.IsValid); 2913Assert.True(semanticInfo.ImplicitConversion.IsInterpolatedStringHandler);

Semantics\ReadOnlyStructsTests.cs (14)

Semantics\RecordStructTests.cs (46)

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\RefFieldTests.cs (42)

Semantics\ScriptSemanticsTests.cs (2)

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

Semantics\SemanticErrorTests.cs (3)

25186Assert.True(bSymbol.HasComplete(CompletionPart.All)); 25290Assert.True(aSymbol.HasComplete(CompletionPart.All)); 25351Assert.True(bSymbol.HasComplete(CompletionPart.All));

Semantics\SimpleLambdaParametersWithModifiersTests.cs (31)

Semantics\StructConstructorTests.cs (4)

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\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 (37)

Semantics\UnsafeTests.cs (28)

Semantics\UseSiteErrorTests.cs (1)

2443Assert.True(diagnostics.Any(d => d.Code == (int)ErrorCode.ERR_NoTypeDef));

Semantics\Utf8StringsLiteralsTests.cs (10)

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)); 2604Assert.True(generatorCancelled); 2701Assert.True(driver.GetRunResult().Diagnostics.IsEmpty); 2711Assert.True(driver.GetRunResult().Diagnostics.IsEmpty); 2718Assert.True(compilation.SyntaxTrees.Contains(node.SyntaxTree)); 3407Assert.True(capacity >= builder.Capacity); 3564Assert.True(timing.ElapsedTime >= generatorTiming.ElapsedTime); 3605Assert.True(timing.ElapsedTime >= timing1.ElapsedTime); 3610Assert.True(timing.ElapsedTime >= timing2.ElapsedTime); 3612Assert.True(timing.ElapsedTime >= timing1.ElapsedTime + timing2.ElapsedTime); 3644Assert.True(timing.ElapsedTime >= generatorTiming.ElapsedTime); 3651Assert.True(timing.ElapsedTime > timing2.ElapsedTime); 3656Assert.True(generatorTiming.ElapsedTime > generatorTiming2.ElapsedTime); 4088Assert.True(wasCalled); 4126Assert.True(wasCalled); 4155Assert.True(gen1Called); 4174Assert.True(gen2Called); 4430Assert.True(executeCalled); 4527Assert.True(result.Results[1].GeneratedSources.IsDefault); 4545Assert.True(stepRan); 4581Assert.True(initWasCalled);

SourceGeneration\GeneratorDriverTests_Attributes_FullyQualifiedName.cs (56)

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 (23)

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\GetSemanticInfoTests.cs (95)

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 (35)

Compilation\SemanticModelGetSemanticInfoTests.cs (76)

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

129Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "C", "D" })); 160Assert.True(table.TypeNames.Distinct().OrderBy(s => s).SequenceEqual(new[] { "C", "D" })); 236Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B" })); 239Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B", "C", "D" })); 242Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B" })); 245Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B", "C", "D" })); 248Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "C", "D" }));

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

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)); 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\CompilationCreationTests.cs (19)

Symbols\ConversionTests.cs (28)

Symbols\CorLibrary\CorTypes.cs (5)

102Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 144Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 163Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 197Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes); 209Assert.True(msCorLibRef.KeepLookingForDeclaredSpecialTypes);

Symbols\CovariantReturnTests.cs (8)

263Assert.True(method.IsOverride); 265Assert.True(method.IsMetadataVirtual(MethodSymbol.IsMetadataVirtualOption.IgnoreInterfaceImplementationChanges)); 341Assert.True(false); 471Assert.True(sourceAssembly is SourceAssemblySymbol); 523Assert.True(retargetingAssembly is RetargetingAssemblySymbol); 4880Assert.True(useMethodImpl); 4944Assert.True(useMethodImpl); 5008Assert.True(useMethodImpl);

Symbols\CSharpCompilerFeatureRequiredTests.cs (5)

145Assert.True(onType!.HasUnsupportedMetadata); 203Assert.True(onEnum!.HasUnsupportedMetadata); 210Assert.True(onClassTypeParameter!.HasUnsupportedMetadata); 211Assert.True(onClassTypeParameter.TypeParameters[0].HasUnsupportedMetadata); 220Assert.True(onDelegateType!.HasUnsupportedMetadata);

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 (225)

Symbols\ExtendedPartialMethodsTests.cs (2)

1163Assert.True(implementation.IsExtern); 2261Assert.True(m.IsStatic);

Symbols\ExtensionMethodTests.cs (3)

228Assert.True(gooSymbol.IsExtensionMethod); 231Assert.True(gooOriginal.IsExtensionMethod); 2499Assert.True(mightContainExtensionMethods);

Symbols\FunctionPointerTypeSymbolTests.cs (6)

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)); 1965Assert.True(FunctionPointerTypeSymbol.IsCallingConventionModifier(testConvention));

Symbols\GenericConstraintTests.cs (15)

Symbols\ImplicitClassTests.cs (3)

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

Symbols\IndexerTests.cs (8)

179Assert.True(property.IsIndexer); 200Assert.True(setter.ReturnsVoid); 1516Assert.True(derivedType.Indexers.All(i => i.MetadataName == "A")); 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()));

Symbols\InterfaceImplementationTests.cs (14)

586Assert.True(class1.Interfaces().Contains(@interface)); 635Assert.True(class1.Interfaces().Contains(@interface)); 745Assert.True(baseClassMethodVirtual.IsVirtual); 761Assert.True(class1MethodVirtual.IsOverride); 779Assert.True(class2MethodVirtual.IsOverride); 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"));

Symbols\LocalFunctionTests.cs (1)

58Assert.True(local.IsStatic);

Symbols\Metadata\MetadataMemberTests.cs (7)

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\PE\HasUnsupportedMetadata.cs (4)

372Assert.True(f1.HasUnsupportedMetadata); 376Assert.True(m1.HasUnsupportedMetadata); 384Assert.True(e1.HasUnsupportedMetadata); 388Assert.True(p1.HasUnsupportedMetadata);

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

76Assert.True(p4.HasUnsupportedMetadata); 79Assert.True(m5.ReturnsVoid);

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

202Assert.True(@class.Interfaces().Contains(@interface)); 297Assert.True(refInterface.Interfaces().Contains(defInterface));

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\LoadingIndexers.cs (1)

606Assert.True(indexer.MustCallMethodsDirectly);

Symbols\Metadata\PE\LoadingMethods.cs (51)

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

36Assert.True(@class.Interfaces().Contains(@interface)); 131Assert.True(refInterface.Interfaces().Contains(defInterface));

Symbols\Metadata\PE\MissingTypeReferences.cs (12)

48Assert.True(@base.IsType); 66Assert.True(@base.IsType); 103Assert.True(@base.IsType); 132Assert.True(@base.IsType); 147Assert.True(@base.IsType); 162Assert.True(@base.IsType); 179Assert.True(@base.IsType); 196Assert.True(@base.IsType); 215Assert.True(@base.IsType); 233Assert.True(@base.IsType); 255Assert.True(@base.IsType); 377Assert.True(missingAssembly.Equals(missingAssembly));

Symbols\Metadata\PE\NoPia.cs (6)

755Assert.True(pia1Link.Properties.EmbedInteropTypes); 757Assert.True(pia5Link.Properties.EmbedInteropTypes); 759Assert.True(library2Link.Properties.EmbedInteropTypes); 1110Assert.True(pia5Link.Properties.EmbedInteropTypes); 1118Assert.True(pia1Link.Properties.EmbedInteropTypes); 1126Assert.True(library2Link.Properties.EmbedInteropTypes);

Symbols\Metadata\PE\NoPiaInstantiationOfGenericClassAndStruct.cs (3)

469Assert.True(classLocalType.IsFromCompilation(localConsumer)); 470Assert.True(classLocalType.IsValueType); 506Assert.True(localField.Type is ArrayTypeSymbol);

Symbols\Metadata\PE\TypeForwarders.cs (4)

66Assert.True(module1.TypeRefHandleToTypeMap.Values.Contains((TypeSymbol)base4.OriginalDefinition)); 67Assert.True(module1.TypeRefHandleToTypeMap.Values.Contains((TypeSymbol)base6.OriginalDefinition)); 1640Assert.True(token.IsNil); //could the type ref be located? If not then the attribute's not there. 1713Assert.True(token.IsNil); //could the type ref be located? If not then the attribute's not there.

Symbols\MethodEqualityTests.cs (1)

223Assert.True(invokedMethods.All(m => m.Equals(m)));

Symbols\MissingSpecialMember.cs (1)

915Assert.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 (9)

368Assert.True(prop.IsPartialDefinition); 372Assert.True(duplicateProp.IsPartialImplementation); 405Assert.True(prop.IsPartialDefinition); 409Assert.True(duplicateProp.IsPartialDefinition); 2815Assert.True(p.IsStatic); 2831Assert.True(m.IsStatic); 5239Assert.True(defSymbol.IsPartialDefinition); 5276Assert.True(defSymbol.IsPartialDefinition); 5323Assert.True(defSymbol.IsPartialDefinition);

Symbols\RequiredMembersTests.cs (3)

67Assert.True(type.HasAnyRequiredMembers); 7177Assert.True(field1.IsRequired); 7178Assert.True(property1.IsRequired);

Symbols\Retargeting\RetargetCustomModifiers.cs (2)

87Assert.True(m5.ReturnsVoid); 177Assert.True(volatileFld.IsVolatile);

Symbols\Retargeting\RetargetExplicitInterfaceImplementation.cs (1)

99Assert.True(false);

Symbols\Source\BaseClassTests.cs (1)

1347Assert.True(carr2.IsSZArray);

Symbols\Source\ClsComplianceTests.cs (1)

2114Assert.True(accessor.Name[0] == '_');

Symbols\Source\CompletionTests.cs (1)

117Assert.True(SymbolCompletionState.HasAtMostOneBitSet((int)state.NextIncompletePart));

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 (4)

131Assert.True(v.IsReferenceType); 133Assert.True(v.IsSealed); 831Assert.True(lambda.ReturnsByRefReadonly); 838Assert.True(lambda.ReturnsByRefReadonly);

Symbols\Source\ExpressionBodiedMethodTests.cs (3)

47Assert.True(gooImpl.IsPartial); 48Assert.True(gooImpl.IsPartialImplementation); 50Assert.True(gooImpl.IsExpressionBodied);

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 (6)

145Assert.True(n1.IsConst); 147Assert.True(n1.IsStatic); 152Assert.True(n2.IsVolatile); 162Assert.True(n3.IsStatic); 258Assert.True(mem.IsConst); 500Assert.True(goo.IsFixedSizeBuffer);

Symbols\Source\FileModifierTests.cs (33)

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 (50)

39Assert.True(m.ReturnsVoid); 120Assert.True(m.ReturnsVoid); 144Assert.True(m.ReturnsVoid); 450Assert.True(method.IsDefinition); 609Assert.True(m1.IsOverride); 616Assert.True(m2.IsOverride); 623Assert.True(m3.IsOverride); 624Assert.True(m3.IsSealed); 630Assert.True(m4.IsOverride); 640Assert.True(m5.IsStatic); 645Assert.True(m6.IsOverride); 673Assert.True(m1.IsAbstract); 680Assert.True(m2.IsAbstract); 690Assert.True(m3.IsVirtual); 697Assert.True(m4.IsVirtual); 705Assert.True(m5.IsStatic); 709Assert.True(m6.IsAbstract); 802Assert.True(m1.IsOverride); 809Assert.True(m2.IsOverride); 816Assert.True(m3.IsOverride); 817Assert.True(m3.IsSealed); 823Assert.True(m4.IsOverride); 833Assert.True(m5.IsStatic); 838Assert.True(m6.IsOverride); 868Assert.True(m1.IsAbstract); 875Assert.True(m2.IsAbstract); 885Assert.True(m3.IsVirtual); 892Assert.True(m4.IsVirtual); 900Assert.True(m5.IsStatic); 904Assert.True(m6.IsAbstract); 1173Assert.True(type1.IsValueType); 1190Assert.True(m2.ReturnsVoid); 1210Assert.True(type2.IsReferenceType); 1232Assert.True(m2.ReturnsVoid); 1265Assert.True(type1.IsReferenceType); 1284Assert.True(m2.ReturnsVoid); 1290Assert.True(m3.ReturnsVoid); 1598Assert.True(f.IsOverride); 1674Assert.True(@class.Interfaces().Contains(@interface)); 1718Assert.True(@class.Interfaces().Contains(@interface)); 1764Assert.True(@class.Interfaces().Contains(@interface)); 1864Assert.True(method1.IsVirtual); 1865Assert.True(method2.IsVirtual); 1870Assert.True(((Cci.IMethodDefinition)method1.GetCciAdapter()).IsVirtual); 1881Assert.True(((Cci.IMethodDefinition)method2.GetCciAdapter()).IsVirtual); 1882Assert.True(((Cci.IMethodDefinition)method4.GetCciAdapter()).IsVirtual); 1885Assert.True(method1.IsVirtual); 1886Assert.True(method2.IsVirtual); 2544Assert.True(partialDef.IsPartialDefinition); 2579Assert.True(partialDef.IsPartialDefinition);

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\NullablePublicAPITests.cs (28)

Symbols\Source\PropertyTests.cs (17)

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); 2669Assert.True(comp.ExternalReferences[1].Properties.EmbedInteropTypes); 2708Assert.True(comp.ExternalReferences[1].Properties.EmbedInteropTypes); 2726Assert.True(comp.ExternalReferences[1].Properties.EmbedInteropTypes);

Symbols\Source\RecordTests.cs (22)

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 (191)

Symbols\SymbolDistinguisherTests.cs (1)

701Assert.True(AreEqual(new SymbolDistinguisher(compilation, sA, sB), new SymbolDistinguisher(compilation, sA, sB)));

Symbols\SymbolEqualityTests.cs (20)

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 (1)

18461Assert.True(methods.Any(n => n.StartsWith("A..ctor", StringComparison.Ordinal)));

Symbols\SymbolExtensionTests.cs (1)

282Assert.True(Array.IndexOf(namespaceNames, expectedName) >= 0);

Symbols\TypeTests.cs (11)

471Assert.True(field1.IsDefinition); 472Assert.True(field1.IsStatic); 486Assert.True(field1.IsDefinition); 496Assert.True(method.IsDefinition); 642Assert.True(obj.IsDefinition); 650Assert.True(dyn.IsDefinition); 1686Assert.True(anonymousType.IsAnonymousType); 2458Assert.True(member is NamedTypeSymbol); 2469Assert.True(uniqueMethods.Add(method)); 2624Assert.True(member is NamedTypeSymbol); 2636Assert.True(uniqueTypes.Add(nestedType));

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 (1)

138Assert.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); 9641Assert.True(root.ContainsDirectives); 9655Assert.True(root.ContainsDirectives); 9667Assert.True(root.ContainsDirectives); 9726Assert.True(trivia.IsDirective); 9728Assert.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 (54)

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 (8)

40Assert.True(symbol.IsValueType); 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)); 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 (4)

3571Assert.True(@event.IsWindowsRuntimeEvent); 3587Assert.True(removeMethod.ReturnsVoid); 3612Assert.True(addMethod.ReturnsVoid); 3618Assert.True(removeMethod.ReturnsVoid);

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

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 (13)

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); 300Assert.True(extensionManager.IsDisabled(codefix)); 322Assert.True(extensionManager.IsDisabled(codefix)); 324Assert.True(errorReported); 1067Assert.True(appliedChanges);

CodeFixes\ExtensionOrderingTests.cs (9)

44Assert.True(actualOrder.Length > 0); 45Assert.True(actualOrder.IndexOf(p => p.Metadata.Name == PredefinedCodeFixProviderNames.AddImport) < 51Assert.True(actualOrder.Length > 0); 52Assert.True(actualOrder.IndexOf(p => p.Metadata.Name == PredefinedCodeFixProviderNames.AddImport) < 104Assert.True(actualOrder.Length > 0); 109Assert.True(actualOrder.Length > 0); 135Assert.True(codeFixPriorityMap.Count > 0); 143Assert.True(currentIndex >= 0); 150Assert.True(nextIndex > currentIndex);

CodeRefactorings\CodeRefactoringServiceTest.cs (3)

54Assert.True(stubRefactoringAction is object); 111Assert.True(extensionManager.IsDisabled(codeRefactoring)); 114Assert.True(errorReported);

Collections\Immutable\Maps\BidirectionalMapTests.cs (32)

Completion\FileSystemCompletionHelperTests.cs (1)

23Assert.True(actual.All(i => i.Rules == TestFileSystemCompletionHelper.CompletionRules));

Completion\GlobalAssemblyCacheCompletionHelperTests.cs (1)

39Assert.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)

175Assert.True(applied); 336Assert.True(workspace.TryApplyChanges(solution)); 386Assert.True(applied); 480Assert.True(diagnostic != null); 486Assert.True(diagnostic == null); 794Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(new TestGeneratorReference(generator)).Solution));

Diagnostics\DiagnosticDataTests.cs (1)

220Assert.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 (6)

143Assert.True(sessionState.IsSessionActive); 157Assert.True(sessionState.IsSessionActive); 312Assert.True(sessionState.IsSessionActive); 321Assert.True(called); 330Assert.True(called); 333Assert.True(sessionState.IsSessionActive);

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)

45Assert.True(line.GetText().StartsWith("line", StringComparison.Ordinal));

Extensions\ITextLineExtensionsTests.cs (4)

75Assert.True(value); 82Assert.True(value); 89Assert.True(value); 96Assert.True(value);

Extensions\ITextSnapshotLineExtensionsTests.cs (4)

134Assert.True(value); 141Assert.True(value); 148Assert.True(value); 155Assert.True(value);

InheritanceMargin\InheritanceMarginTests.cs (1)

327Assert.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 (8)

56Assert.True(previewWorkspace.TryApplyChanges(project.Solution)); 59Assert.True(previewWorkspace.TryApplyChanges(newSolution)); 70Assert.True(previewWorkspace.TryApplyChanges(project.Solution)); 75Assert.True(previewWorkspace.TryApplyChanges(addedSolution)); 81Assert.True(previewWorkspace.TryApplyChanges(changedSolution)); 88Assert.True(previewWorkspace.TryApplyChanges(removedSolution)); 102Assert.True(previewWorkspace.TryApplyChanges(document.Project.Solution)); 106Assert.True(previewWorkspace.IsDocumentOpen(document.Id));

RenameTracking\RenameTrackingTaggerProviderTests.cs (1)

882Assert.True(RenameTrackingTaggerProvider.IsRenamableIdentifierFastCheck(source.Task, out _));

Structure\StructureTaggerTests.cs (2)

89Assert.True(methodTag.IsImplementation); 297Assert.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()); 711Assert.True(typesThatDerive.Any(t => t.Name == "T_DependProject_Class")); 718Assert.True(typesThatDerive.Any(t => t.Name == "T_DependProject_Class")); 725Assert.True(typesThatDerive.Any(t => t.Name == "T_DependProject_Class")); 824Assert.True(classInSource.Locations.Any(loc => loc.IsInMetadata)); 831Assert.True(sourceDefinition.Locations.Any(loc => loc.IsInSource)); 872Assert.True(classInSource.Locations.Any(loc => loc.IsInMetadata)); 879Assert.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)

45Assert.True(container == newSourceText.Container);

Utilities\BloomFilterTests.cs (2)

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\SymbolEquivalenceComparerTests.cs (93)

ParsingTestBase.cs (2)

44Assert.True(typeArguments.Length > 0); 60Assert.True(typeArguments.Length > 0);

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)

68Assert.True(result.Success);

EditAndContinue\EditAndContinueTestVerifier.cs (4)

140Assert.True(editScripts.Length == expectedResults.Length); 210Assert.True(expectedResult.SemanticEdits.IsEmpty); 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)

111Assert.True(reader.TryGetDocumentChecksum("/a/c.cs", out var actualChecksum, out var actualAlgorithm));

EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (2)

1029Assert.True(sourceTextProviderCalled); 1821Assert.True(documentDifferences.IsEmpty);

EditAndContinue\RemoteEditAndContinueServiceTests.cs (1)

254Assert.True(called);

Commands\ExecuteWorkspaceCommandTests.cs (1)

42Assert.True((bool)response);

Completion\CompletionFeaturesTests.cs (2)

758Assert.True(results.Items.All(item => item.CommitCharacters is null)); 1099Assert.True(results.Items.Any(i => i.Label == "if"));

Completion\CompletionTests.cs (15)

Configuration\DidChangeConfigurationNotificationHandlerTest.cs (2)

93Assert.True(clientCallbackTarget.WorkspaceDidChangeConfigurationRegistered); 341Assert.True(match.Success);

Diagnostics\PullDiagnosticTests.cs (6)

779Assert.True(results.Single().Diagnostics![0].Tags!.Contains(DiagnosticTag.Unnecessary)); 789Assert.True(results.Single().Diagnostics![0].Tags!.Contains(DiagnosticTag.Unnecessary)); 852Assert.True(results.Single().Diagnostics![1].Tags!.Contains(DiagnosticTag.Unnecessary)); 856Assert.True(results.Single().Diagnostics![2].Tags!.Contains(DiagnosticTag.Unnecessary)); 862Assert.True(results.Single().Diagnostics!.Single().Tags!.Contains(DiagnosticTag.Unnecessary)); 1071Assert.True(results[1].Diagnostics!.Single().Message.Contains("Source generator failed"));

DocumentChanges\DocumentChangesTests.cs (1)

387Assert.True(DidChangeHandler.AreChangesInReverseOrder([change1, change2, change3]));

HandlerTests.cs (2)

165Assert.True(didReport); 223Assert.True(didReport);

InlayHint\CSharpInlayHintTests.cs (1)

147Assert.True(lastInlayHints.Any());

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

Ordering\RequestOrderingTests.cs (15)

ProtocolConversionsTests.cs (1)

335Assert.True(projectContext.IsMiscellaneous);

References\FindAllReferencesHandlerTests.cs (2)

229Assert.True(results.All(r => r.Location != null)); 322Assert.True(results[0].Location.DocumentUri.ToString().EndsWith("String.cs"));

Rename\RenameTests.cs (1)

186Assert.True(documentEdit.Edits.All(edit => edit.Unify().NewText == renameText));

SemanticTokens\AbstractSemanticTokensTests.cs (1)

83Assert.True(tokens.Length % 5 == 0);

SemanticTokens\SemanticTokensRangeTests.cs (1)

604Assert.True(schema.AllTokenTypes.Contains(tokenName));

SpellCheck\SpellCheckTests.cs (2)

92Assert.True(results.Length == 6); 355Assert.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 (2)

368Assert.True(areEqual == (documentUri1 == documentUri2)); 369Assert.True(areEqual != (documentUri1 != documentUri2));

Workspaces\LspWorkspaceManagerTests.cs (8)

LspFileChangeWatcherTests.cs (3)

41Assert.True(LspFileChangeWatcher.SupportsLanguageServerHost(testLspServer.LanguageServerHost)); 126Assert.True(Registrations.TryAdd(registration.Id, registration)); 135Assert.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));

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)

1206Assert.True(value is true);

Analyzers\AnalyzerConfigTests.cs (106)

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 (1)

246Assert.True(i2.MoveNext());

Collections\Extensions\EnumerableExtensionsTests.cs (8)

31Assert.True(RoslynEnumerableExtensions.SequenceEqual((IEnumerable<int>)null, null, comparer)); 35Assert.True(RoslynEnumerableExtensions.SequenceEqual(new[] { 1 }, new[] { 1 }, comparer)); 39Assert.True(RoslynEnumerableExtensions.SequenceEqual(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, comparer)); 105Assert.True(elements.SequenceEqual(result)); 112Assert.True(MakeEnumerable(1, 2, 3, 4).SequenceEqual(elements.Concat(4))); 139Assert.True(sequence.Flatten().SequenceEqual(MakeEnumerable("a", "b", "c", "d", "e", "f"))); 149Assert.True(seq.SequenceEqual(seq, equality)); 152Assert.True(seq.SequenceEqual(new int[] { 1, 2, 3 }, equality));

Collections\Extensions\ImmutableArrayExtensionsTests.cs (51)

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 (17)

Collections\ImmutableSegmentedDictionaryTest.cs (9)

43Assert.True(map.ContainsKey("Johnny")); 163Assert.True(IsSame(dictionary, result)); 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 (27)

Collections\ImmutableSegmentedHashSetTest.cs (3)

55Assert.True(ignoreCaseSet.Contains("aPpLe")); 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 (17)

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

Collections\ImmutableSegmentedListTest.cs (22)

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 (2)

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\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 (30)

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

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)

MSBuildWorkspaceTestBase.cs (1)

139Assert.True(result.Success);

NewlyCreatedProjectsFromDotNetNew.cs (1)

134Assert.True(foundDivider);

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) || 408Assert.True(dversion1.GetTestAccessor().IsNewerThan(dversion)); 413Assert.True(latestDV1.GetTestAccessor().IsNewerThan(latestDV)); 422Assert.True(document2.Project.Version.GetTestAccessor().IsNewerThan(document1.Project.Version)); 429Assert.True(solution3.Version.GetTestAccessor().IsNewerThan(solution2.Version)); 1881Assert.True(options.PreprocessorSymbolNames.Contains("EnableMyAttribute")); 1982Assert.True(File.Exists(fooDoc.FilePath)); 2313Assert.True(analyzerReference.FullPath.EndsWith("CSharpProject.dll", StringComparison.OrdinalIgnoreCase)); 2897Assert.True(noEncodingSolution.Workspace.TryApplyChanges(noEncodingSolution)); 2942Assert.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));

Workspaces\TestWorkspace`1.cs (1)

637Assert.True(document.IsLinkFile || documentFilePaths.Add(document.FilePath!));

ChecksumTests.cs (1)

147Assert.True((i == j) == (checksums[i] == checksums[j]));

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)

145Assert.True(csharpResult.Count() > 0); 148Assert.True(vbResult.Count() > 0);

FindReferencesTests.cs (4)

400Assert.True(projectIds.Contains(netCoreProject.Id)); 630Assert.True(typeResult.Locations.All(loc => loc.Location.SourceSpan != constructorResult.Locations.Single().Location.SourceSpan)); 636Assert.True(typeResult.Locations.Count(loc => loc.Alias == null) == 1); 637Assert.True(typeResult.Locations.Count(loc => loc.Alias != null) == 1);

Formatter\FormatterTests.cs (1)

138Assert.True(formattingOptions.UseTabs);

ObjectSerializationTests.cs (5)

72Assert.True(Equalish(value, newValue)); 103Assert.True(Equalish(value, newValue)); 268Assert.True(Enumerable.SequenceEqual(expected, (byte[])reader.ReadByteArray())); 435Assert.True(reader.ReadBoolean()); 503Assert.True((bool)reader.ReadScalarValue());

Options\EditorConfigNamingStyleParserTests.cs (1)

464Assert.True(!string.IsNullOrEmpty(editorConfigString));

Options\NamingStylePreferencesTests.cs (2)

29Assert.True( 200Assert.True(type.IsEnum);

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 (50)

SolutionTests\SolutionWithSourceGeneratorTests.cs (13)

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 (28)

SyntaxPathTests.cs (23)

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)

101Assert.True(comment.HadXmlParseError); 255Assert.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\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)); 107Assert.True(Enumerable.SequenceEqual(expectedResult, namesBuilder));

UtilityTest\ReferenceHolderTests.cs (2)

94Assert.True(x.Equals(y)); 95Assert.True(y.Equals(x));

UtilityTest\SpecializedTasksTests.cs (10)

96Assert.True(task.IsCompletedSuccessfully); 118Assert.True(task.IsCanceled); 195Assert.True(task.IsCanceled); 252Assert.True(task.IsCanceled); 290Assert.True(task.IsCanceled); 319Assert.True(task.IsCanceled); 357Assert.True(task.IsCanceled); 400Assert.True(task.IsFaulted); 480Assert.True(task.IsCanceled); 515Assert.True(task.IsCanceled);

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 (1)

123Assert.True(destination.SequenceEqual(destination2));

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*" }));

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)

297Assert.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)

223Assert.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)

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); 433Assert.True(options.IsReadOnly);

AgentQualityEvaluatorTests.cs (10)

QualityEvaluatorTests.cs (24)

ResultsTests.cs (24)

SafetyEvaluatorTests.cs (51)

BLEUEvaluatorTests.cs (1)

44Assert.True(metric.Interpretation.Failed);

NGramTests.cs (5)

34Assert.True(a.Equals(b)); 35Assert.True(a.Equals((object)b)); 69Assert.True(result.SequenceEqual(expected)); 73Assert.True(result.SequenceEqual(expected)); 77Assert.True(result.SequenceEqual(expected));

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)

102Assert.True(entry.Messages.SequenceEqual(deserialized.Messages, ChatMessageComparer.Instance)); 104Assert.True(entry.ChatDetails!.TurnDetails.SequenceEqual(deserialized.ChatDetails!.TurnDetails!, ChatTurnDetailsComparer.Instance)); 105Assert.True(entry.Tags!.SequenceEqual(deserialized.Tags!)); 195Assert.True(entry.Messages.SequenceEqual(deserialized.ScenarioRunResults[0].Messages, ChatMessageComparer.Instance)); 197Assert.True(entry.ChatDetails!.TurnDetails.SequenceEqual(deserialized.ScenarioRunResults[0].ChatDetails!.TurnDetails!, ChatTurnDetailsComparer.Instance)); 198Assert.True(entry.Tags!.SequenceEqual(deserialized.ScenarioRunResults[0].Tags!)); 221Assert.True(defaultJson.Length > compactJson.Length); 277Assert.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); 578Assert.True(callCount >= 1); 599Assert.True(shieldsUp); 919Assert.True(activity.Duration.TotalMilliseconds > 0); 990Assert.True(response.Result);

EmbeddingGeneratorIntegrationTests.cs (17)

OpenAIAIFunctionConversionTests.cs (2)

74Assert.True(root.TryGetProperty("properties", out var properties)); 75Assert.True(properties.TryGetProperty("name", out var nameProperty));

OpenAIAssistantChatClientIntegrationTests.cs (1)

79Assert.True(dr.Value.Deleted);

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); 793Assert.True(await actualEnumerator.MoveNextAsync());

ChatCompletion\FunctionInvocationContextTests.cs (2)

26Assert.True(ctx.Messages.IsReadOnly); 69Assert.True(ctx.Terminate);

ChatCompletion\FunctionInvokingChatClientTests.cs (4)

ChatCompletion\LoggingChatClientTests.cs (8)

ChatCompletion\OpenTelemetryChatClientTests.cs (1)

179Assert.True(activity.Duration.TotalMilliseconds > 0);

Embeddings\DistributedCachingEmbeddingGeneratorTest.cs (1)

215Assert.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);

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

14Assert.True(tags.IsEmpty); 25Assert.True(tags.IsEmpty); 36Assert.True(tags.IsEmpty); 86Assert.True(tags.IsArray); 100Assert.True(tags.IsArray); 123Assert.True(tags.IsArray); 134Assert.True(tags.IsArray);

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

ResourceMonitoringOptionsCustomValidatorTests.cs (4)

27Assert.True(result.Failed); 40Assert.True(result.Succeeded); 56Assert.True(isValid); 71Assert.True(validationResult.Failed);

ResourceMonitoringOptionsTests.cs (1)

33Assert.True(options.CalculateCpuUsageWithoutHostDelta);

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); 240Assert.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 (16)

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 (5)

105Assert.True(esSockets.IsEnabled()); 110Assert.True(esHttp.IsEnabled()); 115Assert.True(esNameRes.IsEnabled()); 133Assert.True(esSockets.IsEnabled()); 137Assert.True(esSockets.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 (2)

73Assert.True(await options.ShouldHandle(CreatePredicateArguments(null))); 84Assert.True(await options.ShouldHandle(CreatePredicateArguments(response)));

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 (9)

19Assert.True(ct.Checkpoints.Count == 0); 42Assert.True(c[i].Name == names[i]); 43Assert.True(elapsed >= t); 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 (20)

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 (13)

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); 76Assert.True(atag[0].Name == "a"); 77Assert.True(atag[0].Value == "second"); 81Assert.True(notaTag.Count == tagList.Count - 1); 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)

54Assert.True(true); 536Assert.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.ValidatableType.cs (1)

85Assert.True(validationOptions.TryGetValidatableTypeInfo(type, out var validatableTypeInfo));

ValidationsGeneratorTestBase.cs (1)

157Assert.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")));